Haskell变量被称不可变，为何我能对其重新赋值并更新值？

Hey there! This is such a common gotcha when you're first getting your hands dirty with Haskell—let me break down what's actually happening here, because it all comes down to how Haskell thinks about names vs. mutable variables in languages like Python or Java.

First, let's get one key point straight: Haskell doesn't have mutable variables in the imperative sense. Every value you create is immutable—once it exists, it can never be changed. So when you type something like this in GHCi:

Prelude> let x = 5
Prelude> x
5
Prelude> let x = 10
Prelude> x
10

You're not modifying the original x that was bound to 5. Instead, you're creating a new binding with the same name x that points to 10. The original binding (x → 5) is still there, but it's now hidden by the new one in your current scope.

To see this in action, try a nested scope example:

Prelude> let x = 5 in (let x = 10 in x) + x
15

Here, the inner x is a new binding pointing to 10, but the outer x is still pointing to 5. The two are completely separate—we're just reusing the same name, not altering the original value.

Another way to think about it: in imperative languages, a variable is like a box you can open and put a new value into. In Haskell, a name is like a sticky note you can peel off one value and stick onto another. The original value never changes—you're just moving the label.

Even in a do block, which feels more "imperative", this is still true:

demo :: IO ()
demo = do
  let x = 5
  print x  -- Outputs 5
  let x = 10
  print x  -- Outputs 10

Again, the second let x = 10 doesn't change the first x—it just creates a new binding that shadows the old one for the rest of the block.

So to wrap it up: what you're seeing isn't "reassignment" of an immutable variable. It's name shadowing—creating a new, separate binding with the same name that hides the original. The underlying values themselves remain immutable, just like Haskell promises.

内容的提问来源于stack exchange，提问作者saketh