> Any definition of gerunds limited to atomic representations of verbs is
an oversimplification (for natural language gramatical analogy). It should
be atomic representations without limitations. @. and `:6 can produce nouns
and modifiers from their atomic representations.
I fully agree with you (except that, to me, the name gerund would be
irrelevant as long as, for example, (`:6) would continue to make sense of
those forms); I would go even further. I would include *anything* that
(`:6) can take and make sense of it (at least up to J807), these include
forms that are not necessarily confined to lists of atomic representations;
I included a couple in my first post, to wit,
(9!:3) 5 2 NB. Box (display) and linear representations...
(<(<<(,'0');3),(<,'+'),<<(,'0');5),(<,'*'),<<(,'0');2 NB. (3 + 5) * 2
┌───────────────────┬─┬───────┐
│┌───────┬─┬───────┐│*│┌─────┐│
││┌─────┐│+│┌─────┐││ ││┌─┬─┐││
│││┌─┬─┐││ ││┌─┬─┐│││ │││0│2│││
││││0│3│││ │││0│5││││ ││└─┴─┘││
│││└─┴─┘││ ││└─┴─┘│││ │└─────┘│
││└─────┘│ │└─────┘││ │ │
│└───────┴─┴───────┘│ │ │
└───────────────────┴─┴───────┘
((<(<<(,'0');3),(<,'+'),<<(,'0');5),(<,'*'),<<(,'0');2) (`:6)
16
and
(<(<,'"'),<<(,'0');1),<(<'@:'),<;:'>@:{' NB. ("1)(@:(>@:{))
┌───────────┬─────────────┐
│┌─┬───────┐│┌──┬────────┐│
││"│┌─────┐│││@:│┌─┬──┬─┐││
││ ││┌─┬─┐││││ ││>│@:│{│││
││ │││0│1│││││ │└─┴──┴─┘││
││ ││└─┴─┘│││└──┴────────┘│
││ │└─────┘││ │
│└─┴───────┘│ │
└───────────┴─────────────┘
((<(<,'"'),<<(,'0');1),<(<'@:'),<;:'>@:{') (`:6)
("1)(@:(>@:{))
┌─────┬─────────────┐
│┌─┬─┐│┌──┬────────┐│
││"│1│││@:│┌─┬──┬─┐││
│└─┴─┘││ ││>│@:│{│││
│ ││ │└─┴──┴─┘││
│ │└──┴────────┘│
└─────┴─────────────┘
The nuvoc page for ` includes the "gramatically" qualifier which makes it
an acceptable "simplification explainer"
I hope you are correct. However, it seems to me that both, the Dictionary
and NuVoc, imply that what is not explicitly allowed is forbidden. If so,
NuVoc's entry for evoke (`:) reads "If m is a gerund, m`:n creates a verb
based on m." which would imply that, regardless of the implementation,
producing anything else, apart from verbs, would be considered illegal (I
would be glad to be corrected by the powers that be).
Your an definition differs from my ar definition in that ar accepts verbs.
You are right, of course; but, my (mildly tested) claim was that my adverb
ar=. an f.hg, not the verb an, is a tacit counterpart of your explicit
adverb ar =: 1 : '5!:1 <''u''' and my adverb ar also accepts verbs (in
addition to nouns),
<^:(L. < *@#) ar
┌─────────────────────────────┐
│┌──┬────────────────────────┐│
││^:│┌─┬────────────────────┐││
││ ││<│┌─┬────────────────┐│││
││ ││ ││3│┌──┬─┬─────────┐││││
││ ││ ││ ││L.│<│┌─┬─────┐│││││
││ ││ ││ ││ │ ││@│┌─┬─┐││││││
││ ││ ││ ││ │ ││ ││*│#│││││││
││ ││ ││ ││ │ ││ │└─┴─┘││││││
││ ││ ││ ││ │ │└─┴─────┘│││││
││ ││ ││ │└──┴─┴─────────┘││││
││ ││ │└─┴────────────────┘│││
││ │└─┴────────────────────┘││
│└──┴────────────────────────┘│
└─────────────────────────────┘
I also use aar to handle modifiers (and names distinguished from strings)
It turns out that my ar (and yours as well) can deal with any word, not
just nouns and verbs, if one can manage to pass the word as an argument.
So, if I had to find the atomic representations of words defined in
literals using an official J interpreter, I would use J807 or earlier and
go the wicked tacit way using my J Tacit Toolkit...
l2a=. (Ver'ar') o train o as f. NB. literal to atomic (verb)
l2a 'i.2 3'
┌─────────┐
│┌─┬─────┐│
││0│0 1 2││
││ │3 4 5││
│└─┴─────┘│
└─────────┘
l2a '<^:(L. < *@#)'
┌─────────────────────────────┐
│┌──┬────────────────────────┐│
││^:│┌─┬────────────────────┐││
││ ││<│┌─┬────────────────┐│││
││ ││ ││3│┌──┬─┬─────────┐││││
││ ││ ││ ││L.│<│┌─┬─────┐│││││
││ ││ ││ ││ │ ││@│┌─┬─┐││││││
││ ││ ││ ││ │ ││ ││*│#│││││││
││ ││ ││ ││ │ ││ │└─┴─┘││││││
││ ││ ││ ││ │ │└─┴─────┘│││││
││ ││ ││ │└──┴─┴─────────┘││││
││ ││ │└─┴────────────────┘│││
││ │└─┴────────────────────┘││
│└──┴────────────────────────┘│
└─────────────────────────────┘
l2a '("1)(@:(>@:{))'
┌───────────────────────────────────────┐
│┌─┬───────────────────────────────────┐│
││4│┌─────────────┬───────────────────┐││
││ ││┌─┬─────────┐│┌─┬───────────────┐│││
││ │││4│┌─┬─────┐│││4│┌──┬──────────┐││││
││ │││ ││"│┌─┬─┐││││ ││@:│┌──┬─────┐│││││
││ │││ ││ ││0│1│││││ ││ ││@:│┌─┬─┐││││││
││ │││ ││ │└─┴─┘││││ ││ ││ ││>│{│││││││
││ │││ │└─┴─────┘│││ ││ ││ │└─┴─┘││││││
││ ││└─┴─────────┘││ ││ │└──┴─────┘│││││
││ ││ ││ │└──┴──────────┘││││
││ ││ │└─┴───────────────┘│││
││ │└─────────────┴───────────────────┘││
│└─┴───────────────────────────────────┘│
└───────────────────────────────────────┘
l2a '''bind'' f.'
┌───────────────────────┐
│┌─┬───────────────────┐│
││:│┌─────┬───────────┐││
││ ││┌─┬─┐│┌─┬───────┐│││
││ │││0│2│││0│x@(y"_)││││
││ ││└─┴─┘│└─┴───────┘│││
││ │└─────┴───────────┘││
│└─┴───────────────────┘│
└───────────────────────┘
UNO=. 1
l2a '''UNO'' f.'
┌─────┐
│┌─┬─┐│
││0│1││
│└─┴─┘│
└─────┘
If I had to use J901 then, at least for now, I would use,
l2a=. verb : '(5!:1)<''y'' [ ".''y=. '' , y'
and live with potential side effects,
UNO=. 1
l2a '''UNO''f.'
┌─────┐
│┌─┬─┐│
││0│1││
│└─┴─┘│
└─────┘
y=. 1
l2a '''y''f.'
┌─────────┐
│┌─┬─────┐│
││0│'y'f.││
│└─┴─────┘│
└─────────┘
On Sun, Mar 1, 2020 at 12:03 PM 'Pascal Jasmin' via Programming <
programm...@jsoftware.com> wrote:
Any definition of gerunds limited to atomic representations of verbs is
an oversimplification (for natural language gramatical analogy). It should
be atomic representations without limitations. @. and `:6 can produce nouns
and modifiers from their atomic representations. The nuvoc page for `
includes the "gramatically" qualifier which makes it an acceptable
"simplification explainer"
In example 2 of that page,
"NB. x is 3 gerunds; execute one on y, depending on the sign of y"
mistakenly uses gerunds instead of "atomic representations"
I've always used gerund to mean a list of atomic representations. One
basis to think so: +`'' produces a list of one item
Your an definition differs from my ar definition in that ar accepts verbs.
I also use aar to handle modifiers (and names distinguished from strings)
aar =: 1 : 'if. isNoun ''u'' do. q =. m eval else. q =. u end. 5!:1 <
''q'''
eval =: 1 : 'if. 2 ~: 3!:0 m do. m else. a: 1 : m end.'
isNoun =: (0 = 4!:0 ::0:)@:<
+ aar
┌─┐
│+│
└─┘
three =: 3
'three' ar
┌─────────┐
│┌─┬─────┐│
││0│three││
│└─┴─────┘│
└─────────┘
'three' aar
┌─────┐
│┌─┬─┐│
││0│3││
│└─┴─┘│
└─────┘
'/\' aar
┌─┐
│/│
└─┘
'/\' aar
┌─────────┐
│┌─┬─────┐│
││4│┌─┬─┐││
││ ││/│\│││
││ │└─┴─┘││
│└─┴─────┘│
└─────────┘
On Sunday, March 1, 2020, 09:07:05 a.m. EST, Jose Mario Quintana <
jose.mario.quint...@gmail.com> wrote:
In my previous post I wrote,
"First I thought that only atomic representations of trains of verbs were
allowed"
but I should have written instead,
"First I thought that only nouns representing trains of verbs under de
adverb train (`:6) were allowed"
that is, for instance, ((u`v)`w) where u,v, and w are verbs is valid.
(I should stop writing posts to the forum and watching fights
simultaneously.)
On Sun, Mar 1, 2020 at 12:35 AM Jose Mario Quintana <
jose.mario.quint...@gmail.com> wrote:
< Though that lr bug caused the problems with f. that we both have noted
in the past.
Right, I remember; however, I think the issue reverts back to what,
officially, a gerund is, or more generally what are admissible arguments
to
train (`:6), agenda (@.), and tie (`) (and their products) because if an
entity is not valid a faulty linear representation of it might not be
regarded as a bug.
On the one hand, the dictionary was ambiguous (and permissive in my
mind)
on this subject but my understanding is that NuVoc is nowadays the
official
documentation; thus, a gerund is "the atomic representation of a verb, or
a
list thereof" (which among other things implies that your isgerund verb
might need to be revised or renamed). After reading the tie (`) entry is
not entirely clear to me what are valid values for n and m. First I
thought that only atomic representations of trains of verbs were allowed,
but apparently '' is also considered valid in some instances. Perhaps,
for
example, the use of (3 ar) in,
((3 ar)`*`])
┌─────┬─┬─┐
│┌─┬─┐│*│]│
││0│3││ │ │
│└─┴─┘│ │ │
└─────┴─┴─┘
((3 ar)`*`]) (`:6)
3 * ]
is invalid because (3 ar) is not the atomic representation of a verb.
In
addition,
+ ((3 ar)`) (`(5 ar))
┌─────┬─┬─────┐
│┌─┬─┐│+│┌─┬─┐│
││0│3││ ││0│5││
│└─┴─┘│ │└─┴─┘│
└─────┴─┴─────┘
seems to be an invalid use of ties even if only because
+ ((3 ar)`) (`(5 ar)) (`:6)
8
is a noun rather than a verb.
On the other hand, there has been an effort in the past to correct
similar faulty linear representations that have been pestering some of us
for many years. Maybe they are invalid but tolerated; several years ago I
wrote the following tacit double adverb (hg) which allows one to produce a
wide class of tacit adverbs by reducing the task of tacit adverbial
programming to tacit verbal programming. When I wrote hg Dan and I
thoutght it was kosher but nowadays apparently it is not,
o=. @:
c=."_
ar=. 5!:1@:<
d=. (a0=. `'') (a1=. (@:[) ((<'&')`) (`:6)) (a2=. (`(<(":0);_)) (`: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
d=. (a3=. (@: (aw f.)) ('av'f.)) (a4=. "_) (a5=. `:6)
a6=. ((( ar'a4') ; ] ; ( ar'a3')"_) ('av'f.)) (`:6)
NB. hg...
hg=. `((ar'a6')`(ar'a5')) (`:6)
assert (*: 1 2 3) -: 1 2 3 ((<'*:') ; ] )
hg
assert (*/ 1 2 3) -: * (< , ((<'/')c))
hg 1 2 3
assert ((*: - +/\)1 2 3) -: (*:`(+/\)) (0&{ , (<'-') ,
1&{)@:(('';1)&{::) hg 1 2 3
erase'a0 a1 a2 a3 a4 a5 a6 av aw d'
A simple application is to produce a tacit version of your ar adverb
(mildly tested),
an=. <@:((,'0') ,&:< ])f. NB. Atomizing words (monadic verb)
ar=. an f.hg
A shorter tacit version of ar exists but the point is that hg can
produce
a tacit version of the adverb ar as well as lots of other tacit adverbs.
The linear representations of both adverbs (hg and ar) are faulty; that
is,
running on J807, I have not tried with J901.
P.S. I merely have a mild academic interest on this matter since I
neither use J901 nor J807 for any important work.
On Thu, Feb 27, 2020 at 11:04 PM 'Pascal Jasmin' via Programming <
programm...@jsoftware.com> wrote:
Henry reported (I think/thought) fixing this display (lr) bug within
the j9 cycle.
Though that lr bug caused the problems with f. that we both have noted
in the past.
There are 2 separate display bugs with "partial gerunds" (bound adverb
with `)
((<(,'0');3)`) NB. not equivalent to displayed result
<(,'0');3`
Any other adverb "trained" with partial gerund creates a more obvious
distortion
/((<(,'0');3)`)
/(3`)
though it still works (internally it is not messed up as display)
+(/((<(,'0');3)`))
┌─────┬───────┐
│┌─┬─┐│┌─┬───┐│
││0│3│││/│┌─┐││
│└─┴─┘││ ││+│││
│ ││ │└─┘││
│ │└─┴───┘│
└─────┴───────┘
----------------------------------------------------------------------
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
