Please re-read my message? Yes, the line quoted in my error message got wrapped. However, I have no reason [yet] to believe that it was incomplete.
But... your quoting of that error message wrapped it further for me. I do not know if that wrapping happened before you got my message or after. But I would hope at the very least that you would recognize that the error message contained [even if wrapped] what I believed was the line that's throwing the error. Anyways... I do not see how "beware of line wrapping" solves anything here. Not yet, anyways. That said, if you really want to avoid line wrap issues, I would recommend using pastebin. (But, my reading of the code suggests that a2 would still be undefined if it's run in a fresh session. And, I suspect you could see this for yourself if you take that erase line from your message and include it at the top of your script. Be sure, of course, to be running J and not Jx...) Anyways, I'm willing to believe that I have made a mistake. And I might even be convinced that I missed some sort of line wrap issue. But, right now, I'm definitely not seeing it. (And, as verification: every line in my copy of the code is indented - but line-wrap leaves unindented lines.) Thanks, -- Raul On Fri, Oct 20, 2017 at 5:53 PM, Jose Mario Quintana <[email protected]> wrote: > 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 ---------------------------------------------------------------------- For information about J forums see http://www.jsoftware.com/forums.htm
