> When you envision 'even longer modifier trains', you are implicitly requiring a stack of more than 4 words.
which can be avoided by (auto)parenthesizing outer modifier train, such that there's always at most 4 tokens. Do I understand the following expression to mean that modifier trains group left to right (somehow)? @ @ + - @ (@ @ +) - @ @ @ + - @ / ((@ @ +) - @)/ / @ @ + - @ |syntax error | /@@ +-@ / (@ @ + - @) /((@ @ +) - @) @ + @ - @ (@ + @) - @ shouldn't it group from the right? On Sunday, September 26, 2021, 10:46:13 p.m. EDT, Henry Rich <[email protected]> wrote: Since the goal was to make the old documents still usable, changes would require strong arguments demonstrating their superiority. You are pitting yourself against Ken Iverson: may the better man win. I can assure you that whatever is in your 'templating system' had zero influence on the design and implementation of {{ }} . When you envision 'even longer modifier trains', you are implicitly requiring a stack of more than 4 words. Henry Rich On 9/26/2021 10:34 PM, 'Pascal Jasmin' via Programming wrote: > I've been working on an autoparenthesizing of modifier trains, with > interpretations that would seem much more useful than the "old stuff". I > don't have a good interpretation for A V train, so I guess it could stay as > suggested. The following are what I'd prefer, added after -> ( = means > equivalent) > > > V0 V1 C2 conj V0 V1 (u C2 v) -> V0 (V1 C2) = V1 C2 V0 > A0 V1 V2 adv (u A0) V1 V2 > C0 V1 V2 conj (u C0 v) V1 V2 -> (C0 V1) V2 = A V2 > C0 V1 C2 conj (u C0 v) V1 (u C2 v) -> u (C0 V1) (C2 v) > A0 A1 V2 conj (u A0) (v A1) V2 -> (u A1 A2) V2 > N0 C1 A2 adv N0 C1 (u A2) -> u (N0 C1) A2 > N0 C1 C2 conj N0 C1 (u C2 v) -> u (N0 C1) (C2 v) = ((N0 C1 u) C2 v) = > (v (u (N0 C1)) C2) parentheses not needed. > V0 C1 A2 adv V0 C1 (u A2) -> u (V0 C1) A2 > V0 C1 C2 conj V0 C1 (u C2 v) -> same as N C C > A0 C1 N2 adv (u A0) C1 N2 > A0 C1 V2 adv (u A0) C1 V2 > A0 C1 A2 conj (u A0) C1 (v A2) -> u A0 (C1 v) A2 > A0 C1 C2 conj (u A0) C1 (u C2 v) -> ((u (A0) (C1 v)) C2) = adverb > C0 C1 N2 conj (u C0 v) C1 N2 -> v (u C0)(C1 N2) = (u C0 v)(C1 N2) > C0 C1 V2 conj (u C0 v) C1 V2 -> same as above > C0 C1 A2 conj (u C0 v) C1 (v A2) -> ((u C0 v) C1) A2 = adverb > C0 C1 C2 conj (u C0 v) C1 (u C2 v) -> ((u C0 v) C1) C2 = conjunction A C > A0 C1 adv (u A0) C1 u (adverbial hook) -> (u A0) C1 v > > The beauty of the suggested forms is that there is not much to remember, and > allows for parenthesless forms. > > V0 V1 C2 -> V0 (V1 C2) is just the only valid parenthesization of the left > expression. > > C0 vn C2... More modifiers -> (C0 vn) C2...M ie. when a nv term is between 2 > conjunctions it binds to the left one. > > Whenever C vn appears, (C vn) is bound is the only special rule. It binds > ahead of other modifiers to right. > > To permit even longer modifier trains, while keeping the 4 token stack: > > C0 C1 M2 M3 -> C0 C1 (M2 M3) > > Reusing parameters in multiple modifiers seems stranger than the still > strange inserting them seemingly arbitrarily within a modifier train. If > these are useful, they are best made into a purpose modifier rather than as > default parsing rules that will confuse. > > A cool enhancement would be multiple right bindings to modifier trains that > contain multiple conjunctions: > > (C0 C1 M) v -> (C0 v) C1 M ie. A conjunction modifier train binds v to the > leftmost (unbound) conjunction. > ((C0 v) C1 M) v2 -> (C0 v) (C1 v2) M = (C0 C1 M) v v2 > u ((C0 v) C1 M) -> ((u C0 v) C1) M ie binding from left or right provides > options similar to "old stuff" > > templating system that may have formed basis for {{ }}, and allows for rich > custome modifier trains: > http://www.jsoftware.com/pipermail/programming/2020-September/056558.html > > > On Sunday, September 26, 2021, 12:01:45 p.m. EDT, Henry Rich > <[email protected]> wrote: > > > > > > Nostalgic old-timers will be happy to see the return of Modifier Trains, > such as (@/), which were in early J but were deleted long ago. See > https://code.jsoftware.com/wiki/Vocabulary/fork#invisiblemodifiers . > > These trains were one of Ken Iverson's elegant brilliancies. Few used > them, and they are not needed, because anything they do can also be done > with explicit modifiers ({{ u @ v/ }} is equivalent to (@/)). No one > need rush out and look at them. > > We have brought them back because to do so was easier than updating all > the old J literature that refers to the forms. And because they're cool. > > Henry Rich > -- 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 ---------------------------------------------------------------------- For information about J forums see http://www.jsoftware.com/forums.htm
