You're just shadowing the previous binding with a new one, not actually mutating anything[1]:
λ> let foo = 1
λ> let foo = 2
λ> foo
=> 2
could be rewritten[2] as
λ> let foo = 1 in ( let foo = 2 in foo )
=> 2
which makes the semantics more clear.
This idiom is also quite common in Clojure, another famously immutable-first language:
(let [foo 1
foo 2]
foo)
;; => 2
In my opinion (predominantly informed by my experience with those two languages contrasted with the usual suspects from mutable-OOP-land), the benefit of immutability isn't what's happening in your own local scope, since it's typically quite easy to track what your immediate context is doing to a variable. Instead, it's the language-enforced promise that the only changes to local values can come from local actions: your function and method calls can never have spooky side effects, nor can other threads if you're in some hellish concurrent environment.
In this light, Chaos's apparent syntactic sugar of
a[15] = 44
to mean (using some hand-wavey pidgin)
a = a.updateAt(15,44)
seems quite reasonable and fully in the spirit of immutability as a meaningful language feature.
[1] In my scratchwork project, my repl actually yells at me with an annoying warning about this:
<interactive>:8:5-7: warning: [-Wname-shadowing]
This binding for ‘foo’ shadows the existing binding
defined at <interactive>:6:5
[2] I believe that the haskell repl actually functions like a do-block, so the pedantically correct desugaring possibly involves lambdas and bind, but that's not really an interesting distinction here IMO and makes the example less clear.