The challenge, in short, is to prove that your favorite language has, or can closely emulate, (A) lexical closure and, (B) higher order functions (functions which return other [anonymous] functions), where "function" really means "subroutine" and does not mean a mathematical function.
We want to write a function that generates accumulators-- a function that takes a number n, and returns a function that takes another number i and returns n incremented by i.
(That's incremented by, not plus. An accumulator has to accumulate.)
That is, Graham wants you to demonstrate a stateful function. However, implicitly, he discourages the use of global variables. He wants to see the use of variables which are local to their function (invisible outside its definition), but which retain their values across invocations of that function.
If you're familiar with Visual Basic, think of the keyword static
First: in J, a "function" is a verb, adverb or conjunction. Verbs return nouns and only nouns (including names and gerunds), while adverbs and conjunctions can return nouns, verbs, adverbs or conjunctions.
Since the "function which returns a function" only needs one argument (to wit: n, the initial value of the lexical variable), the solution in J will be an adverb.
Consequently, in J, our goal is to provide a definition accGen:
accGen =: adverb define NB. Some magical definition )
The issue to be solved is: where should this definition keep its state? We could keep state in a locale, or in the operating system (for example, in a file). Locales are preferred as they are somewhat cleaner than the alternatives. Some people might object to the use of locales because they are well documented and the challenge implied that the state involved should be secret.
burke=: 1 : 0 n=. 'n_',(> cocreate''),'_' (n)=. m 3 : (n,'=:',n,'+y') ) ag =: 0 burke ag 1 1 ag 1 2 ag 1 3
oleg=: 1 : 0 a=. cocreate'' n__a=: m a&(4 : 'n__x=: n__x + y') ) f=. 3 oleg f 0 3 f 2 5 f 5 10 f 0 10
This solution is more general because the entire generated locale is available to the derived verb; it therefore has the potential to store and retrieve any number of data, not just x. Furthermore, Oleg's verb avoids code generation (that is, the text of derived verbs is constant; only the bound variable changes).
Can you list other solutions?
For an amusing (but abusive) way to "solve" this puzzle, see: the mapped files solution
Oleg's solution can readily be translated into a one-liner thus: accgen=:1 :'(a[n__a=.m[a=.18!:3$~0)&(4 :''n__x=.n__x+y'')'
The current dyadic definition of verbs derived from accgen is supplied by the powering aspect of & (see the bond page in the dictionary). So
ag =: 0 accgen 10 ag 1 1024 2^10 1024
If this is not useful, we can provide a different definition, such as accgenr =: accgen ( : (] ($:@:[) $:@:-@:$:@:0:) ) which allows us to reset the accumulator:
agr =: 0 accgenr agr 1 1 agr 10 11 agr 100 111 agr~ 0 0 agr 1 1 agr~ 42 42 agr 1 43
A variation on Chris's approach uses no dynamic code in the body of the accumulator, and no globally qualified name for the accumulator's numeric value, but does construct a globally valid reference to the accumulator "function":
miller=: 1 :0 object=. cocreate'' n__object=: m accum__object=: 3 :'n=:n+y'"0 ''1 :('accum_',(>object),'_') ) a=: 3 miller b=: 4 miller a 4 5 6 7 12 18 b 4 5 6 8 13 19 a 10 28 a f. 3 : 'n=:n+y'"0
- Can you list other, meaningfully different, solutions?
Graham cites lexical scope as a feature of a "powerful" language. This appears to me like backwards reasoning. Graham likes Lisp; he thinks it's a powerful language. Lisp has lexical scope. Graham therefore concludes that all powerful languages must have lexical scope. Or, equivalently, a language must have lexical scope to be powerful.
I disagree with this conclusion. Lexical closure is incompatible with the functional programming model (a mathematical way of describing algorithms).
In the example section, notice how calling the same function with the same arguments produces a different result. A function whose output is not wholly determined by its input -- a function with "hidden inputs" -- is anathema to functional programming. (And yet, thinking about papers I've read, closures, "projections" and "monads" (in the Haskell/Scheme sense) are hot topics. So I must be wrong)
Contrast this with tacit definition in J, which does not even mention its arguments: mean =: +/ % #; this means tacit verbs are so dependent on their arguments that their indivual components' contexts are determined by their placement within the definition!
I maintain that functional programming is a powerful paradigm (in the same way mathematics is a powerful paradigm), and is at odds with lexical closure, and therefore lexical closure is not required of a powerful language. (Which is not the same as saying a language with lexical closure is not powerful, or that a language cannot achieve (greater) power through its addition.)
Regardless, because Graham is widely known and respected, his challenge has been and will be presented on the Forums, so we might as well answer it. Onward, then.
-- DanBron 2006-12-12 06:07:10