Made a mistake in typing the 2nd 4 argument conjunction. should be: # % % (`(`h)) (+/)
(%`(+/))(`h)) # (% (%`(+/))(`h))) % +/ % # On Monday, October 4, 2021, 11:41:31 p.m. EDT, Raul Miller <[email protected]> wrote: If we tried to execute: # % % ((``)(`h)) (+/) with your proposed CC mechanism, why wouldn't we get a result of # %`(+/)`%(`h) 3(`h) ? Thanks, -- Raul On Mon, Oct 4, 2021 at 10:54 PM 'Pascal Jasmin' via Programming <[email protected]> wrote: > > using either ``(`:6) or `h > > means 3 parameters in total, with leftmost conjunction bound with initial u/v > and returns an adverb to bind the 3rd parameter which will become the v > parameter to right conjunction. so > > # +/ (`h) % > > +/ % # > > then for the 4 tine, triple conjunction > > # % u ((``)(`h)) (+/) > > u +/ % # > > > Even if it looks ugly, it allows for easy composability. > > > > > On Monday, October 4, 2021, 10:29:56 p.m. EDT, Raul Miller > <[email protected]> wrote: > > > > > > Hmm... > > You do have some extra parenthesis there. > > Or, this works: > % ((+/`) (``:6) ]:) # > +/ % # > > And, I suppose I should point out that > {{% +/ u v}} > would work similarly to your (((+/`) h ]:)(% h)), and is concise. > > That said, ((``)`)(`:6) is presumably shorthand for something longer > (you need that +/ in there somehow, if I understand what you are > saying ... though I also have not convinced myself of how it would > work, and with +/ in there I don't see how your CC syntax can be > relevant). > > Take care, > > -- > Raul > > On Mon, Oct 4, 2021 at 9:46 PM 'Pascal Jasmin' via Programming > <[email protected]> wrote: > > > > To get the intuitive potential functionality instead of a syntax error > > > > AAC must be written in form of ACA as (AA)C]: , and > > AACA must also be transformed into ACA as (AA)CA > > > > as concrete example > > > > % ((+/`) (`(`:6)) ]:) # > > > > +/ % # > > > > with h =. `(`:6) > > > > (+/`) is a new train that used to have to be written ((+/)`) > > > > composing with h requires the right A (]:) to form ACA train. > > > > suppose you now want to enhance your total modifier by putting a % as a > > leading train tine (normalize data to multiple of average) > > > > it is relatively easy to compose to the right. > > > > % (((+/`) h ]:)(% h)) # NB. still requires parenthesizing full expression > > > > % (+/ % #) > > > > > > Exercise for the reader on how the enhancement could be composed by having > > say (%`) towards left of expression as composing strategy. > > > > with my CC proposal, the first would be > > > > ``(`:6) or (``)`:6 > > > > and 2nd > > > > ((``)`)(`:6) > > > > > > > > On Monday, October 4, 2021, 08:28:06 p.m. EDT, Raul Miller > > <[email protected]> wrote: > > > > > > > > > > > > But AAC and AACA are not adverb trains, and as near as I can tell have > > always been syntax errors. > > > > Anyways, it's difficult to talk about such things without useful examples. > > > > Thanks, > > > > -- > > Raul > > > > On Mon, Oct 4, 2021 at 7:25 PM 'Pascal Jasmin' via Programming > > <[email protected]> wrote: > > > > > > > > > Overbracketting AA..A is needed because AAC is not defined, and to get > > > AACA, (AA)CA must be done. > > > > > > CAA is already defined equivalent to C(AA) > > > > > > > > > > > > > > > > > > On Monday, October 4, 2021, 06:24:30 p.m. EDT, Raul Miller > > > <[email protected]> wrote: > > > > > > > > > > > > > > > > > > I do not think I need to "over bracket" AAAA now. > > > > > > Near as I can tell, J903's version an adverb train produces the same > > > consequences that we get from j902's version of an adverb train. > > > > > > Do you have any examples where this is not the case? > > > > > > Thanks, > > > > > > -- > > > Raul > > > > > > On Mon, Oct 4, 2021 at 4:35 PM 'Pascal Jasmin' via Programming > > > <[email protected]> wrote: > > > > > > > > > That said, this was also a syntax error when we did not have > > > > conjunction trains. So I am not sure why it should be an important > > > > issue now. > > > > > > > > if you stick to old permissible AA...A trains then you don't need to > > > > "over" bracket (AA..A) > > > > > > > > for CAA..A you also don't need to bracket (for practical purposes) > > > > > > > > for AA..ACA, you do need to over bracket the left part. > > > > > > > > > > > > There are new powers that allow including unbound Cs inside adverb > > > > trains. That is awesome!!! The disadvantage of imposing tedium on > > > > these new powers is greater than the advantage of not double typing out > > > > u in uCu, in my opinion. > > > > > > > > > > > > On Monday, October 4, 2021, 04:20:13 p.m. EDT, Raul Miller > > > > <[email protected]> wrote: > > > > > > > > > > > > > > > > > > > > > > > > Hmm... > > > > > > > > Conceptually speaking, the A A C A syntax error could be eliminated > > > > without the addition of any new parsing rules, if A A C would > > > > translate to two parse elements (combining the two adverbs and putting > > > > the C back as-is). > > > > > > > > That said, this was also a syntax error when we did not have > > > > conjunction trains. So I am not sure why it should be an important > > > > issue now. > > > > > > > > I also don't know if there are other implications. I haven't thought > > > > about it that much. > > > > > > > > Are you aware of other important cases? > > > > > > > > Thanks, > > > > > > > > -- > > > > Raul > > > > > > > > On Mon, Oct 4, 2021 at 3:43 PM 'Pascal Jasmin' via Programming > > > > <[email protected]> wrote: > > > > > > > > > > Going to use reply to Pepe as a case for changing trains before its > > > > > too late (ie before they get used) > > > > > > > > > > > > > > > > hook=. `(`:6) NB. (Equivalently, hook=. ``:6) > > > > > > > > > > This is an excellent contribution that shows the CC hook (defined as > > > > > duplicate arguments: (u C1 v)(u C2 v) offers no benefits. > > > > > > > > > > The only imaginable cases so far is to produce a hook, or to return > > > > > (u n) or (v m) to caller context. > > > > > > > > > > the only possible use of u n over u y (which would occur without the > > > > > CC) is that it is possible to bind u or n partially in an expression, > > > > > or if u n returns a verb or modifier. There is no natural u which > > > > > can legally do the former. > > > > > > > > > > It is possible to create a conjunction that replaces ` such that will > > > > > accept nouns or verbs as its arguments and produce gerunds. Without > > > > > full definition, my version is: > > > > > > > > > > ti =: 2 : 0 > > > > > > > > > > if. -. u isgerundA do. u =. u ar end. > > > > > > > > > > if. -. v isgerundA do. v =. v ar end. > > > > > > > > > > u,v > > > > > > > > > > ) > > > > > > > > > > a different conjunction is possible/needed if it is to allow quoted > > > > > modifiers to have their atomic representation included. > > > > > > > > > > with h. =: ti`:6 > > > > > > > > > > with u ti n `:6 not legally capable of forming a verb or modifier, it > > > > > is still possible to create that functionality with u n producing a > > > > > string, and > > > > > > > > > > h.(1 :) > > > > > > > > > > could then be used to turn that future string computation into an > > > > > adverb. > > > > > > > > > > C C -> ((u C1 v)C2) > > > > > > > > > > has benefits compared to using workarounds... Benefits > no benefits. > > > > > > > > > > > > > > > In the case of A C -> adv: u A (C u) > > > > > > > > > > the only "mainstream" benefit is the ability to make a conjunction > > > > > "reflexive" (]: C) > > > > > > > > > > theoretical completeness aside, this is not a huge programming > > > > > application, though if you knew a different way to provide this in a > > > > > quoteless manner, that would be best to eliminate all benefits. > > > > > > > > > > Even if some possiblity is created, benefits are inferior compared to > > > > > this AC definition: > > > > > > > > > > A C -> u A (C v) > > > > > > > > > > similar to A C A of A C ]: > > > > > > > > > > The annoyance of A C A pattern is that (A A) C A must be explicit to > > > > > have a sane interpretation. More parentheses means more tedious > > > > > annoyances in writting code, and avoiding tedious annoyances is a > > > > > benefit. > > > > > > > > > > My total vision for the trains is that it is higher value to have > > > > > auto "pairing"/parenthesizing of "free" u and v's near Cs, than the > > > > > general minimal benefits that exist from the trains, although I will > > > > > also support the explicit triple parenthesing of as one example (V V > > > > > C) as superceding the auto-pairing rules. > > > > > > > > > > But forcing AA...A trains to now be parenthesized sometimes is a > > > > > major tedium downgrade compared to previous versions of J. > > > > > > > > > > So, for sure I will always hate AC and CC if they persist past beta. > > > > > > > > > > Reflexive conjunctions don't have the same mathematical symmetry of > > > > > applying well understood model/concepts of doubling, squaring, 0 and > > > > > 1 which are so well understood that they have their own primitives > > > > > instead of using reflexive forms. If you know you want a reflexive > > > > > conjunction application, then you can be forced into the tedious > > > > > repetition of uACu or uCu. > > > > > > > > > > Even though each potential implementation of AC creates tedium in > > > > > some applications, it is far more tedious to parenthesize many future > > > > > AA trains then to provide duplicate conjunction parameters which no > > > > > built in conjunctions have any meaningful conceptual frameworks for. > > > > > Exception example: > > > > > > > > > > quadruple =: +:(]:@) NB. requires 2 more "shifted upper row" typing > > > > > characters than +:@+. Reading requires looking up the never used > > > > > (]:C) pattern. > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > On Saturday, October 2, 2021, 07:51:20 p.m. EDT, Jose Mario Quintana > > > > > <[email protected]> wrote: > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > 1. it breaks existing valid code. > > > > > > > > > > Certainly, I had to repair my hg adverb in a couple of places (see > > > > > below) > > > > > > > > > > > Alternative of (C0 V1) C2 turns this into A C train which has useful > > > > > interpretation. Avoids parentheses in > > > > > > > > > > I am fond of the C0 A1 bident and to a lesser extent of the A0 C1 A2 > > > > > trident. I like to write a pseudo while conjunction as, > > > > > > > > > > w=. ^:(^:_) NB. (Equivalently, using a resurrected trident, w=. > > > > >^:^:_ ) > > > > > > > > > > u w v > > > > > |value error > > > > > | u w v > > > > > > > > > > Darn! This new annoying feature that now triggers errors related to > > > > > m,n,u,v,x, and y even outside the scope of explicit forms is > > > > > interfering. > > > > > Trying again, > > > > > > > > > > alpha w beta > > > > > alpha^:beta^:_ > > > > > > > > > > However, the main reason I like it is that the production of tacit > > > > > conjunctions can be reduced to the production of related adverbs; for > > > > > example, the conjunction (hook) to produce a hook can be written as, > > > > > > > > > > hook=. `(`:6) NB. (Equivalently, hook=. ``:6) > > > > > > > > > > alpha hook beta > > > > > alpha beta > > > > > > > > > > Alternatively, after scripting a repaired hg adverb script (that is, > > > > > by > > > > > replacing the corresponding lines by > > > > > > > > > > d=. (a3=. (@: (aw f.)) ('av'f.)) (a4=. "62) (a5=. `:6) > > > > > > > > > > and > > > > > > > > > > hg=. (`((ar'a6')`(ar'a5'))) (`:6) > > > > > > > > > > ), > > > > > > > > > > hook=. ]hg > > > > > > > > > > alpha hook beta > > > > > alpha beta > > > > > > > > > > Moreover, using a suitable tacit verb instead of ] one can produce any > > > > > arbitrary form that is a function of its arguments with one caveat: > > > > > noun > > > > > arguments would have to be boxed. This brings me to the A0 C1 A2 > > > > > trident. > > > > > > > > > > This trident can be used to operate on raw noun arguments. One can > > > > > define > > > > > first a noun boxing adverb, > > > > > > > > > > box=. ((<,'<') ; ])hg > > > > > assert (<1 2 3) -: 1 2 3 box > > > > > > > > > > (Incidentally, I realize I am using a shotgun to kill a fly, I know I > > > > > can > > > > > easily use a pistol instead but I wonder what would be a gentle and > > > > > kind > > > > > method to kill this fly (that is, to produce a nicer equivalent > > > > > adverb to > > > > > the box adverb) using the resurrected trains or your alternative > > > > > versions.) > > > > > > > > > > Then one can operate on noun arguments; for instance, > > > > > > > > > > 1 2 3 ((box ` box)(] hg)) (u0`u1`u2) > > > > > ┌─────┬──────────┐ > > > > > │1 2 3│┌──┬──┬──┐│ > > > > > │ ││u0│u1│u2││ > > > > > │ │└──┴──┴──┘│ > > > > > └─────┴──────────┘ > > > > > > > > > > Again, replacing ] above by a suitable verb one can produce, in > > > > > principle, > > > > > any arbitrary form (that is a function of its arguments); for > > > > > example, the > > > > > conjunction (linear) which produces the corresponding linear > > > > > combination of > > > > > a list of verbs represented by the gerund can be produced as follows, > > > > > > > > > > 9!:14'' NB. By the way... > > > > > j903/j64/windows/beta-r/commercial/ > > > > > www.jsoftware.com/2021-09-26T14:46:15/clang-12-0-0/SLEEF=1 > > > > > > > > > > e=. &.> > > > > > x=. @:[ > > > > > y=. @:] > > > > > > > > > > left=. ('';1;0)&{:: > > > > > right=. ('';1;1)&{:: > > > > > plus=. ([ , (<,'+') , ]) > > > > > times=. < o ([ , (<,'*') , ]) > > > > > > > > > > linear=. (box`box)((an e o left > o ((plus e/) . (times e)) <e o > > > > >right) > > > > > hg) > > > > > linear=. 'linear'f. > > > > > > > > > > 0 1 2 linear (u0`u1`u2) > > > > > (00 * u0) + (01 * u1) + 2 * u2 > > > > > 1 0j2 3j3 linear (^.`(% + ^)`(1 + *:)) > > > > > (1j0 * ^.) + (0j2 * % + ^) + 3j3 * 1 + *: > > > > > > > > > > (The linear conjunction is not only tacit (and fixed), > > > > > > > > > > _66 [\ (5!:5)@:<'linear' > > > > > (((("62)((`'') (&(((<,'<') ; ])@:(<@:((0;1;0)&({::)))@:[)) ((`(<(, > > > > > '0');_))(`:6))))(`:6)) ` ((("62)((`'') (&(((<,'<') ; ])@:(<@:((0;1 > > > > > ;0)&({::)))@:[)) ((`(<(,'0');_))(`:6))))(`:6)))((("62)((`'') (&((< > > > > > @:((,'0') ,&:< ])&.>@:(('';1;0)&({::)) >@:(([ , (<,'+') , ])&.>/ . > > > > > (<@:([ , (<,'*') , ])&.>)) <&.>@:(('';1;1)&({::)))@:(<@:((0;1;0)&( > > > > > {::)))@:[)) ((`(<(,'0');_))(`:6))))(`:6)) > > > > > > > > > > but it was produced tacitly, which is the only acceptable way from the > > > > > perspective of a genuine tacit fan(atic). ;) ) > > > > > > > > > > I am curious, again, to see how old-timers or newcomers can employ the > > > > > resurrected bidents and tridents (or your alternative versions) to > > > > > facilitate simpler equivalent versions of the linear conjunction shown > > > > > above. > > > > > > > > > > P.S. I do know how to produce a conceptually simpler, at least in my > > > > > mind, > > > > > version of the linear conjunction (if necessary, as a curried adverb > > > > > which > > > > > effectively takes a couple of arguments (aka, double adverb); for > > > > > instance > > > > > when using a j807 interpreter) the wicked way. That is by casting > > > > > blasphemous spells which compel tacit verbs to produce also verbs, > > > > > adverbs, > > > > > and conjunctions; just as adverbs and conjunctions do. In fact, I > > > > > wrote > > > > > the linear conjunction first the wicked way and use it as a model for > > > > > writing the orthodox version (shown above) afterward. > > > > > > > > > > 9!:14'' > > > > > j807/j64nonavx/windows/release/commercial/ > > > > > www.jsoftware.com/2018-10-05T10:48:34 > > > > > > > > > > NB. After scripting the wicked tacit toolkit... > > > > > > > > > > plus=. [: [ +cv ] Train > > > > > times=. [: [ *cv ] Train > > > > > > > > > > linear=. > o (an e x ((plus e/) . (times e)) < o train "0 y) f.s2c > > > > > > > > > > 0 1 2 (u0`u1`u2) linear > > > > > (0 * u0) + (1 * u1) + 2 * u2 > > > > > > > > > > 1 0j2 3j3 (^.`(% + ^)`(1 + *:)) linear > > > > > (1 * ^.) + (0j2 * % + ^) + 3j3 * 1 + *: > > > > > > > > > > > > > > > > > > > > ---------------------------------------------------------------------------------- > > > > > > > > > > > > > > > On Mon, Sep 27, 2021 at 8:26 PM 'Pascal Jasmin' via Programming < > > > > > [email protected]> wrote: > > > > > > > > > > > > Lets start with the 2 worst, irredeemable most useless, trains > > > > > > > > > > > > C0 V1 C2 -> (u C0 v) V1 (u C2 v) fork result. duplicating input to > > > > > > both > > > > > edge conjunctions. Will never be used. > > > > > > > > > > > > Alternative of (C0 V1) C2 turns this into A C train which has useful > > > > > interpretation. Avoids parentheses in one of the 2 natural > > > > > (validating) > > > > > parenthesizings of this string. > > > > > > > > > > > > C1 A2 -> u C1 (u A2) . A far less dumb alternative would be u C1 (v > > > > > A2). At least both AC and CA would be conjunctions. > > > > > > > > > > > > I prefer (u C1 v) A2 out of consistency and coherence. While u C1 > > > > > > (v A2) > > > > > may have a use, its 50/50 which would be used/wanted more. > > > > > > > > > > > > > > > > > > The next category is that of slightly longer combinations of A and C > > > > > > (the words coherent and consistent refer to qualities that let you > > > > > understand a concept/execution train instead of memorizing incoherent > > > > > and > > > > > inconsistent result tables. A highly valuable, if not priceless, > > > > > aspect of > > > > > a language.) > > > > > > > > > > > > AAC not defined. bad syntax error. (AA)C is fine interpretation and > > > > > already defined sanely. AA -> (AA) is everywhere else in J. > > > > > > ACA -> (u A) C (v A). Not useless, but not obviously more > > > > > > frequently > > > > > wanted than coherent ((u A) C v) A2 > > > > > > CAA -> coherent > > > > > > CAC -> doesn't exist. syntax error. Can be ((u C v) A) C2. An > > > > > > adverb > > > > > (or CA) result. > > > > > > ACC -> (u A) C1 (u C2 v) reuses u, making it useless. A perfectly > > > > > coherent result would be one equivalent to both (AC)C and A(CC). > > > > > Associativity is prizeable. > > > > > > CCA -> (u C1 v) C (u A). same uselessness. (CC)A or C(CA) > > > > > > preferably > > > > > identical interpretations is obviously better. > > > > > > CC not defined. Most important of all. -> ((u C1 v) C2) is an > > > > > > adverb. > > > > > The consistency with AC is that arguments are inserted with their > > > > > natural > > > > > parenthesized order, and then consistent with V0 V1 C2 -> (V1 C2 V0) > > > > > which > > > > > allows using conjunctions in strand/double adverb mode, which avoids > > > > > the > > > > > frequent error of wishing the v argument to a conjunction referred to > > > > > the > > > > > full verb phrase on the right. > > > > > > > > > > > > First, it is more useful that definitions exist than not. > > > > > > Two, definitions that reuse arguments for different modifiers have > > > > > > no > > > > > applicable use expectation. > > > > > > > > > > > > Its one thing to defend the interpretations that are not useless, > > > > > > over a > > > > > more consistent approach. I could listen to such a defense. It's an > > > > > other > > > > > to defend useless interpretations. > > > > > > > > > > > > The next/last category are the ones that result in trains. Rather > > > > > > than > > > > > itemize each train, let me just go over one cool example that I can > > > > > think > > > > > of. > > > > > > > > > > > > (] #~ ") > > > > > > 1 (= 2&|)(] #~ ")_1 i.5 > > > > > > > > > > > > 1 3 > > > > > > > > > > > > its cool, except that for the " conjunction, the correct right > > > > > > argument > > > > > is always _1 . But there is a cooler adverb form: > > > > > > > > > > > > (("_1) # ]) > > > > > > > > > > > > Noting that it's cool, might lose track that the purpose of the > > > > > > coolness > > > > > is that it can be assigned as an adverb. The power of J is in its > > > > > higher > > > > > order functions that can be assigned. The alternative definition is: > > > > > > > > > > > > select =: 1 : 'u"_1 # ]' > > > > > > > > > > > > it is already very easy to make train results from adverbs. And an > > > > > enhancement: > > > > > > > > > > > > ns =: 2 : 'u"_1 v ]' > > > > > > > > > > > > allows substitutes for # as v. Including i. or perhaps a compound > > > > > > verb > > > > > that dug through a boxed structure inside items. A super cool > > > > > conjunction > > > > > that was extremely easy to write (the important value provided), and > > > > > even > > > > > cooler than the train version. Cooler means harder to name. > > > > > > > > > > > > The problem with inconsistent "non binding" of some arguments in > > > > > > modifier > > > > > trains is that I can write the following > > > > > > > > > > > > (] #~ " _1) NB. parses just fine. > > > > > > > > > > > > The intent is that if the rule of leftmost 3 parameters in a > > > > > > modifier > > > > > train get grouped together, and intent suggested by _1 indent, then > > > > > perhaps > > > > > this means > > > > > > > > > > > > (] (#~) ")_1 NB. making an adverb out of original conjunction > > > > > > through > > > > > binding > > > > > > > > > > > > when it actually means: > > > > > > > > > > > > 1 (= 2&|)(] (#~ " _1)) i.5 > > > > > > > > > > > > 0 0 0 0 > > > > > > > > > > > > 1 0 0 0 > > > > > > > > > > > > 0 0 0 0 > > > > > > > > > > > > 1 1 1 0 > > > > > > > > > > > > 0 0 0 0 > > > > > > > > > > > > It is a minority of J users that understand trains. Adding > > > > > > conjunctions > > > > > and adverbs into permissible train formation items just adds an > > > > > exponential > > > > > rate of errors, and removes accessiblity even further for most J > > > > > users. > > > > > Sometimes the modifiers are binding, sometimes they generate a > > > > > modifier > > > > > that results in a train... increases reading taxation, that requires > > > > > good > > > > > memory of large inconsistent result tables, and whether a pattern > > > > > fits into > > > > > one of the entries, and loses the mental simplicity of following a > > > > > train's > > > > > dyadic/ambivalent terms to understand it. > > > > > > > > > > > > > > > > > > > If we change the old definitions that just means > > > > > > we have even more work to do. > > > > > > > > > > > > This can be done from the parsing table approach which may be > > > > > > manageable > > > > > > > > > > > > > SHORT examples > > > > > > > > > > > > +/ - @: -> +/ (-@:) -> -@:(+/) NB. gains strand notation for > > > > > conjunctions. Things consistently bind when you expect them to. > > > > > > > > > > > > + - * (@ @) -> + - (* @) @ -> + (*@-)@ -> *@-@+ NB. natural strand > > > > > binding order. Intuitively extendible to longer modifier train > > > > > "saved name" > > > > > > > > > > > > If the A V -> V A proposal is accepted then, > > > > > > > > > > > > @ (+/) - -> -@(+/) NB. double left arguments also parse. This adds > > > > > flexibility to C C train for binding order: > > > > > > > > > > > > * (@ @)- + -> * (@-)(@+) -> *@-@+ NB. same end result but with more > > > > > partial binding options. Can be good simplicity argument for + - left > > > > > binding order for same result. > > > > > > > > > > > > Consistency with AC and CA means that binding any argument within > > > > > > the > > > > > conjunction train is easy > > > > > > > > > > > > (@@+) -> (@(@+)), (@-@) -> ((@-)@), (*@@) -> (*@)@ are all partial > > > > > bindings that allow same end result with further conjunction or strand > > > > > parameters... when AC and CA are consistent. > > > > > > > > > > > > > > > > > > part of the consistency importance is what happens when modifiers > > > > > > return > > > > > modifiers. Keep consuming right arguments is the "correct" > > > > > behaviour. New > > > > > surprise incoherent trains are not welcome. > > > > > > > > > > > > > > > > > > > > > > > > On Monday, September 27, 2021, 01:15:18 p.m. EDT, Henry Rich < > > > > > [email protected]> wrote: > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > The primary goal of reintroducing the old trains was to make the old > > > > > > documents valid. Whether there is a better way to define the old > > > > > > trains > > > > > > is not to the point. If we change the old definitions that just > > > > > > means > > > > > > we have even more work to do. > > > > > > > > > > > > You are not improving your credibility by asserting that 'all of the > > > > > > train results... are at best marginally useful'. I used them quite > > > > > > a > > > > > > bit and was sad to see them go. Indeed, I never had a case where I > > > > > > wanted to write a modifier and found the trains wanting. I admit > > > > > > that I > > > > > > was content with the structure of J as it is, not trying to create a > > > > > > different approach to function definition. > > > > > > > > > > > > You would have to actually demonstrate examples where an alternative > > > > > > definition would enable some important new application. Then we > > > > > > could > > > > > > judge whether the change is worth the large effort required. I > > > > > > would > > > > > > add, we would need to do this before the beta period expires. > > > > > > > > > > > > I have just now gone through some of your list of proposed changes > > > > > > and I > > > > > > have yet to find one I agree with, but that's just my opinion. The > > > > > > burden is on you to demonstrate the superiority of your proposal. > > > > > > Just > > > > > > one SHORT example would be a good start, something important that > > > > > > the > > > > > > old trains are lacking. With luck we might find that you are > > > > > > redefining > > > > > > something so obscure that no one has ever used it, for which a > > > > > > change > > > > > > would be easier. > > > > > > > > > > > > In the meantime, adding parentheses to your bidents is harmless and > > > > > > solves your problem. > > > > > > > > > > > > It is gratifying to see the interest that this old code has ignited. > > > > > > > > > > > > Henry Rich > > > > > > > > > > > > On 9/27/2021 12:46 PM, 'Pascal Jasmin' via Programming wrote: > > > > > > >> Since you can > > > > > > > easily make your old code work by putting parentheses in +@/ to > > > > > > > make > > > > > > > (+@)/ and that preserves old documents, that would be the best > > > > > > > solution. > > > > > > > > > > > > > > That J sometimes "does what I mean" is a mixed blessing. Great > > > > > > > when it > > > > > works, but relying on it means syntax errors due to its > > > > > incompleteness in > > > > > applying the intuitive concepts that could make writing modifiers > > > > > easier. > > > > > > > > > > > > > > It all boils down to "could Ken have made a mistake" > > > > > > > > > > > > > > Modifier trains are an awesome idea, and it is great to have > > > > > > > enhanced > > > > > interpretations of code. > > > > > > > > > > > > > > Removing these interpretations for J6 were viewed as a better > > > > > > > idea than > > > > > these interpretations. > > > > > > > > > > > > > > The appeal of modifiers trains that return trains can seem less > > > > > > > scary > > > > > than modifiers that return modifiers. The latter though is part of > > > > > the > > > > > language since at least J6. Some of the "old trains" do the sane > > > > > modifier > > > > > autobinding, while others return trains. > > > > > > > > > > > > > > All of the train results, if not completely useless, are at best > > > > > marginally useful. A good test would be for someone to come up with a > > > > > single useful function in that form. Even if such a function exists, > > > > > it > > > > > can be easily/clearly written as a custom modifier in less time than > > > > > it > > > > > takes to research whether one of the train producing modifier trains > > > > > provides a useful equivalent shortcut. > > > > > > > > > > > > > > CC CA AC CnvC provide tremendous benefit in having valid > > > > > interpretations. Who wouldn't prefer more valid parsings and less > > > > > syntax > > > > > errors. But the benefit only exists when interpretations are > > > > > coherent, > > > > > useful, and consistent. That benefit only occurs if all of the > > > > > modifier > > > > > trains produce the natural modifier bindings that a fully bound in > > > > > place > > > > > expression would produce. > > > > > > > > > > > > > > > > > > > > > That it might be scary to consider CC an adverb that produces a > > > > > conjunction (u C1)C2 -> AC -> (uA)(Cv) or a conjunction that provides > > > > > an > > > > > adverb ((u C1 v)C2) doesn't force you to use the scariness. It is > > > > > consistent with the C C V train, and almost the V C C train. (the > > > > > execution of v1 C v2 C V is (v1 C v2) C V, while V C C produces V C > > > > > (v2 C > > > > > v3)). While V C C can have useful applications, the "special" > > > > > bracketing > > > > > can be accomplished if CA had a sane interpretation (u C v)A. Then V > > > > > C1 C2 > > > > > to have current interpretation can be written as C2 (V C1). > > > > > > > > > > > > > > To Ken's credit, the dumb C A train can be avoided with C A 1 : > > > > > > > 'u'. > > > > > ie C A A is sane. > > > > > > > > > > > > > > C V C (and all duplicate u/v modifier trains) however are just > > > > > > > mistakes > > > > > and useless. > > > > > > > > > > > > > > Reintroducing these trains has great potential. But we need to > > > > > > > fix the > > > > > bad ones before code gets written using them, and irreparably breaks > > > > > J's > > > > > potential. > > > > > > > > > > > > > > It can also break complex embedded existing code. Techniques for > > > > > strand/double adverb notation might rely on interpreter quirk, though > > > > > are > > > > > no longer needed with my proposal. > > > > > > > > > > > > ---------------------------------------------------------------------- > > > > > 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 > > > ---------------------------------------------------------------------- > > > 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 > ---------------------------------------------------------------------- > 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
