关于Haskell值绑定的两个技术疑问：为何支持值与值绑定及ghci字面量绑定无报错的原因

1. Why does Haskell allow binding values to values? #

Great question—this cuts to a core difference between Haskell and imperative languages. When you write something like x = 5 in Haskell, you’re not doing assignment (the kind where you overwrite a variable’s value later, like in Python or Java). Instead, you’re creating an immutable definition or alias.

Here’s what that really means:

• x and 5 become equivalent within their scope—you can substitute one for the other anywhere in your code, no exceptions.
• This ties directly to Haskell’s pure functional nature: there’s no mutable state, so "changing" a value doesn’t exist. All bindings are permanent and equation-based, just like in math.
• This enables equational reasoning, a huge advantage of functional programming. You can reason about your code by swapping values, just as you would in algebra. For example, if y = x + 3, you can safely replace x with 5 to know y will always be 8.
• It also supports recursive bindings, like the classic Fibonacci definition:

  fib 0 = 0
  fib 1 = 1
  fib n = fib (n-1) + fib (n-2)
  

  Each line is a binding that defines part of the fib function’s behavior.

2. Why doesn't GHCi throw an error for 4 = 5? #

First, let’s clear up a misunderstanding: you’re not "assigning to a literal" here—Haskell has no assignment operation at all. That line is parsed as a top-level pattern binding, and here’s why it doesn’t trigger an error:

• The left side (4) is a literal pattern. In Haskell, literal patterns only match exact values. So this binding says, "When the value 4 is matched, set it equal to 5." This is logically impossible, but syntactically valid.
• GHCi doesn’t flag this as an error because Haskell allows "unreachable" or logically contradictory bindings—they just never get executed. Since 4 can never be equal to itself and 5 at the same time, this binding has zero impact on your environment.
• Built-in literals like 4 are pre-defined by Haskell’s standard library. Your binding doesn’t overwrite or shadow this built-in value. GHCi will always use the original, pre-defined 4 when you query it, ignoring your invalid pattern binding entirely.

For contrast, if you tried this with a custom name (like x = 5 followed by x = 6), GHCi would throw a "Multiple declarations of ‘x’" error. But literals are special—their definitions are fixed, so your contradictory binding is just ignored rather than treated as a conflict.

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