Inline comments follow...

>  Just wondering why
>
>   isgerund=: 3 : 0 :: 0
>   y at .]
>   1
>   )
>
>  isn't an acceptable test for “gerundality”?

( I do not think so; I answered this question earlier in another post. )

>
>  I also kind of agree with Bill, in the sense that J doesn’t seem to have
been
>  designed from the ground up (or halfway up for that matter) to facilitate
>  programmatically building code / functions with gerunds. Gerunds seem
>  to have been designed more for @. conditionals and sending multiple verbs

In a related post, I asked recently the following rhetorical question
quoting from the Dictionary's entry for the primitive @. ...

Incidentally, if is not for producing code (and executing code), what is
the purpose of "If n is boxed, the train is parenthesized accordingly. The
case m at .v uses the result of the verb v to perform the selection"?

>  to adverbs like }., and using foreigns to manipulate them just seems kind
>  of “hacky” to me.
>
>  This of course doesn’t mean that writing such code is impossible;
>  just that doing so leads to highly incomprehensible code (at least to
the casual J
>  programmer; sorry, but I haven’t the faintest idea how most of your
wicked tacit
>  wizardry works Pepe!) There are other languages such as Lisp whose lists
and

That is expected.  When I was forced to learn APL and I was shown some code
for producing a histogram it appeared incomprehensible to me.  Then, I
encountered non-trivial pure tacit verbs and I had a similar experience.
Finally, a few years ago I entered the wicked weird world of J.  In all
three cases, after persevering, soon enough all started to make sense to me
and I have never looked back.

>  highly regular syntax are designed specifically around that, or Haskell
where
>  currying means that any function taking more than one argument is a
higher-
>  order function returning another function; and J and APL’s syntaxes have
other
>  fortes, notably terseness and remarkable idiomatic qualities.
>
>  I feel that a big part of this comes from being able to write code that
does a lot
>  in a small space, with few parentheses, and with relatively simple
parsing rules;
>  and without the current noun-verb-adverb hierarchy, one of those three
qualities
>  would be lessened.

I do not expect and I have not noticed performance or compatibility issues;
but, more importantly, Windows and Unix/Linux Jx interpreters have been
made public and I would appreciate any feedback if you, or anyone else,
find any actual degradation versus a corresponding official (J806 source
commit 5cec3b69) interpreter.

>
>  Adding first-class verbs would kind of blur that hierarchy, and while
they are interesting
>  to have in unofficial interpreters I believe that the official
interpreter should stay
>  lean, efficient, relatively consistent, but especially practical to use
for the average

Sometimes I write half-seriously as in my recent comment to Marshall; allow
me to clarify: Proprietary Jx interpreters have been running for many years
to satisfy internal needs.  I decided to share some of those facilities
with the J community a few years back.  The chances I give to higher-order
functions (verbs, adverbs, and conjunctions) to become part of an official
J language are even lower than the chances that Unicode names become
compliant.  It does not really matter much to me one way or the other.  I
do not think you have to worry about that; nevertheless, I regard Jx still
as lean and efficient ;)

I do mind that the internal design (in contrast to the external behavior
enforcing, to some extent, compliance) of the interpreters, the one at the
C code level which apparently allows (by default) anything to act on
anything to produce anything, is preserved.  This, hopefully, would allow
Jx to tag along with J as the latter continues to evolve.  That was the
case up to J804 but I am not quite sure about J805 and j806.  I reported a
suspicious change in behavior for j805 (and J806) albeit for a relatively
complicated noncompliant case.  I keep a Jx version corresponding to J804
in reserve just in case; however, the J806 improvements seem to justify
what appears, so far, to be a small risk taken by using a J806 based Jx.

It would be nice if the back door is not closed in the official
interpreters because that has allowed me to share sometimes how some
adverbial programming problems can be attacked tacitly the wicked way using
official interpreters (all adverbial tasks can be attacked this way as far
as I can see).  I had an exchange with the current designer and implementer
of the language [0,1,2,3] when the back door was exposed; the door is still
open indicating that, at least, it has been tolerated.

>  J programmer. So the question is wether the “generality” or
“completeness” added
>  by first-class verbs is worth the losses in other areas.
>
>  All that to say that I agree with Bill that gerunds as they are now have
been designed
>  to be created with the tie conjunction, and while they are not perfect,
they are
>  an acceptable compromise.
>
>  Louis

[0]  [Jprogramming] A verb that returns non-nouns  Henry Rich
     http://www.jsoftware.com/pipermail/programming/2013-January/031261.html

[1]  [Jprogramming] A verb that returns non-nouns  Jose Mario Quintana
     http://www.jsoftware.com/pipermail/programming/2013-January/031264.html

[2]  [Jprogramming] A verb that returns non-nouns  Henry Rich
     http://www.jsoftware.com/pipermail/programming/2013-January/031265.html

[3]  [Jprogramming] A verb that returns non-nouns  Jose Mario Quintana
     http://www.jsoftware.com/pipermail/programming/2013-January/031312.html


On Fri, Aug 4, 2017 at 12:41 AM, Louis de Forcrand <ol...@bluewin.ch> wrote:

