Furthermore, the ability to perform destructive update does not disqualify the ability to perform what you are asking using Haskell if indeed you correct it to be a sensible expression of software - that is, you pass the “number of times it’s called” as an additional argument/return value. This can be achieved cleanly by using the State monad.

By the way, yes the Haskell equivalent is supposed to be 100 times shorter — that is the nature of a relatively expressive programming language.

Nope. That’s the nature of implementing one language’s idioms in another. For an example going the other way, say we have a function
char * echo(char * str) { return str; } // C
or
pre = id — haskell
and it’s called all over our program. Now say we want to count the number of times it’s called. In C, we just do this:

int echo_count = 0;
char * echo(char * str) { ++echo_count; return str; } // C

Global state is easy and idiomatic. In Haskell, we’re hosed — “proper hosed”. Time to rewrite our whole program.

(a + b) + c = a + (b + c),

not

a + b = b + a,

which is commutativity. (But associativity is the property that makes the two forms equivalent if they both terminate.)

Sorry to anyone for whom I have caused confusion. It is me who was confused. My sincerest apologies. Ryan, I have updated in an attempt to correct your confusion for which I accept full responsibility.

definitions of folds in haskell should be:

foldl _ e [] = e
foldl f e (x : xs) = foldl f (f e x) xs

and

foldr _ e [] = e
foldr f e (x : xs) = f x (foldr f e xs)

so “foldr (-) 97 i” is

(7 - (8 - (9 - (… (74 - 97))))

Yes. you got them backwards.

The difference matters especially with structures like functional cons lists. A fold left can be written tail-recursively; a fold right cannot (except by reversing the list and folding left).