GHCI Haskell not remembering bindings in command l

I am trying to learn Haskell but it is a little hard as non of my bindings are remembered from the command line; output from my terminal below.

> let b = []
> b
[]
> 1:b
[1]
> b
[]

I have no idea why this is like this can anyone please help.

What did you expect your example to do? From what you've presented, I don't see anything surprising.

Of course, that answer is probably surprising to you, or you wouldn't have asked. And I'll be honest: I can guess what you were expecting. If I'm right, you thought the output would be:

> let b = []
> b
[]
> 1:b
[1]
> b
[1]

Am I right? Supposing I am, then the question is: why isn't it?

Well, the short version is "that's not what (:) does". Instead, (:) creates a new list out of its arguments; x:xs is a new list whose first element is x and the rest of which is identical to xs. But it creates a new list. It's just like how + creates a new number that's the sum of its arguments: is the behavior

> let b = 0
> b
0
> 1+b
1
> b
0

surprising, too? (Hopefully not!)

Of course, this opens up the next question of "well, how do I update b, then?". And this is where Haskell shows its true colors: you don't. In Haskell, once a variable is bound to a value, that value will never change; it's as though all variables and all data types are const (in C-like languages or the latest Javascript standard) or val (in Scala).

This feature of Haskell – it's called being purely functional – is possibly the single biggest difference between Haskell and every single mainstream language out there. You have to think about writing programs in a very different way when you aren't working with mutable state everywhere.

For example, to go a bit further afield, it's quite possible the next thing you'll try will be something like this:

> let b = []
> b
[]
> let b = 1 : b

In that case, what do you think is going to be printed out when you type b?

Well, remember, variables don't change! So the answer is:

[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,…

forever – or until you hit control-C and abort.

This is because let b = 1 : b defines a new variable named b; you might as well have written let c = 1 : c. Thus, you're saying "b is a list which is 1 followed by b"; since we know what b is, we can substitute and get "b is a list which is 1 followed by 1 followed by b", and so on forever. Or: b = 1 : b, so substituting in for b we get b = 1 : 1 : b, and substituting in we get b = 1 : 1 : 1 : 1 : ….

(The fact that Haskell produces an infinite list, rather than going into an infinite loop, is because Haskell is non-strict, more popularly referred to as lazy – this is also possibly the single biggest difference between Haskell and every single mainstream language out there. For further information, search for "lazy evaluation" on Google or Stack Overflow.)

So, in the end, I hope you can see why I wasn't surprised: Haskell can't possibly update variable bindings. So since your definition was let b = [], then of course the final result was still [] :-)