Yes, removing that line works.
(Same example that worked with Erlang's version:)
1: [^:('0:'-:])L:0&(>:@0:a0) hg
>:@1:
(It's not clear to me, though, how I was expected to distinguish that
line from line wrap?)
Thanks,
--
Raul
On Sat, Oct 21, 2017 at 7:30 AM, Jose Mario Quintana
<[email protected]> wrote:
> Look carefully at my first post [0] as I suggested (using a browser), the
> line,
>
> (a0=. `'') (a1=. (@:[) ((<'&')`) (`:6)) (a2=. (`(<(":0);_)) (`:6))
>
> defines a0, a1 and a2, the next line is J's response
> ((`'')(((@:[)(&`))(`:6)))((`_)(`:6)) and the next line,
>
> av=. ((ar'a0')`) (`(ar'a1')) (`(ar'a2') ) (`:6)
>
> is where ar'a2' is used.
>
>
> [0] [Jprogramming] Trains: past, present and ... Jose Mario Quintana
> http://www.jsoftware.com/pipermail/programming/2017-October/049263.html
>
>
> On Fri, Oct 20, 2017 at 6:18 PM, Raul Miller <[email protected]> wrote:
>
>> 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/forum
>> s.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
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
