Why can't I redefine a list in the interpreter as a result of a function on itself?

Haskell is a pure functional language , so there are no side effects and no state : every function has a result, and always the same result if its parameters are identical.

To this we must add that in Haskell all variables are, in a way, functions: A constant value like the one you have defined can be understood as a function without arguments.

In this way, your code:

let list = reverse list

could be translated into an imperative language as:

fun list () {
    return reverse(list())
}

With this hypothetical translation you should better understand what is happening: When trying to evaluate list, this translates to trying to evaluate reverse list. This is clearly recursive, and without a base case to stop it, the result is an infinite loop.

Darkhogg's answer, while it does point to a recursive definition as the cause, doesn't seem accurate to me. First of all, functional purity and statelessness are not the cause of this problem. Although it is true that we cannot modify the values ​​in Haskell, we can locally obscure the names with definitions of a shorter scope ("shadow a binding with another one in a narrower scope"). This is easy to prove in the interpreter:

GHCi, version 7.10.2: http://www.haskell.org/ghc/  :? for help
Prelude> let lista = [1..5]
Prelude> let ejemplo xs = xs ++ lista
Prelude> lista
[1,2,3,4,5]
Prelude> ejemplo [4]
[4,1,2,3,4,5]
Prelude> let lista = [1..3]
Prelude> lista
[1,2,3]
Prelude> ejemplo [4]
[4,1,2,3,4,5]

It is seen that:

1. We were able to redefine the name lista.
2. Each use of the name refers to the value that is "in scope" in that use. For example:
   • The function ejemplowas defined in a context where lista = [1..5].
   • Therefore, the value of ejemplo [4]does not change after the redefinition of lista— ejemploit remains the same function as it was at its point of definition.

The redefinition did not modify the old value of lista, its only effect is on subsequent definitions. The above definitions maintain the same original meaning. Or more precisely:

1. The scope ("scope") of each definition is the following expressions.
2. Late definitions of the same name overshadow ("shadow") earlier definitions.
3. Each use of a name refers to the closest previous definition.

The second thing to note is that it's not a good idea to think that in Haskell "all variables are, in some way, functions." Thinking that way what you do is confuse the issue. In Haskell all functions are values, but not all values ​​are functions.

To understand the difficulty of the example, what needs to be noted is that Haskell, unlike almost any other common language, allows recursive definitions not only of functions but also of values. For example, the following function builds a circular list:

cycle :: [a] -> [a]
cycle as = let result = as ++ result in result

In this definition, the variable resultis used simultaneously on the left and right sides of its definition, both as the name we define, and as an argument to the function that produces the value we assign to the name. In Haskell this works, thanks to "lazy evaluation". We can illustrate this by an equational argument:

-- Definición de `++`
(++) :: [a] -> [a] -> [a]
[] ++ ys = ys
(x:xs) ++ ys = x : (xs ++ ys)

-- Definición de `take`
take :: Int -> [a] -> [a]
take _ [] = []
take n (a:as)
  | n <= 0 = []
  | otherwise = a : take (n - 1) as

-- Demostración
take 3 (cycle [1, 2])
  = take 3 (let result = [1, 2] ++ result in result)
  = take 3 (let result = [1, 2] ++ result in [1, 2] ++ result)
  = take 3 (let result = [1, 2] ++ result in 1 : ([2] ++ result))
  = 1 : take 2 (let result = [1, 2] ++ result in [2] ++ result)
  = 1 : take 2 (let result = [1, 2] ++ result in 2 : ([] ++ result))
  = 1 : 2 : take 1 (let result = [1, 2] ++ result in [] ++ result)
  = 1 : 2 : take 1 (let result = [1, 2] ++ result in result)
  = 1 : 2 : take 1 (let result = [1, 2] ++ result in [1, 2] ++ result)
  = 1 : 2 : take 1 (let result = [1, 2] ++ result in 1 : ([2] ++ result))
  = 1 : 2 : 1 : take 0 (let result = [1, 2] ++ result in [2] ++ result)
  = 1 : 2 : 1 : []
  = [1, 2, 1]

Although this concept seems somewhat exotic, it turns out to be very useful, because it means that we can effortlessly construct graphs of immutable objects with mutual reference.

And now we can reexamine your example:

Prelude> let list = reverse list

Your expectation is that on the right side of the =, the name listrefers to its previous definition, in another scope ("scope"). In almost any other language that expectation would be correct, but it is not in Haskell—in this definition, liston the right refers to liston the left.