Here's one issue:
1 2 3 *: av
1 4 9
load'debug/dissect'
dissect '1 2 3 *: av'
Syntax error: invalid sequence Noun Verb
Error snippet: 1 2 3 *: av
But that's not a syntax error.
And, for reference, here are two distinct implementations of av. First
an explicit approximation:
LR=: 5!:5@<
LRA=:1 :0
(LR 'u'),' m'
)
AV=:1 :0
1 :(u LRA)
)
Second, a restatement of Jose's code (but with a few different names):
ar=: 5!:1@:<
bGerund=: `''
Compose=: (@:[) ((<'&')`) (`:6)
a2=: (`(<(":0);_)) (`:6)
av=: ((ar'bGerund')`) (`(ar'Compose')) (`(ar'a2') ) (`:6)
I am still trying to think up a good name for a2 - roughly speaking
it's a placeholder which winds up being ignored in the result of the
Compose verb. I was interested in what dissect had to show me about
the evaluation process here, but that's not relevant to this problem,
which you can see by replacing av with AV.
#################################################
That said, it's perhaps also interesting that trace is also buggy:
trace '1 2 3 *: AV'
--------------- 5 Fork -------
1 2 3
*:
AV
1 2 3 *: AV
==============================
The problem seems to be an incomplete handling of locales. While trace
executes in the jtrace locale, the sentence it is executing comes from
a different locale (typically the base locale). This means that 4!:0
in movet treats AV as an undefined name (and, thus, a verb).
A quick and dirty fix would be to add
coinsert 'base'
to the top of addons/general/misc/trace.ijs (right under cocurrent'jtrace').
This has two flaws but it's still better than nothing:
(1) it won't work when trying to trace in another locale,
(2) it will still shadow base names with jtrace names.
Problem 2 could be avoided by replacing uses of 4!:0 and ". with names
which are defined in the z locale (nc and do), and suffixing them with
locale references. Still not perfect (because relies on z), but
implementations which shadow z are already dubious.
I have no idea about problem 1 - maybe documentation would be the best
solution there. (Another possibility would be to add feature to the
locale support, to detect locale of the caller - but I can't think of
any non-obfuscation uses of that feature. And, yes, ... I guess I
might have to include "making jtrace automatically work regardless of
the current locale of the global session" as obfuscation. I am not
sure about that...)
#################################################
Anyways, since this is getting long, I have reported two problems here:
(1) An invalid "syntax error" in dissect
(2) A serious name resolution problem in trace
Thanks,
--
Raul
On Sat, Oct 21, 2017 at 8:03 AM, Henry Rich <[email protected]> wrote:
> Pepe, if you would add that bug, whatever it is, to
>
> http://code.jsoftware.com/wiki/System/Interpreter/Bugs/Errors
>
> I'd be obliged.
>
> Henry Rich
>
>
>
> On 10/21/2017 7:55 AM, Jose Mario Quintana wrote:
>>
>> Hi Erling,
>>
>> The issue arises because my original post shows a session as opposed to a
>> clean script and I used a trick to define three adverbs in one line, see
>> my
>> last response, to Raul. That should not have caused any harm except that
>> J's response is affected by a linear representation bug.
>>
>> In retrospect, to avoid any confusion, I should have edited the session
>> and
>> deleted J's response; that is,
>>
>> 9!:14''
>> o=. @:
>> ar=. 5!:1 @:<
>> (a0=. `'') (a1=. (@:[) ((<'&')`) (`:6)) (a2=. (`(<(":0);_)) (`:6))
>> av=. ((ar'a0')`) (`(ar'a1')) (`(ar'a2') ) (`:6)
>> ...
>>
>> What you did is equivalent, thanks.
>>
>> The first part runs fine using the latest "stable" official interpreter
>> (it
>> also runs in Jx, of course). The last part (the "thought experiment" was
>> run using Jx).
>>
>>
>>
>>
>> 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
>
>
>
> ---
> This email has been checked for viruses by AVG.
> http://www.avg.com
>
>
> ----------------------------------------------------------------------
> For information about J forums see http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
