from your definition, -&% b. _1 NB. inverse exists
%@- then -&% (+: &.) 2 3 NB. seems to be what you want? 1 1.5 -&% (+: &) 2 3 _1 _0.666667 but (- %) b. _1 NB. dyadic verbs don't have inverses |domain error you can assign an inverse to a dyadic verb and then dinv =: 2 : '[ (v inv) [: u v' 1 +: dinv ((- %) :.(%@-)) 4 2 3 1r2 _2 _ _3 1r3 On Friday, December 17, 2021, 10:17:07 p.m. EST, Hauke Rehr <[email protected]> wrote: I’ll have to take some time digesting Pascal’s recent treatments of the modifier trains topic. Maybe I’ll get stuck and maybe I won’t dare tell you about my point of view for I used them too little. But there is one thing related to two very useful conjunctions: Under and Assign Obverse in combination with hooks. For a long time, I wanted J to be able to do some more magic when using the obverse of a hook. Say I want to (- %) then apply some inner function and then undo that operation. There are completely sane and deterministic semantics for this, as long as the left tine has an obverse. I would want u&.(w v) y to behave like u&.(w&(v y)) y NB. (v y) evaluated to a constant and bound by & so in my stupid example with inner function, say, +:, we’d get +:&.(-&(% y)) y example y=:1r2 +:&.(-&2) 1r2 _1 which I would want to be able to write like +:&.(- %) 1r2 Applications of this came up time and again, and it fits well the way &. (and &.: ) work already. Any chance this may become part of J’s semantics? Am 18.12.21 um 03:45 schrieb 'Pascal Jasmin' via Programming: > J has gotten some powerful tools in 903 for making compound modifiers > (modifiers that return other modifiers) and some interesting parentheses > eliminations > > The following 6 modifiers create forks. The 3 Fm ones are adverbs that > return conjunction when n indicates the fork tine that is fixed by the > adverb. The Fmn ones are conjunctions that fix positions m and n to return > an adverb that will fill the remaining position. > > cocurrent 'z' > > F0 =: 1 : 'u ` ` `: 6' > F1 =: 1 : '[. u ].' > F2 =: 1 : '` ` u `: 6' > > > F01 =: ((` (2 : '`')))(`:6) > F02 =: 2 : '(u`)(`v)(`:6)' > F02 =: ( ([.(2 : '`')) (2 : '`' ].) ) (`:6) > F12 =: (2 : '`' `) `: 6 > > > The conjunction forms can all be made tacit other than the (2 :'`') bits that > are used to "fool" CC trains into forming adverbs. I withdraw my criticism > of CC, because the trick of 2 :'C' in place of a conjunction is a very > flexible short and readable way of making CC (and other modifier trains) > return compound modifiers. > > The facit version of F02 is ((CC)(CC))A -> CA -> (AA)A > > F1 and F12, and F0 and F02 have same binding order with 3 parameters. (and F2 > would match a swapped F12, named F21 but not provided above) > > These compound modifiers reduce parentheses use, while permitting more > flexible composition. > > > In terms of choosing an F shadow name, F1 or F12 seem like the best choices, > because they both keep the same fork order. > > +/ %F1 # > > +/ % # > > F1 has the advantage of binding any single adjacent parameter while keeping > order of remaining parameters, and can also do this: > > #(+/ %F1) > > +/ % # > > +/ % (F1 #) NB. A V form > > F12 has less binding flexibility, but because it is an "original" > conjunction, it binds its right parameter, and so the whole fork becomes a > parameter to any other modifiers > > > +/ % F12 # "1 > > (+/ % #)"1 > > +/ % F1 # "1 > > +/ % #"1 NB. since F1 is adverb, w u F1 v (AA)CvAAAA -> w (u F1) ((((v > (AA)Cv)A)A)A)A). ie. v will bind with expression to its right "normally" as > if it were a u parameter. > > > F =: F12 NB. instead of F =: F1 is chosen for composability, saving 2 chars > instead of 1. F1 still very useful. > > compositions with F1 can choose which adverbs/modifiers operate on the v > parameter and which operate on full fork > > +/ % (F1 (<.@:)) #"1 > > <.@:(+/ % #"1) > > #"1(+/ % F1) (<.@:) > > <.@:(+/ % #"1) > > #(+/ % F1) (<.@:)"1 > > <.@:(+/ % #)"1 > > > +/ % F # (<.@) = F] # F] (#@) NB. count of items that are equal to floor of > average > > #@((<.@(+/ % #) = ]) # ]) NB. much easier to type out/read. Parenthesized > expressions are short > > ] +/ %(<.@) F # = F] (F2 (#@)) #~ NB. same expression but swapped term > positions, and adverb move > > #@(] #~ (+/ <.@% #) = ])#@(] #~ <.@(+/ % #) = ]) NB. minimal edit effort. > > A guideline for which of the 6 fork generators to use is to leave the most > complicated term of the fork as the leftmost parameter. Though there is much > more flexibility than in previous J versions > > ] = F1 +/ % F # NB. using F1 allows for "complicated" right part > > ] +/ % F # (F2"1) = NB. complex part in u (of F2) > > (] = +/ % #)"1 > > ] +/ % F # F01 = "1 NB. similar but may have reading preference. (F01"1) > also legal > > ((+/ % #) = ])"1 > > > > On Tuesday, December 14, 2021, 12:53:38 p.m. EST, 'Pascal Jasmin' via > Programming <[email protected]> wrote: > > > > > > > Making an ammend conjunction patterned around the u`v`]} form but where u is > a function of the selected (v) items of y > > version 1 > > 13 - ((2 : '[ u v { ]' ` ].) (`])}) 1: i.5 > > 0 12 2 3 4 > > There appears to be a rule that modifier trains that are longer than 3 > "tines" will be grouped from left to right in 3s > > above is (C C C) A A . This allows fewer parentheses since they will be auto > added > > 2 : '[ u v { ]' ` ]. (`])} > > (2 : '[ u v { ]' ` ].) (`]) (} ) > > and even > > 2 : '[ u v { ]' ` ]. `]} NB. C C C C V A -> ((C C C) C V) A -> CA = >rational pre-903 modifier trains. > > ((2 : '[ u v { ]' ` ].) ` ])(} ) > > version 2: enhance the ammend conjunction to work monadically. u dyadic > function called monadically has access to both selected items and whole list > as right arg. > > extending to right end without parens works (adding ~ reflect, and switching > some internal [ ]) > > 2 : '] u v { [' ` ]. `] }~ NB. CAA > > ((2 : '] u v { [' ` ].) ` ]) (} ) ~ > > but this lack of parentheses elegance is only due to CCV -> CA > > if instead, this is written as CAAA, it becomes (CAA)A, and still works > > 2 : '] u v { [' ` ]. (`[) }~ > > ((2 : '] u v { [' ` ].) (`[) (} ))~ > > 13 -(2 : '] u v { [' ` ]. (`[) }~) 1: i.5 > > 0 12 2 3 4 > > ABER = Always be extending right. You can parentheslessly extend a modifier > to the right with A or C (u = v or n) > > version 3: allow v (selection verb) to be a noun by adding "_ modifier to > "selection tine" of } > > our versions so far are in C C C C V A A format, and we need to modify the > 3rd C from left. This won't work > > 2 : '] u v { [' ` ]. "_ > > > because that is (C C C) C N which applies "_ to whole expression instead of > just middle tine of } gerund. so C C (C "_) is what we are looking for > > 2 : '] u v { [' ` (]."_) (`[) }~ > > ((2 : '] u v { [' ` (]. " _)) (`[) (} ))~ > > 13 -(2 : '] u v { [' ` (]."_) (`[) }~) 1 i.5 > > 0 12 2 3 4 > > version 4: replace the explicit conjunction left part with a tacit one > > sketching it out before worrying about "AC problems" or parenthesing, > > [` ` `{`[ > > (([ ` `) ` ({ )) ` [ > > appears correct because UCC does what AC "should" do. There is a bug with > our version 3 enhancement. A noun argument will blow up the "` trains" > > -(]` ` `{`[ `: 6) 1: > > ] - 1: { [ > > ar =: 1 : '5!:1 <''u''' > > > and CCA can replace our dangling ` (C) > > > -(]` ([. ` ar) `{`[ `: 6) 1 > > ] - 1 { [ > > amend =: ]` ([. ` ar) `{`[ `: 6 ` (]."_) `[ }~ > > 13 - amend 1 i.5 > > 0 12 2 3 4 > > This seems very clean only because uCC behaves as the rational AC. If you > make the mistake of parenthesing the initial (]`) then transforming to ACA > format is only manageably dirtier because the starting state is clean > > - ((]`) ([. ` ar) ]. `{`[ `: 6 ` (]."_) `[ }~) 1 > > (] - 1 { [)`(1"_)`[} ~ > > > > > > > On Sunday, December 12, 2021, 02:15:03 p.m. EST, 'Pascal Jasmin' via > Programming <[email protected]> wrote: > > > > > > I'd like the following changes to new modifier trains in priority order: > AC -> uACv > CC -> (uC1v)C2 > u`n and m`v producing gerunds instead of errors when n or m is unboxed and > not '' > > J is a powerful language in large part due to its existing modifier support. > It allows easy composition of functions and modifiers. The new trains, > especially ACA and CA are a significant enhancement of that composition > power. These new/old trains also make writting compound modifiers much > easier. > > Thank you to J team for reviving the old trains. > > With J's strong capabilities for composition, the primary purpose of writing > a modifier is an expectation for general (re)use. And the value of the whole > system is in the ease of composition and editability. > > If you want to create the (current) behaviour of AC, you can easily write 1 : > 'uACu' or tacitly, ((A C [.)a:) . And this, likely very rare use case, is > then available for full composability by you and users. > > Composability means 2 things. Easy function composition, but also, an easily > editable writing process. > > +(``:6)# > > + # > > The current way to extend this CA (CCV -: CA) with adding say a / modifier to > u is to shoehorn the expression into ACC format: (AC].) > > + (/(``:6)].)# > > +/ # > > > That extra ]. all the way at the "other end (right)" of the C part in AC is a > needless "nightmare"/composability obstrction in comparison to "forcing extra > steps" for the less useful current AC definition. > > One improvement would be to define AAC (currently undefined) as u(AA)(Cv) and > AAAC as (AA)AC because then composing an adverb to left of modifier train > would only require an extra annotation (A ]: C) that does not require > cursoring over and may also not require an abundance of parens. There is a > readability problem as well when the }bookkeeping annotation" ]: or ]. is not > next to the leftmost modifier > > Reading a modifier must be done left to right. The right parts compose on > the results of the left parts. Calculating the order (number of parameters) > of a modifier both mentally and mechanically is easier when most, and the > simplest (AC CC ACA and CA) are all conjunctions until observed verb/nouns > bind them. When encountering left to right AC, having to mentally or > mechanically compute/find whether there is a ]. in appropriately > parenthesized location is taxing and distracting. > > CC as a hook generator is marginally useful. (``:6) would do the same, and > if ` produced gerunds with m`v and u`n for unboxed and non empty m and n, > then producing (u n) from CC "replacement" is also easy. A user defined > conjunction ti can replace `, but it requires explicit code that pollutes > display on partial bindings. > > +`(1 ar)`] creates a display ugliness that +`1`] would not. > > it might also be worth enhancing } such that > > +`(1 ar)`]} > > |domain error > > didn't happen, and +`1`]} would be legal and would display as written. > }(amend) is a critical language function that could be easier to use. > v0`v1`v2 could also be a monadic version of amend. > > The proposal for CC -> ((u C1 v)C2) supports the need for a modifier/modifier > train to have more than 2 parameters. Proposed CC would have order of 3. > > A current workaround for achieving the desirable behaviour is to create a CA > train with the compound modifier > > CasA =: 1 : ' 1 : ('' u '' , m ) ' > > > # +/( ` ('`'CasA)) % > > ┌───────┬─┬─┐ > > │┌─┬───┐│%│#│ > > ││/│┌─┐││ │ │ > > ││ ││+│││ │ │ > > ││ │└─┘││ │ │ > > │└─┴───┘│ │ │ > > └───────┴─┴─┘ > > to make a train out of the gerund (`:6) the "easiest" solution is to modify > the CA train to CAA, but the "most appropriate"/extensible solution is to > treat (`:6) as an "optional"/end transformation function to be tacked on or > removed for debugging or inserting further modifiers in between > > # +/( ` ('`'CasA(`:6))) % NB. easy less extendible way > > +/ % # > > # +/(( ` ('`'CasA))(`:6)) % NB. extensible but requires extra parentheses > with cursoring around to envelop previous expression > > +/ % # > > extending the function using current AC workaround to put the / adverb inside > the modifier instead of the caller's responsibility: > > # +(( (/ ` ]:) ('`'CasA))(`:6)) % > > +/ % # > > as proposed for CC this core would become (` `) and the alternative for train > formation ((` `)`:6) is much neater starting point from which to insert > additional expansions/modifiers. The enhanced modifier above becomes > (((/`)`)`:6) > > Making general modifier composability "the bias" is a worthwhile focus of > the language. Shortening the space between parentheses and reducing the > total number means improvements in writability and readability, and extending > the expression complexity that is mentally manageable. > > > On Tuesday, October 5, 2021, 12:24:44 p.m. EDT, Pascal Jasmin > <[email protected]> wrote: > > > > > > HR: I found the production (A C)->((x A) C x) useful enough in my work > that I gave it a name, the adverbial hook. > > > One way to keep this production, which I still fail to see as "useful > enough", while enhancing composability of modifier trains is defining > > AAC -> u AA(Cv) > > implying that > > AAAC -> (AA)AC and A(AAC) -> (AA)AC > > Parenthesized (AC) can retain your quirky production. > > if you have an A and a C that you wish to "compose intuitively", ]:AC has > better future composability than the ACA transformation of AC]: due to > parentheses explosion described below. > > > A yet to mention advantage of composability is the ability to test individual > modifier trains before combining them simply. The AAC and ]:AC proposals > would do this, in a way that shoehorning a modifier into ACA form does not. > ie. composing a modifier train to the left of ACA requires a new shoehorning > into a new ACA structure. > > Assuming the above is sensible, and in the spirit that more trains are good, > there are a couple of other "smelly" current train defintions. Smelly for > reusing arguments: > > ACC -> uA C (u C v) > CCA -> (u C v) C (vA) > > it is worth noting that current AC could also be written as ((AC[.)a:) > > but some productions that are missing that would include a CC component in a > train are > > (uC)(vC) > (Cu)(Cv) > (uC)(Cv) > (Cu)(vC) > > ACC and CCA could cover 2 of them. CAC could cover a 3rd. > > > On Monday, October 4, 2021, 08:44:11 p.m. EDT, 'Pascal Jasmin' via > Programming <[email protected]> wrote: > > > > > > I have to be repetitive in first part of response because it seems to have > been missed in later discussion > > ``:6 is all that is needed to produce a hook. > > a replacement to ` that forms gerunds out of m`n or m`v or u`n is needed. I > call that replacement "ti". > > That is needed for the u n execution example of your CC. The only reason you > would ever need a modifier to execute u n (or y) is if u returns a string > that needs to be processed by another modifier (such as 1 : or 3 : ) in > order to produce a function. > > Therefore all uses of implemented CC are served by ti(`:6)(optional extra > Adverb to process a noun result) > > > USE CASE (as requested) > > All 902 modifier trains are composable by simple juxtaposition. AAA and A > compose with whichever is positioned on the left will send its result to the > one on the right. Composability is high value awesomeness! > > My CC proposal keeps that composability for the new enhanced modifier trains > that include CA and ACA (both conjunctions) > > forcing (AC[:) as a replacement for what should just be AC harms > composability as well: > > A (AC[:) has to be written as A (AC[:) [: . Adding a further A to left means > (A (A (AC[:) [:) [:) if as an example all of the As and ACAs were named, and > you couldn't just go inside the ACA to do ((AAA)C[:) > > I don't believe conjunction reflexitivity is worth the composability > nightmares. > >> Reducing parentheses is not a laudable goal; in fact, I see it as the > opposite. The train A A C should, if possible, mean something different > from (A A) C because Why have two ways to say the same thing? > > > AAC is not defined, btw, but if it were I would strongly hope that it were > (AA)C]: ie what (AA)C and AC should be. > > It is a respectable philosophy to have unique trains that force explicit > parentheses. I would prefer fewer parsing rules with auto pairing of > parameters for the pure blissful cleanliness of it all (but not insisting on > the full purity extreme). Your view forces a lot of memorization that might > have been an important factor in the original decommissioning. > > > > On Monday, October 4, 2021, 06:05:47 p.m. EDT, Henry Rich > <[email protected]> wrote: > > > > > > The discussion is moving toward the polemic and unhelpful. I write to > try to suppress suggestions that have no hope of being implemented soon. > > 1. Reducing parentheses is not a laudable goal; in fact, I see it as the > opposite. The train A A C should, if possible, mean something different > from (A A) C because Why have two ways to say the same thing? We are > trying to define a grammar with NO reserved words except parentheses; > perhaps only Ken could have attempted it; there are just a handful of > productions to define; they should be as powerful as possible, with as > little duplication as possible. > > 2. I found the production (A C)->((x A) C x) useful enough in my work > that I gave it a name, the adverbial hook. > > 3. (C C) -> ((u C v) C) is a drastic change to the language. It consumes > two words and creates something that consumes one or two more words. Is > it brilliant? Is it the camel's nose in the tent? I personally think > it raises a stench to the nostrils of the Almighty. I could be wrong. > But anyone suggesting such a fundamental change must arrive first with > SHORT EXAMPLES showing why the language should consider such forms, > which will be so unfamiliar to the J programmer. If the knowledgeable J > community is convinced, we can consider whether the forms should be > implemented. > > A couple of users (including me) suggested (C0 C1)->((u C0 v) (u C1 > v)). Why? Because it allows > * easy production of hooks, with V ([. ].) V > * execution of verbs, with V ([. ].) N-phrase > > That's a pretty good argument, SUPPORTED BY EXAMPLE. Hooks are important. > > I am very reluctant to make changes that don't have demonstrated > benefits, being a disciple of Omar: > > O take the cash in hand and waive the rest; > Ah, the brave music of a /distant/ drum! > > Henry Rich > > > On 10/4/2021 4:33 PM, 'Pascal Jasmin' via Programming 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, >> > > -- ---------------------- mail written using NEO neo-layout.org ---------------------------------------------------------------------- For information about J forums see http://www.jsoftware.com/forums.htm ---------------------------------------------------------------------- For information about J forums see http://www.jsoftware.com/forums.htm
