No, a2 is defined previously; recall "beware of line-wrapping." In addition, what I showed was a session output, not a clean script. If your email formatting is giving you a hard time, try to look at the version of my post in the forum archive.
I hope it helps On Thu, Oct 19, 2017 at 8:31 PM, Raul Miller <[email protected]> wrote: > When I try to execute your script, I get: > > |value error: a2 > | (a0=.`'')(a1=.(@:[)((<'&')`)(`:6))(a2=.(`(<(":0);_))(`:6))( > (`'')(((@:[)(&`))(`:6)))((`_)(`:6))av=.((ar'a0')`)(`(ar'a1'))(`( > ar'a2'))(`:6) > |[-3] /users/rauldmiller/j64-805-user/temp/2.ijs > 9!:14'' > j805/j64/darwin/beta-9/commercial/www.jsoftware.com/2016-07-05T17:11:06 > > And, indeed, it does look like you are referring to ar'a2' before > you define a2. > > Thanks, > > -- > Raul > > > On Thu, Oct 19, 2017 at 8:21 PM, Jose Mario Quintana > <[email protected]> wrote: > > There were many adverb and conjunction producing trains during a period > > which Henry has referred as the Golden Age. Some were available as early > > as 1993 [0] and several more afterward [1]. A few of those adverb > > producing trains (all of them bidents) survived [2] (using nv to denote > > noun or verb), > > > > " > > x (a1 a2) is x a1 a2 > > x (c nv) is x c nv > > x (nv c) is nv c x > > " > > > > but none of the conjunction producing trains did. Nevertheless, I > learned > > to appreciate very much two of them (a trident and a bident), together > with > > the survivors, many years after they were decommissioned, > > > > " > > x (a1 c2 a3) y is (x a1) c2 (y a3) > > ... > > x (c a) y is (x c y) a > > " > > > > I hope mentioning old versions of J does not provoke a wild-goose chase > ;) > > > > Remarkably, the adverb producing train survivors are sufficient to allow > > for complete adverbial programming in the following sense: if the desired > > entity (a noun, verb, adverb or conjunction), to be produced, can be > > computed from the adverb's argument then there is a (pure) tacit adverb > > able to do so (even compliantly; that is, the hard way, without using any > > black magic). > > > > How come? There are several ways to show how this can be done; the J > > sentences further down define a (Curried) adverb hg which can define an > > arbitrary adverb t as follows, > > > > t=. v hg > > > > hg acts on a (presumably pure tacit) workhorse verb v and produces the > > required adverb (t). The workhorse verb acts on the atomic > representation > > of t's argument and should produce the atomic representation (or similar) > > of the desired entity; finally, hg evokes (`:6) it. Since (at least, in > > principle) one can go back and forth between the atomic representations > and > > the entities they represent, tacit adverbial programming is reduced to > > tacit verbal programming and the latter is Turing complete [3, 4]. > > > > The adverb hg can be defined as follows (no agendas are used, which some > > members might find too cryptic), beware of line-wrapping, > > > > 9!:14'' > > j805/j64/windows/release/commercial/www.jsoftware.com/2016- > 12-11T08:02:16 > > > > o=. @: > > ar=. 5!:1@:< > > > > (a0=. `'') (a1=. (@:[) ((<'&')`) (`:6)) (a2=. (`(<(":0);_)) (`:6)) > > ((`'')(((@:[)(&`))(`:6)))((`_)(`:6)) > > av=. ((ar'a0')`) (`(ar'a1')) (`(ar'a2') ) (`:6) > > NB. Adverbing a monadic verb (adv) > > assert 1 4 9 -: 1 2 3 *: av > > > > aw=. < o ((0;1;0)&{::) NB. Fetching the atomic representation > > a3=. (@: (aw f.)) ('av'f.) > > a4=. "_ > > a5=. `:6 > > a6=. ((( ar'a4') ; ] ; ( ar'a3')"_) ('av'f.)) (`:6) > > > > hg=. `((ar'a6')`(ar'a5')) (`:6) > > assert 1 4 9 -: 1 2 3 ((<'*:') ; ]) hg > > > > erase'a0 a1 a2 a3 a4 a5 a6 ar av aw' > > 1 1 1 1 1 1 1 1 1 1 > > > > The adverb hg is tacit and it is fixed. Once it is defined one does not > > have to know or remember how it works to use it (that was the main point > > for defining it in the first place). > > > > The verb an is convenient to use together with hg for development > (because > > it neutralizes the hg ending adverb evoke (`:6)) > > > > an=. <@:((,'0') (,&<) ]) NB. Atomizing words (monadic verb) > > > > For example, assume one wants an adverb t to act on a gerund, > representing > > two verbs (say, u and v) u`v, and produce the verb v@u; thus one needs a > > workhorse verb to produce, > > > > v@:u an hg > > ┌──────────┐ > > │┌──┬─────┐│ > > ││@:│┌─┬─┐││ > > ││ ││v│u│││ > > ││ │└─┴─┘││ > > │└──┴─────┘│ > > └──────────┘ > > > > acting on, > > > > (u`v) an hg > > ┌─────────┐ > > │┌─┬─────┐│ > > ││0│┌─┬─┐││ > > ││ ││u│v│││ > > ││ │└─┴─┘││ > > │└─┴─────┘│ > > └─────────┘ > > > > Therefore, given that, > > > > (u`v) an o (< o ((('@:') ; < o |.)) o (('';1)&{::)) hg > > ┌──────────┐ > > │┌──┬─────┐│ > > ││@:│┌─┬─┐││ > > ││ ││v│u│││ > > ││ │└─┴─┘││ > > │└──┴─────┘│ > > └──────────┘ > > > > the adverb t can be defined as, > > > > t=. < o ((('@:') ; < o |.)) o (('';1)&{::) hg > > > > (u`v)t > > v@:u > > > > Let us entertain a more general version of t taking a gerund > representing a > > (variable) number of verbs, the atomic representation of a sample > argument > > u0`u1`u2`u3`u4 (extra parentheses used again for clarity) is, > > > > (u0`u1`u2`u3`u4) an hg > > ┌────────────────────┐ > > │┌─┬────────────────┐│ > > ││0│┌──┬──┬──┬──┬──┐││ > > ││ ││u0│u1│u2│u3│u4│││ > > ││ │└──┴──┴──┴──┴──┘││ > > │└─┴────────────────┘│ > > └────────────────────┘ > > > > and the atomic representation of the product u0@:u1@:u2@:u3@:u4 is, > > > > (u0@:u1@:u2@:u3@:u4) an hg > > ┌──────────────────────────────────────────┐ > > │┌──┬─────────────────────────────────────┐│ > > ││@:│┌────────────────────────────────┬──┐││ > > ││ ││┌──┬───────────────────────────┐│u4│││ > > ││ │││@:│┌──────────────────────┬──┐││ │││ > > ││ │││ ││┌──┬─────────────────┐│u3│││ │││ > > ││ │││ │││@:│┌────────────┬──┐││ │││ │││ > > ││ │││ │││ ││┌──┬───────┐│u2│││ │││ │││ > > ││ │││ │││ │││@:│┌──┬──┐││ │││ │││ │││ > > ││ │││ │││ │││ ││u0│u1│││ │││ │││ │││ > > ││ │││ │││ │││ │└──┴──┘││ │││ │││ │││ > > ││ │││ │││ ││└──┴───────┘│ │││ │││ │││ > > ││ │││ │││ │└────────────┴──┘││ │││ │││ > > ││ │││ ││└──┴─────────────────┘│ │││ │││ > > ││ │││ │└──────────────────────┴──┘││ │││ > > ││ ││└──┴───────────────────────────┘│ │││ > > ││ │└────────────────────────────────┴──┘││ > > │└──┴─────────────────────────────────────┘│ > > └──────────────────────────────────────────┘ > > > > Now, that seems to be messy but it does not have to be (hint: producing > the > > atomic representation is not necessary, as long as the entity can be > evoked > > correctly). A solution of this type is shown near the end of this post. > > > > While currently, tacit adverbial programming is complete, tacit > > conjunctional programming is, alas, virtually zip. Nevertheless, let us > > have a thought experiment: what would happen if the two conjunction > > producing trains I mentioned above had survived? Would conjunctional > > programming be complete in the same sense in which tacit adverbial > > programming is? The answer is yes. > > > > How come? Because then tacit conjunctional programming could be reduced > to > > tacit adverbial programming. Assume, for example, that a conjunction > acts > > on a noun and a verb, say 1 2 3 4 and +/, then > > > > 1 2 3 4 ((an f.hg) (` (an o ((('';1)&{::))hg))(an f.hg)) (+/) > > ┌───────────┬───────┐ > > │┌─┬───────┐│┌─┬───┐│ > > ││0│1 2 3 4│││/│┌─┐││ > > │└─┴───────┘││ ││+│││ > > │ ││ │└─┘││ > > │ │└─┴───┘│ > > └───────────┴───────┘ > > > > Therefore, one can replace the verb an by a workhorse verb v acting on > the > > above gerund to produce whatever is desired, for example, if one wants > the > > right-hand verb argument to act on the left-hand side argument we could > > simply define the conjunction as follows, > > > > t=. ((an f.hg) (` (|. o ((('';1)&{::))hg)) (an f.hg)) > > > > 1 2 3 4 t (+/) > > 10 > > > > 'boxed' t < > > ┌─────┐ > > │boxed│ > > └─────┘ > > > > type't' > > ┌───────────┐ > > │conjunction│ > > └───────────┘ > > > > In general, an arbitrary conjunction could be defined as, > > > > > > t=. (an f.hg) (` (v o ((('';1)&{::))hg)) (an f.hg) > > > > where v is the workhorse verb. For the common case where the two > arguments > > are verbs, > > > > t=. ` (v o ((('';1)&{::))hg) > > > > would be sufficient. > > > > The 1993 version J is unable to successfully define hg because, although > > evoke (`:6) supported gerunds representing lists of verbs, it did not > have > > the extended functionality for hg to be able to work; that was added > > later. I am not sure if the late versions of the interpreters of the > > Golden Age can reproduce all the above. > > > > However, the above is not quite a pure thought experiment. It reflects a > > Jx session (Jx is a fork of J that provides some extensions [5]). (Jx > does > > not require the conjunction producing trains to make tacit conjunctional > > programming complete because it provides an alternative way to produce > > arbitrary conjunctions; there are there because they are useful and I > > personally consider any tiny performance penalty, due to restoring a > > trident entry in the parse table, as a well-deserved tribute to them.) > > > > Could they find their way back to official interpreters? I do not think > > so. Yet, complete conjunctional tacit programming could be provided > without > > having to restore any trident (apart from the fork trident which is > > special). How come? I could give an outline on how this could be > > implemented but this post is already way too long and I wonder how many > > members could still be reading it at this point. > > > > However, before I forget, just in case someone wants to see it... > > > > The more general adverb t can be obtained easily: since, > > > > (u0`u1`u2`u3`u4) an o (([ , (<'@:') , ])/o |. o (('';1)&{::))hg > > ┌──┬──┬──┬──┬──┬──┬──┬──┬──┐ > > │u4│@:│u3│@:│u2│@:│u1│@:│u0│ > > └──┴──┴──┴──┴──┴──┴──┴──┴──┘ > > > > then t can be defined as, > > > > t=. ([ , (<'@:') , ])/o |. o (('';1)&{::)hg > > > > u0`u1`u2`u3`u4`u5`u6 t > > u6@:u5@:u4@:u3@:u2@:u1@:u0 > > > > *:`(+/)`-`j.`(^ %:)t 1 2 3 > > 2.40034j16.7123 > > > > PS. My plans for sending a version of this post during the weekend were > > crushed because I was too busy (oversleeping, watching dance > performances, > > eating out, swimming, watching boxing, football, etc. :) > > > > > > References > > > > [0] [Jprogramming] Tacit Expressions with Explicit J Syntax roger stokes > > > > http://www.jsoftware.com/pipermail/programming/2017-Septembe > r/048917.html > > > > [1] [Jprogramming] Jx 1.1 Release neitzel > > http://www.jsoftware.com/pipermail/programming/2017-October > /049177.html > > > > [2] [Jprogramming] Jx 1.1 Release neitzel > > http://www.jsoftware.com/pipermail/programming/2017-October > /049179.html > > > > [3] Universal Turing machine (J) > > https://rosettacode.org/wiki/Universal_Turing_machine#J > > > > [4] Jforum: A Tacit Implementation of a Turing Machine > > http://www.jsoftware.com/pipermail/general/1999-December/002736.html > > > > [5] [Jprogramming] Jx 1.1 Release Jose Mario Quintana > > > > http://www.jsoftware.com/pipermail/programming/2017-Septembe > r/048957.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
