Looking at the expression you see right away that most of this is the operator.. The calls have the form:
(operator operands ...)
Thus you know the operator is this:
((lambda (f)
((lambda (g)
(lambda (h)
(f (g (h 4)))))
double))
square)
and the sole operand is this:
inc
When looking at the operator you see again open parentheses and that means it also is a call. The new operator is binds f to square and does a new call binding g to double and since the last lambda does not have parentheses around it the return is a function/closure/procedure as expected. So we can replace the bindings without changing it's meaning and in this case you get:
(lambda (h)
(square (double (h 4))))
Now lets do the top (operator operand) again:
((lambda (h)
(square (double (h 4))))
inc)
Here you see h gets bound to inc. If we substitute that we can replace the whole thing with the procedure body:
(square (double (inc 4))) ; ==> 100
When you see ((lambda ...) ...) you are looking at a anonymous procedure getting called right away. It's the same as (something ...) which also is a call but here the variable something shoudl get evaluated to a procedure. An extra parentheses around either of these like (((lambda .. or ((something ... should tell you that the function is expected to return a function that is then called. It's standard correct Scheme but not the most common so just learn to be aware of these since it requires some more seconds of attention. When writing code yourself considerer making this clear with bindings:
(let ((helper (something a b c))))
(helper d))
Rather than:
((something a b c) d)
Even though these look equally simple at time of writing even you will thank yourself when you look again after a long pause.
