Gerunds may be produced by boxing, but it doesn't follow that anything
produced by boxing is a gerund.
Look at the definition of `: where it is clear that the result of
evoking a gerund must be a verb.
Henry Rich
On 9/4/2018 11:54 AM, Raul Miller wrote:
Ok... (deep breath)...
Here is something that the dictionary says:
"In English, a gerund is a noun that carries the force of a verb, as
does the noun cooking in the art of cooking. The tie applies to two
verbs to produce a gerund. Gerunds are commonly used with Insert (/)
and with Agenda (@.):
"More generally, tie produces gerunds as follows: u`v is au,av , where
au and av are the (boxed noun) atomic representations (5!:1) of u and
v . Moreover, m`n is m,n and m`v is m,av and u`n isau,n . See Bernecky
and Hui [12]. Gerunds may also be produced directly by boxing. ..."
-- http://www.jsoftware.com/help/dictionary/d610.htm
And then it goes on with some examples.
This suggests that any value that has an atomic representation could
be a valid part of a gerund.
The syntax of the tie conjunction only accepts nouns and verbs, but
gerunds are an array and we use gerunds to represent the components of
gerunds (where they have structure). For example, the gerund for +&3
includes the atomic representation of &
You could introduce rules which eliminate some atomic representations,
but that would create problems in the code which implements gerunds
(because now you need to introduce some other mechanism to handle
those cases).
That said, the actual implementation is instead:
"... tie produces gerunds as follows: u`v is au,av , where au and av
are the (boxed noun) atomic representations (5!:1) of u and v where u
and v are verbs. Tie does not use the atomic representation of u where
u is a noun, as u would often be a gerund."
(The current implementation also doesn't use the atomic representation
of v, when v is a noun. But this could be considered an implementation
flaw. So I left that detail out of my representation of the current
implementation.)
That said, it would be simple to change the implementation so that it
is consistent with the current dictionary writeup: Have the parser
track what the previous operation was. If the previous operation was
tie, tie would not use the ar of u. If the previous operation was
anything else, tie would use the ar of u. (Note that this works
specifically because of J's syntax rules for conjunctions.)
This would be a breaking change. For example, the result of 1`2`3
would be different.
This would also mean that (a`b)`c would produce a different result from a`b`c
(This would also mean that if you want to build up a long gerund
across multiple sentences, you'll need to to use append (,) instead of
tie to join the component gerunds together.)
This kind of change would also warrant a writeup describing the issue
(perhaps in the release notes).
Thanks,
---
This email has been checked for viruses by AVG.
https://www.avg.com
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
