The language is sort-of functional. It's as unfunctional as possible while still highlighting immutability. The key is to focus on what you can't do. Pointers

The language is sort-of functional. It's as unfunctional as possible while still highlighting immutability. The key is to focus on what you can't do. Pointers in C do provide a similar UI to "boxes" that I was describing. But their plain values aren't the same. Consider int main() { int x; x = 3; x = 4; printf("x = %i\n", x); } $ gcc test.c -o test $ test x = 4 Here, I am still able to treat the value `x` as a "box" because `x` is not a name but instead an actual int-sized memory location on the stack. Here's a similar fragment in Haskell main = let x = 3 in let x = 4 in print x $ ghc --make test.hs $ test 4 Now the difference here is that each of those bindings (namings) of `x` have a context delimited by the indentation. In particular, names only have meaning within a delimited scope. In fact, the `x` bound by the inner let is completely different from the outer one. The fact that they share the same name means that the inner one shadows the outer one within the scope of the inner let. We could demonstrate this with the following program perhaps main = let x = 3 in print ((let x = 4 in x) + x) $ ghc --make test.hs $ test 7 Here we can plainly see that the context where `x` names 4 is only as large as that inner, bracketed `let ... in ...`. After we leave that scope, `x` reverts to naming 3. The trick with figuring out FP is that it actually feels more restrictive at first. It's a typically higher-level form of expression. You can obviously simulate it all in C (FP languages might even compile down to C) but the goal is to determine what kinds of things can be expressed in the FP language itself. To learn more, I highly suggest learning just the basics of Haskell or OCaml. Scala would probably suffice as well, though I don't know it as well to say. Generally, the idea I'm talking about is often called "immutability" (though it's slightly different). Programming with immutable things tends to be easier to reason about because names do not change what they refer to within a context (like x changing from 3 to 4 in the C program).