[catnaroek]

I'd distinguish between (at least) three degrees of “purity”:

(0) Absolutely anything goes. Examples: Racket (in the REPL), Lisp, Clojure, Scala, Erlang, etc.

(1) Values are immutable, but any computation might have any effect. Examples: Standard ML, OCaml (mostly), Racket (mostly).

(2) Values are immutable, and computations are type-annotated with their possible effects. Examples: Haskell, Idris, Ur/Web.

[i_s]

Pretty strange that you put Clojure in the "anything goes" category when it has been the clear leader when it comes to immutability. Lots of those languages you put in the other categories don't even have persistent data structures in their standard library.

[catnaroek]

Here is why: http://pastebin.com/t3Q3CW4j

This is particularly infuriating because the proper way to handle bound variables is already known: https://en.wikipedia.org/wiki/De_Bruijn_index .

[i_s]

No one is maintaining state by constantly clobbering namespace level variables in Clojure, though. What actually comes into play are ways the language and standard library encourages passing data around and manipulating it, which in Clojure is as immutable as you'll find in any language.

[catnaroek]

Clojure encourages me to program in the REPL, because there is no other way to know what is going on in such a semantically crazy language, other than trial and error.

And the state of the Clojure REPL is as mutable and imperative as it gets, as my paste showed.

[greydius]

You can rebind variables in ghci, too. I certainly wouldn't say this is evidence that Haskell promotes mutable data.

[catnaroek]

> You can rebind variables in ghci

No, you can't: http://pastebin.com/SdbKM7V7

In ML and Haskell, a new variable might shadow an old one (if they have the same name), but they are still different variables.

Shadowing is slightly harder to implement than rebinding, but it provides a useful guarantee for the user: the meaning of existing definitions remains stable even if new definitions are introduced into the environment.

[gclaramunt]

Interestingly, Scala handles it http://pastebin.com/CT36K6Hj It feels like an artifact of the REPL tho, as one shouldn't be able to redefine x

[catnaroek]

Yep, statically typed languages tend to have no option but to handle this right. Otherwise, they risk unsoundness: Consider what would happen if you did `val x = "foo"` instead of `val x = 0`.

But there's still no type-level distinction between immutable and mutable bindings, which is why included Scala in the “anything goes” category.

[rdtsc]

> Absolutely anything goes. Examples: Racket (in the REPL), Lisp, Clojure, Scala, Erlang, etc.

Well you can't mutate variables and data in Erlang. (Try X=1,X=2 in a repl, it will fail). There is a thing called process dictionary but it is frowned upon. Concurency is handled by processes. But that's a different thing.