The alternative to the monad version is

(u0 x) u1 F. v y

instead of

x u0@[ : (u1) F. v y

I put u1 in parens because it is likely a compound verb.

I've written both a "forward" explicit version of this and a tacit boxed 
version of "reverse", and favouring the tacit version, found I had no 
difficulty using only the tacit one.  I'd probably be fine if the short ops (F. 
and F:) where the forward or reverse one.

The issue I am bringing up is one of optimizing for typing speed.  Perhaps 
there is no important software cost to having 6 instead of 2 ops.  The ones 
that get the F. and F: mnemonics should be the best ones (from a typing 
efficiency perspective).

Maybe there is a case that current F. definition meets this criteria?

On the other hand, its important that F.. and F:. are effectively the same.  
And so if there are 6 ops, the existing assignment is ok.
From: Henry Rich <>
Sent: Friday, March 2, 2018 9:32 AM
Subject: Re: [Jprogramming] Insert initialising

From my own use, I use the Forward versions more than the Reverse, by a 
large margin, and I don't want to force the user to use |. needlessly.

Henry Rich

On 3/2/2018 9:12 AM, 'Pascal Jasmin' via Programming wrote:
> Very useful overall, but may I suggest 4 F. family versions (ommitting the 
> forward version).  This improves editability among variations, IMO, and makes 
> the operator codes easier to remember.
> With the above change, F. and F.. mnemonics should be swapped.  The "monad 
> first execution" has fewer applications than "initial value for reduce".
>        From: Henry Rich <>
>   To:
>   Sent: Friday, March 2, 2018 5:11 AM
>   Subject: Re: [Jprogramming] Insert initialising
> Marshall, please criticize the proposal at
> Others' criticism welcome too.
> Henry Rich
> On 3/2/2018 3:38 AM, Marshall Lochbaum wrote:
>> There's no clean way to do it. If the result of the first invocation of
>> f has the same type as the rest of the list elements, you can do
>> f/ _2 (}. , f0/@:{.) l
>> and if it has a different type you can check whether the right argument
>> has this type (like your "signature structure", but implicit).
>> One of my most missed features in J is a reduce with a specified initial
>> element. Thus (l f/ e) would be equivalent to (> f&.>/ (<"_1 l),<e) but
>> without the very large inefficiency of boxing everything. Of course
>> dyadic f/ is already taken, so it would need another symbol. With this
>> feature, you could use (_2 (}. f/ f0/@:{.) l) regardless of the
>> properties of f.
>> If your initialization comes before any of the processing and doesn't
>> change the arguments (so that the first function invocation f0 is
>> equivalent to (f[i0) for some initializer i0), then you can use
>> (f/ l [ i0/ _2{.l), that is, separate the initialization from the
>> function application completely.
>> Marshall
>> On Fri, Mar 02, 2018 at 01:51:39PM +0530, Arnab Chakraborty wrote:
>>> Hi,
>>>      If f is a dyad, then
>>> f/ 2 4 5
>>> means
>>> 2 f 4 f 5
>>> where the rightmost occurence of f is invoked first. I am wondering if
>>> there is a smart way to recognize this first invocation separately from the
>>> rest. This will enable me to perform some initialization inside f. By
>>> "smart" I mean something smarter than the followung two:
>>> 1) using side effect like setting a global flag.
>>> 2) adding some signature structure to the output of f (eg, 'inited';
>>> result),
>>>        and then checking the absence of this signature.
>>> Thanks.
>>> ----------------------------------------------------------------------
>>> For information about J forums see
>> ----------------------------------------------------------------------
>> For information about J forums see
> ---
> This email has been checked for viruses by AVG.

> ----------------------------------------------------------------------
> For information about J forums see
> ----------------------------------------------------------------------
> For information about J forums see

For information about J forums see
For information about J forums see

Reply via email to