Hi Erling,
You are right, the adverb (At) produces tacit sentences but it is
really an
implementation of Dan's pipeline proposal using strand notation via a
Curried adverb (aka, recurrent adverb and multiple adverb).
However, I have written (tacitly) a tacit Curried adverb (xi) which,
using
a lambda-style syntax, produces a tacit verb which in turn, given its
arguments, produces tacit entities. You might find xi interesting; the
general form is,
t=. [: v0 v1 ... vn '...' xi
The names v0 v1 ... vn should be syntactically verbs (recall, xi is a
Curried adverb) but they can represent nouns, verbs, adverbs, or
conjunctions. I use undefined names since those are regarded by
default as
verbs (even if xi does not affect in any way the named verbs). The
literal
'...' represents a quoted J (or more generally a Jx) sentence.
This is how your example can be written using xi,
erase 'b v'
[: v '([: b ''<:b++/\b-~-.b'' xi <''\''=v){."0 v' xi <'\\\//\\\//'
\
\
\
/
/
\
\
\
/
/
There is the nuisance of quotes within quotes and the argument must be
boxed; however, this allows, in general, the verb (t) to produce a
noun, a
verb, an adverb, or a conjunction and to take multiple boxed nouns,
verbs,
adverbs, or conjunctions as its argument. The following verb (t) acts
directly on a couple of (boxed) verbs and produces a verb,
t=. [: u v 'u/@:v' xi
t[:+*:]: NB. Sum of squares
+/@:*:
t[:+*:]: 1 2 3 4 5
55
t[:-%:]: NB. Difference of square roots
-/@:%:
t[:-%:]: 1 2 3 4 5
1.55390522
Note that the Curried higher-order verb (t) is, in effect, acting on two
arguments: [:-%:]: and 1 2 3 4 5; furthermore, t [:-%:]: performs a
partial
application of the verb (t) acting on [:-%:]: .
The following are variations of the verb produced in [0], the verb (t)
acts on a (boxed) conjunction and produces an adverb,
t=. [: u '(ver adv u)&:train/adv' xi
]`{.`{:`{: (t [:(<adv@:)]:) NB. Use [:(<'@:')sb in J
]@:({.@:({:@:{:))
]`{.`{:`{: (t [:(<adv@ )]:) NB. Use [:(<'@ ')sb in J
]@({.@({:@{:))
]`{.`{:`{: (t [:(<adv&:)]:) NB. Use [:(<'&:')sb in J
]&:({.&:({:&:{:))
These non-compliant features are not provided by the Jx interpreter;
they
are, in fact, inherited from the J interpreter, the Jx facilities
just make
them a lot more accessible. Actually, I have written a version
(admittedly
cumbersome) of xi in J; see [1] for a link to a zip archive and the
path to
a script where xi is defined.
PS.
erase'u0 u1 u2'
1 1 1
[: u0 u1 u2 'u0 + u1 + u2' xi 1 ; 2 ; 3
6
erase'α β γ'
1 1 1
[: u0 u1 u2 'u0 + u1 + u2' xi [:α β γ]:
α + β + γ
References
[0] [Jprogramming] Gerund composed application
http://www.jsoftware.com/pipermail/programming/2017-
September/048797.html
[1] J Wicked Toolkit
http://www.2bestsystems.com/foundation/j/Jx.zip
\Jx\J\J Wicked Toolkit.ijs
On Wed, Sep 27, 2017 at 5:10 AM, Erling Hellenäs
<[email protected]>
wrote:
Hi all !
Pascal, I will come back to your post later.
Here is a little compiler written in Jx and compiling, as I
understand it,
tacit code with explicit J syntax into tacit J. I did not test it, I
just
read the post.
http://www.jsoftware.com/pipermail/programming/2017-August/048143.html
The code snippet Farey is an example of the source code of the little
compiler.
I just think we should not have to use a tacit J compiler from
explicit J
to be able to use explicit J syntax and get a tacit result, a single
verb.
It would obviously be better to use explicit J syntax in the first
place,
as i see it.
Cheers,
Erling
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
