Languages with immutable variables by default, like Haskell

Question

one thing that I find fascinating about Haskell is how functions and variables are the same. In most languages a variable holds a value while a function does something and then, eventually, returns a value. In Haskell you don't see this difference and after having used Haskell, falling back to more "traditional" programming where variables are different from functions or methods feels awkward. If I want to get a value, I shouldn't really worry about its origin, whether it is a constant value, a mutable variable or the result of a complex computation! In Haskell, variables are just 0-ary functions.

Many object-oriented languages have properties that feels a bit the gap.

Can anyone indicate any other language with a system similar to Haskell? I thought it was common to functional languages because of referential transparency, but I've seen it's not the case. In Lisp, for example, you have (defun) to explicitly declare functions.

Answer 1

Don't forget Javascript.

var a = function(x) { return (x + 1) };
var b = a(1);
// b == 2 here.

is perfectly legitimate.

Answer 2

In Clojure defn is just a macro to def. Vars are immutable and they hold values. Functions are just values just like any other kind of value. Whether a value actually is a function (Fn) is not important as whether that type of value implements the function interface (IFn).

To clarify the last point a Java primitive array is not a function. I may wish to treat it as a Clojure Sequence, I could create a wrapper type that allows me to present that interface (ISeq) over the primitive array. I could also have the wrapper type implement IFn and the primitive array could then be treated as a function as well.

(def x (wrap-prim-array ...))

(nth x 0) ; idiomatic random access
(x 0)     ; used as a function

Answer 3

Can anyone indicate any other language with a system similar to Haskell?

Several languages have immutable variables (i.e. variables in the mathematical sense) by default:

• Haskell (obviously),
• Clean,
• Erlang,
• ML.

Others encourage this behavior via 'const' or 'val' declarations (Scala, C).

In many functional languages mutable values may only be introduced via explicit 'ref' or 'var' declarations.