> Just wondering why
>
>         isgerund=: 3 : 0 :: 0
>                 y@.]
>                 1
>         )
>
> isn't an acceptable test for “gerundality”?
>
> I also kind of agree with Bill, in the sense that J doesn’t seem to have
> been
> designed from the ground up (or halfway up for that matter) to facilitate
> programmatically building code / functions with gerunds. Gerunds seem
> to have been designed more for @. conditionals and sending multiple verbs
> to adverbs like }., and using foreigns to manipulate them just seems kind
> of “hacky” to me.
>
> This of course doesn’t mean that writing such code is impossible;
> just that doing so leads to highly incomprehensible code (at least to the
> casual J
> programmer; sorry, but I haven’t the faintest idea how most of your wicked
> tacit
> wizardry works Pepe!) There are other languages such as Lisp whose lists
> and
> highly regular syntax are designed specifically around that, or Haskell
> where
> currying means that any function taking more than one argument is a higher-
> order function returning another function; and J and APL’s syntaxes have
> other
> fortes, notably terseness and remarkable idiomatic qualities.
>
> I feel that a big part of this comes from being able to write code that
> does a lot
> in a small space, with few parentheses, and with relatively simple parsing
> rules;
> and without the current noun-verb-adverb hierarchy, one of those three
> qualities
> would be lessened.
>
> Adding first-class verbs would kind of blur that hierarchy, and while they
> are interesting
> to have in unofficial interpreters I believe that the official interpreter
> should stay
> lean, efficient, relatively consistent, but especially practical to use
> for the average
> J programmer. So the question is wether the “generality” or “completeness”
> added
> by first-class verbs is worth the losses in other areas.
>
> All that to say that I agree with Bill that gerunds as they are now have
> been designed
> to be created with the tie conjunction, and while they are not perfect,
> they are
> an acceptable compromise.
>
> Louis
>
> > On 03 Aug 2017, at 19:31, Bill <bbill....@gmail.com> wrote:
> >
> > From my understanding, the reference shows the atomic representation of
> gerund. It does not advocate this a way to construct a gerund. moreover it
> is "foreign" conjunction.
> >
> > numbers can be converted from strings using foreign conjunction but it
> doesn't mean J encourages writing numbers using this method.
> >
> > IMO foreign conjunction is not a part of J core.
> >
> >
> > Sent from my iPhone
> >
> > On 4 Aug, 2017, at 5:33 AM, Jose Mario Quintana <
> jose.mario.quint...@gmail.com> wrote:
> >
> >> "
> >> In J dictionary, only tie conjunction
> >> on verbs was mentioned to produce a gerund.
> >> "
> >>
> >> I am afraid you might not be the only one who has reached such
> conclusion.
> >> Nevertheless, in my opinion, it is a misconception that a gerund can
> only
> >> be a list (of atomic representations) of verbs.  Why?  See [0] in the
> >> context of [1].
> >>
> >> [0] Atomic
> >>   http://www.jsoftware.com/help/dictionary/dx005.htm#1
> >>
> >> [1] [Jprogramming] how to test for a gerund  Roger Hui
> >>   http://www.jsoftware.com/pipermail/programming/2010-April/019178.html
> >>
> >> Mind you  gerundYN  is not bulletproof.
> >>
> >>
> >> On Thu, Aug 3, 2017 at 5:46 AM, bill lam <bbill....@gmail.com> wrote:
> >>
> >>> I am thinking of the opposite. In J dictionary, only tie conjunction
> >>> on verbs was mentioned to produce a gerund. Boxed verbs had not been
> >>> mentioned. Atomic representation of boxed verbs looks like that of
> >>> gerund and therefore can work as gerund. IMO this is a backdoor
> >>> provided by J implementation.
> >>>
> >>> Metadata could be attached to "real" gerunds that have ancestors which
> >>> were  results of verb`verb. All other nouns without this DNA would be
> >>> regarded as non-gerund.
> >>>
> >>> Just my 2 cents.
> >>>
> >>> On Thu, Aug 3, 2017 at 3:57 PM, Marshall Lochbaum <
> mwlochb...@gmail.com>
> >>> wrote:
> >>>> Can I just point out that it's not too late to add some (documented)
> way
> >>>> to box verbs/adverbs/conjunctions? These could be treated as gerunds
> by
> >>>> everything that currently uses gerunds, and the interpreter can just
> >>>> throw an error if anything attempts to actually unbox them. They are
> >>>> much harder to confuse than the current gerunds, and will have far
> >>>> better performance.
> >>>>
> >>>> This sounds like a radical divergence from the way J works now, but I
> >>>> don't think it is in practice. Programmers would use some new
> >>>> conjunction to replace (`), and provided they don't inspect the
> >>>> structure of gerunds nothing else changes. I suppose there would need
> to
> >>>> be a way to check what class of object a box contains, because
> unboxing
> >>>> to check the type is not allowed. Gerunds would remain useful for
> >>>> programmers who want to inspect functions or build them from scratch,
> >>>> but would otherwise become obselete.
> >>>>
> >>>> Marshall
> >> ----------------------------------------------------------------------
> >> 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

Reply via email to