Thanks for the tip about a handy way to play with JavaScript. On Tue, Jul 12, 2016 at 3:25 AM, Raul Miller <[email protected]> wrote:
> I did not have any problem with your presentation in > http://jsoftware.com/pipermail/programming/2016-July/045440.html > (other than a mild reaction to the bulk of code you used for such a > simple concept). > > But, since this topic provokes a lot of back and forth, I suppose it > won't hurt to go over it yet again. > > In the context of programming, a "closure" means a variable which has > a value bound to it across calls to a function or procedure. > > In some languages this value can be updated. > > In J you can approximate this in one of several ways: > > (*) bind a function argument (or part of one) to a specific value. > > F bind 1 2 3 NB. binding a function argument to a specific value > > (G 1 2 3&,) NB. binding part of a function argument to a specific value > > (*) Use a locale (cocreate something to hold the values and then refer to > it). > > (*) Store the information outside of J. > > And, of course, the link Pascal provided gives examples of those. > > That said, in other programming languages, closures are typically > implemented as a side effect of implementing nested scopes, and J does > not provide nested scopes (unless you emulate them using locales). > > For example, if you can get to the command line of a web browser (for > example, in Chrome or Safari, right click on a web page and select > "Inspect Element" and then select the console in the panel that pops > up, or hit escape to toggle another view of the console), try this: > > function F(y) { > var Y= y; > return function G(y) { > Y= Y+y; > return Y; > } > } > > H= F(10); > > H(1); > H(2); > H(3); > > So... perhaps now we can agree that that grease spot on the ground is > no longer a horse? > > -- > Raul > > > On Mon, Jul 11, 2016 at 11:55 PM, Jose Mario Quintana > <[email protected]> wrote: > > Thank you for providing the link Pascal. > > > > I am somewhat confused by the concept of closure. My perspective is from > > what an interpreter allows, as opposed to what the Dictionary allows. > Part > > of the problem is that currently I am only familiar with J, mostly tacit > J, and > > its related terminology (although in ancient times I used other > programming > > languages). Thus, let me to begin with my own tentative mapping of some > > terms (criticisms, comments and suggestions are, of course, welcome). > > > > Mapping of terms > > > > J Others > > > > noun data (atom in FP) > > name variable (also name) > > verb function > > adverb functional (aka, functor) > > conjunction functional (aka, functor) > > higher-order (wicked) verb higher-order function (which is a > > functional) > > tacit point-free style > > fixed tacit variable-free > > > > The question is: Are closures missing (and cannot be closely emulated) in > > J, tacit J, or fixed tacit J (which is the one I care the most)? > > > > On the one hand, in the context of fixed tacit J, according the reference > > [2] in my first message, closures "are a technique for implementing > > lexically scoped name binding in languages with first-class functions" > > which implies that the question above is vacuous since fixed tacit code > > includes no names at all." One the other hand, the item in [0] on > > Higher-order functions states "When returning a function, we are in fact > > returning its closure." implying that the example in my first message was > > indeed a closure... Except, perhaps, for a technicality: I used a > > functional (an adverb), instead of a higher-order function (a verb) to > > produce a function (a verb). However, using a higher-order function > (verb) > > is not difficult: > > > > (Warning, I will show definitions using the latest toolkit (and > providing a > > link where one can get it); in other words, potential Jym spoilers will > > follow shortly.) > > > > JVERSION > > Engine: j805/j64/windows > > Beta-9: commercial/2016-07-05T15:45:22 > > Library: 8.04.15 > > Qt IDE: 1.4.10/5.4.2 > > Platform: Win 64 > > Installer: J804 install > > InstallPath: j:/program files/j > > Contact: www.jsoftware.com > > > > The latest Wicked Tacit toolkit is in the zipped folder [1]. Run it as a > > silent script if you do not want to see potential spoilers, > > > > (0!:0)<'/.../J Tacit Tollkit.ijs' > > > > The interface of the function (verb) derivative follows closely its > > JavaScript counterpart; that is, its a monadic verb and takes a function > > together with (the length of ) an interval (*: and 0.000001 as an > > example). Since these words have different type they are expected as a > > boxed list (with a tally of two). One convenient way for producing a > list > > of boxed words (nouns, verbs, adverbs and conjunctions) is via the > > recurrent (aka, multiple) utility adverb sb. For example, > > > > [: *: 0.000001 ]sb > > ┌──┬────┐ > > │*:│1e_6│ > > └──┴────┘ > > > > The higher-order function derivative can be defined as, > > > > derivative=. ([: ([: ([ at [: an y +cv ]cv Train) -cv [ Train) %cv (] > > rank _:) Train)p f. > > NB. ( v @: ( n + ] ) - v ) % n > " > > _ > > > > It is fixed, > > > > 66 Wrap 'derivative' > > ,^:(0:``:)&6 :.(<@:((,'0') ,&:< ]))@:(,^:(0:``:)&6 :.(<@:((,'0') , > > &:< ]))@:(([ ,^:(0:`@:) ,^:(0:``:)&6 :.(<@:((,'0') ,&:< ]))@:(<@:( > > (,'0') ,&:< ])@:] ; >@:((<+)"_) ; >@:((<])"_))) ; >@:((<-)"_) ; [) > > ; >@:((<%)"_) ; ] ,^:(0:`") _:)&:>/ > > > > It produces a function, > > > > derivative [: *: 0.000001 ]sb > > (*:@:(9.9999999999999995e_7 + ]) - *:) % 9.9999999999999995e_7"_ > > > > and it seems to work according to the specifications, > > > > (derivative [: *: 0.000001 ]sb) 0 1 2 3 4 > > 1e_6 2 4 6 8 > > > > Notice that, after all this, the adverb Der and the higher-order verb > > derivative produce the same verb given the same arguments; thus, it might > > seem irrelevant whether one uses and adverb or a higher-order verb to > > produce the closure verb. Yet, I used almost the same higher-order verb > > derivative (the same verb but without the trailing adverb p) behind the > > scenes to define the adverb Der. The products of the higher-order verb > > derivative may, or may not, strictly qualify as closures but their > behavior > > corresponds to those of closures with immutable variables (as far as I > can > > see). > > > > Despite the title, the main subject of the link you provided is the > > famous/infamous Graham's Accumulator Generator challenge which seems to > > require the production of a named stateful function (verb). If I am not > > mistaken, this could be achieved, using languages that support closures, > by > > binding mutable variables. However, this does not imply that closures > with > > immutable bound variables are not closures. > > > > Nevertheless, one could produce, emulate if you will, a named fixed tacit > > stateful function by forcing it to dynamically modify and fix its own > code > > at each invocation (as a side effect). That would be an interesting > > exercise for the Jym. > > > > Allow me to reiterate: my statements regarding closures and related terms > > are tentative and I am willing to be educated. Actually, that was my > > purpose for starting this thread albeit with hesitation because sometime > > ago closures were a subject matter of heated discussions (see the thread > > associated to the message [2]). An extra complication arises because > > details of other related concepts, such as, function-level programming > and > > functions as first-class citizens, seem to be controversial, or unclear, > to > > some extent. > > > > References > > > > [0] Higher-order functions: returning functions as result (in > First-class > > function) > > > > > https://en.wikipedia.org/wiki/First-class_function#Higher-order_functions:_returning_functions_as_results > > > > [1] Jx/J/Wicked Tacit Toolkit.ijs file in > > http://2bestsystems.com/foundation/j/Jx.zip > > > > [2] [Jprogramming] Recursive programming (and scoping therein) > > > > http://www.jsoftware.com/pipermail/programming/2013-February/031561.html > > > > > > On Thu, Jul 7, 2016 at 9:29 AM, 'Pascal Jasmin' via Programming < > > [email protected]> wrote: > > > >> > >> > >> for another look at closures, > >> > >> > >> http://code.jsoftware.com/wiki/Guides/Lexical_Closure > >> > >> Your examples don't seem to follow the pattern of binding a dyad with > the > >> result of its application as a side effect of its application. > >> > >> A side effect and "singleton" assigned closure makes sense if the > closure > >> is to act as a guard that updates on each call. > >> > >> > >> > >> > >> > >> > >> > >> > >> > >> > >> ________________________________ > >> From: Jose Mario Quintana <[email protected]> > >> To: Programming forum <[email protected]> > >> Sent: Wednesday, July 6, 2016 10:56 PM > >> Subject: [Jprogramming] Are closures possible in J? > >> > >> > >> I recently saw the following message from June Kim in the Chat Forum > [0]. > >> > >> http://procyonic.org/blog/?p=171 > >> > >> I miss closure in J. > >> > >> which seems to imply the closures are missing in J. > >> > >> Perhaps I am misunderstanding the concept but, as far as I can see, > >> closures or similar alternatives are available in J, at least within the > >> (wicked) tacit dialect which is my focus of interest. > >> > >> One indication that closures (or similar alternatives) are available in > J > >> is the solution [1] to the Rosetta Code J task Closures/Value capture, > >> which presumably involves closures. The following is another example: > the > >> function derivative (verb) described in the Wikipedia entry [2] can be > >> implemented easily with wicked spells. ;) I am not showing at the > details > >> because this can be an interesting future Jym exercise but the outline > of > >> the implementation in the form of an edited session follows. > >> > >> First some good news, at least from my perspective, the functionality > of a > >> new updated version of the old Wicked Tacit Toolkit (WTT) [3] survives > all > >> the improvements up to version Beta-9. > >> > >> JVERSION > >> Engine: j805/j64/windows > >> Beta-9: commercial/2016-07-05T15:45:22 > >> Library: 8.04.15 > >> Qt IDE: 1.4.10/5.4.2 > >> Platform: Win 64 > >> Installer: J804 install > >> InstallPath: j:/program files/j > >> Contact: www.jsoftware.com > >> > >> Running the (new) WTT, > >> > >> (0!:1) < '/ ... /Wicked Tacit Toolkit.ijs' > >> NB. > >> NB. > >> > >> > ---------------------------------------------------------------------------- > >> NB. Wicked Tacit Toolkit... > >> NB. > >> > >> > ---------------------------------------------------------------------------- > >> . > >> . > >> . > >> > >> Defining the producing adverb, > >> > >> NB. Derivative (secant)... > >> > >> Der=. ... NB. A one-liner, in terms of the utilities, is not shown > to > >> avoid a spoiler > >> > >> The defined word Der is a wicked fixed adverb; actually, it is a > recurrent > >> adverb (aka, multiple adverb (a double adverb in this instance)). I > guess > >> I am not spoiling much by showing its linear representation which is > faulty > >> (unfortunately, linear representations often are faulty for complex > fixed > >> tacit adverbs, not to mention wicked tacit adverbs). > >> > >> type'Der' > >> ┌──────┐ > >> │adverb│ > >> └──────┘ > >> 66 Wrap'Der' NB. It is fixed... > >> ((("_)(((`'')(&(,^:(0:``:)&6 :.(<@:((,'0') ,&:< ]))@:(<@:((,'0') , > >> &:< ])@:((<,^:(0:``:)&6 :.(<@:((,'0') ,&:< ]))@:(,^:(0:``:)&6 :.(< > >> @:((,'0') ,&:< ]))@:(([ ,^:(0:`@:) ,^:(0:``:)&6 :.(<@:((,'0') ,&:< > >> ]))@:(<@:((,'0') ,&:< ])@:] ; >@:((<+)"_) ; >@:((<])"_))) ; >@:(( > >> <-)"_) ; [) ; >@:((<%)"_) ; ] ,^:(0:`") _:)) ,~ <) ; >@:((<,~)"_) > >> ; >@:((<<)"_))@:(,^:(0:``:)&6 :.(<@:((,'0') ,&:< ]))@:(<@:((0;1;0) > >> &({::))))@:[)))((`_)(`:6))))(,^:(0:``:)&6 :.(<@:((,'0') ,&:< ]))@: > >> ((<@:((,'0') ,&:< ])@:(,^:(0:`/))@:(,^:(0:`&)) >@:((<>)"_))@:>@:{: > >> , <@:((,'0') ,&:< ])@:}:)@:))(((`'')(&(,^:(0:``:)&6 :.(<@:((,'0') > >> ,&:< ]))@:((<(,'0');"_) ; ] ; (<(,'0');(@:(,^:(0:``:)&6 :.(<@:((, > >> '0') ,&:< ]))@:(<@:((0;1;0)&({::)))))((((`''`)(`(((@:[)(&`))(`:6)) > >> ))(`((`_)(`:6))))(`:6)))"_)@:[)))((`_)(`:6))) > >> > >> > >> ( double=. *: 0.000001 Der ) NB. Is the verb double a closure (*: > and > >> 0.000001 persist)? > >> (*:@:(9.9999999999999995e_7 + ]) - *:) % 9.9999999999999995e_7"_ > >> > >> > >> *: double 0 1 2 3 4 > >> 1e_12 4 16 36 64 > >> > >> Since the produced verb double is fixed it becomes independent of the > >> producing adverb Der. Likewise, an intermediate adverb can be defined > as, > >> > >> der=. 0.000001 Der NB. Is the adverb der is also a closure (0.000001 > >> persists)? > >> > >> type'der' > >> ┌──────┐ > >> │adverb│ > >> └──────┘ > >> 66 Wrap'der' NB. It is fixed > >> ("_)(((`'')(&(,^:(0:``:)&6 :.(<@:((,'0') ,&:< ]))@:((<@:((,'0') ,& > >> :< ])@:(,^:(0:`/))@:(,^:(0:`&)) >@:((<>)"_))@:>@:{: , <@:((,'0') , > >> &:< ])@:}:)@:((9.9999999999999995e_7;,^:(0:``:)&6 :.(<@:((,'0') ,& > >> :< ]))@:(,^:(0:``:)&6 :.(<@:((,'0') ,&:< ]))@:(([ ,^:(0:`@:) ,^:(0 > >> :``:)&6 :.(<@:((,'0') ,&:< ]))@:(<@:((,'0') ,&:< ])@:] ; >@:((<+)" > >> _) ; >@:((<])"_))) ; >@:((<-)"_) ; [) ; >@:((<%)"_) ; ] ,^:(0:`") > >> _:)) ,~ <)@:(,^:(0:``:)&6 :.(<@:((,'0') ,&:< ]))@:(<@:((0;1;0)&({: > >> :))))@:[)))((`_)(`:6))) > >> > >> Again, once der is produced it becomes independent of Der because it is > >> fixed. > >> > >> *: der > >> (*:@:(9.9999999999999995e_7 + ]) - *:) % 9.9999999999999995e_7"_ > >> > >> *: der 0 1 2 3 4 > >> 1e_6 2 4 6 8 > >> > >> These examples show that nouns and verbs in an "environment" can be > >> embedded in verbs and adverbs. Adverbs can be embedded in adverbs and > >> verbs, as well (and verbs, adverbs and conjunctions can be taken > indirectly > >> as arguments by verbs and adverbs; for instance, by wrapping them in > >> gerunds or boxed arrays). Alas, user defined tacit conjunctions > apparently > >> are not possible employing current official interpreters; one would > have to > >> revert to official Golden Age interpreters or use alternative Unbox/Jx > >> interpreters. > >> > >> I cannot pretend that I am very familiar with the concept of closures; > yet, > >> it seems to me that, the conventional way for producing closures in J > would > >> be via explicit adverbs or conjunctions with nested (local) explicit > verbs, > >> adverbs or conjunctions which could be deliver as products (of course, > >> these constructions are not supported, not yet anyway). The methods I > have > >> partially shown for producing fixed tacit verbs and adverbs are > >> unconventional (then again, J, tacit writing and wicked spells are > >> unconventional) but the effects seem to be the same or at least very > >> similar. > >> > >> Any enlightenment would be appreciated. > >> > >> References > >> > >> [0] [Jchat] Interesting Critique of J > >> http://www.jsoftware.com/pipermail/chat/2016-July/007002.html > >> > >> [1] Tacit (unorthodox) version in task Closures/Value capture > >> > >> > >> > http://rosettacode.org/wiki/Closures/Value_capture#Tacit_.28unorthodox.29_version > >> > >> [2] First-class functions in Applications of Closure (computer > >> programming) > >> > >> > >> > https://en.wikipedia.org/wiki/Closure_(computer_programming)#First-class_functions > >> > >> [3] [Jprogramming] Tacit Toolkit (was dyadic J) > >> > >> > http://www.jsoftware.com/pipermail/programming/2015-December/043757.html > >> ---------------------------------------------------------------------- > >> For information about J forums see http://www.jsoftware.com/forums.htm > >> ---------------------------------------------------------------------- > >> For information about J forums see http://www.jsoftware.com/forums.htm > > ---------------------------------------------------------------------- > > For information about J forums see http://www.jsoftware.com/forums.htm > ---------------------------------------------------------------------- > For information about J forums see http://www.jsoftware.com/forums.htm > ---------------------------------------------------------------------- For information about J forums see http://www.jsoftware.com/forums.htm
