"... is there any way to have it [ $: ] apply to part of a verb phrase other than with a temporary name?"
Yes, the adverbs mRS and dRS [0] allow one to embed an anonymous tacit (fixed) recursive verb within a larger anonymous fixed verb. Moreover, if one does not mind using explicit verbs one can also explicitly wrap the anonymous tacit (fixed) recursive verb directly or via adverbs. 0. [Jprogramming] Adverbial Tacit Jym http://www.jsoftware.com/pipermail/programming/2016-May/045156.html On Thu, Dec 15, 2016 at 1:08 PM, 'Pascal Jasmin' via Programming < [email protected]> wrote: > follow up on "the parenthesising tree structure" > > > at =: 'u (v@:) 'daF > > cutP =: ({:@] ,~ ]) <;._2~ 1 ,~ (] ~: 0 , }:)@:(1 <. ])@:depth > cutAP=: '()'&$: : (4 : '] ]`$:@.(({.x) e. ;)@:cutP each tieD AltM cutP > y'):. uncutAP > > uncutAP =: '()'&$: : (4 : ';@:(< (<{.x)strinsert(<{:x)strinsert tieD/&.> > tieD@.(1 < L.)"0)^:_ ; at@:((<{.x)strinsert (<{:x)strinsert tieD/) y') :. > cutAP > > > > uncutAP cutAP 'qq((a(bd(c))g)gg( )(ffff))g' > qq((a(bd(c))g)gg( )(ffff))g > > an interesting thing about inverses, it works on bound dyads: > > > '[]'&cutAP b. _1 > '[]'&uncutAP > > A question about $: though, > > is there any way to have it apply to part of a verb phrase other than with > a temporary name? > > an alternate definition of cutAP (that loses parameterized bracket symbols) > > cutAPtemp =: ] ]`$:@.('(' e. ;)@:cutP each tieD AltM > cutAP=: cutAPtemp@:cutP :. uncutAP > > > ----- Original Message ----- > From: 'Pascal Jasmin' via Programming <[email protected]> > To: Programming Forum <[email protected]> > Sent: Wednesday, December 14, 2016 3:03 PM > Subject: [Jprogramming] strand notation tools > > I previously attempted to encode strand notation into a linear > representation (sometimes with bonus encoding info). I now present tools > to directly encode into ar form. > > > isNoun =: (0 = 4!:0 ::0:)@:< > isgerund =: 0:`(0 -.@e. 3 : ('y (5!:0)';'1')"0)@.(0 < L.) :: 0: > isgerundA =: 1 : ' if. isNoun ''u'' do. isgerund m else. 0 end.' > eval =: 1 : ' a: 1 : m' > ar =: 1 : '5!:1 <''u''' > aar =: 1 : 'if. isNoun ''u'' do. q =. m eval else. q =. u end. 5!:1 < > ''q'' ' > > tie =: 2 : 'if. u isgerundA do. if. v isgerundA do. m ar , v ar else. m , > v ar end. else. if. v isgerundA do. u ar , n else. u ar , v ar end. end. ' > tieA =: 2 : 'if. u isgerundA do. if. v isgerundA do. m ar , v ar else. m > , v aar end. else. if. v isgerundA do. u aar , n else. u aar , v aar end. > end. ' > > tie and tieA above differ in how they treat nouns. tieA will treat strings > as if they are modifiers or verb names in the resulting gerund. tie can > handle numbers, and the gerund form of strings is a noun. ` has the > deficiency of not producing gerunds with non-verb arguments. > > > + tie '/' > +-+-----+ > |+|+-+-+| > | ||0|/|| > | |+-+-+| > +-+-----+ > > > + tieA '/\' > +-+---------+ > |+|+-+-----+| > | ||4|+-+-+|| > | || ||/|\||| > | || |+-+-+|| > | |+-+-----+| > +-+---------+ > > strand notation is used in my multiadverb "framework". The advantage over > gerunds is that entire verb phrases can be parsed without parentheses. 2 > parsers are provided: > bG (buildGerund) is a conjunction where n indicates how many > strands/phrases are needed. > bG9 is an adverb that captures all phrases until the verb-token 9: is > reached. > > They both require the same number of total tokens, but bG9 is more > convenient if you wish to partially bind terms out of order and of course > if there are a variable number of arguments. bG is more convenient if > parameters are to be provided in fixed order, and to save a token for the > user of your adverb. > > > lr_z_ =: 3 : '5!:5 < ''y'''daF =: 1 : 'a =. (''2 : '', (quote m) , '' u'') > label_. 1 : (''u 1 :'' , quote a)' > daFx =: (0 : ) 1 : ('a =. (''2 : ('', (lr m) , '') u'') label_. 1 : (''u > 1 :'' , quote a)') NB. explicit. call with 0 left argbG =: 2 : 0 NB. > builds gerund. recurses until n = 0 > select. n case. 0 ;1;_1 do. u case. 2 do. tieA u case. _2 do. (u tieA) > case. (;/ _2 - i.20) do. (u tieA)(bG (n+1)) case. do. ( tieA u)(bG (n-1)) > end. > ) > bG9 =: 'if. ''9:'' -: u lrA do. n else. (u tieA v) bG9 end.' daF > > > 9: +: -@[ + bG9 > +--+---------+-+ > |+:|+-+-----+|+| > | ||@|+-+-+|| | > | || ||-|[||| | > | || |+-+-+|| | > | |+-+-----+| | > +--+---------+-+ > > 9: +: - ((+`) bG9) NB. "named adverb" (parens equivalent) with fixed 2nd > parameter. > +--+-+-+ > |+:|+|-| > +--+-+-+ > > +: - (+ bG 3) NB. fixed > +--+-+-+ > |+:|-|+| > +--+-+-+ > > +: - (+ bG 3)`:6 > +: - + > +: -`+ bG 2 `:6 NB. only 2 arguments, 1 a gerund. > +: - + > > +: - ((+`)(bG 2))`:6 NB. parend adverb. 2 strand arguments again, > because first will be "captured" by +` > +: + - > > +: - (bG 2)`+ `:6 NB. bG and bG9 make gerunds and so can be combined > with tie. > +: - + > > > another advantage of bG over bG9 and other multiadverbs is that a partial > binding is very readable (and editable) > > -@[ bG 9 > (tieA(-@[))(bG 8) > + -@[ bG9 > > 2 : 'if. ''9:'' -: u lrA do. n else. (u tieA v) bG9 > end.'((<,'+'),<(<,'@'),<;:'-[') > > > last batch of routines to make these tools usable in saved adverbs. > aatrain is most important for creating modifier trains. It works by > repeatedly executing its parts until it no longer evaluates to an adverb. > A limitation is that modifier arguments (as strings-linear representations) > to the "intended adverb" are not allowed. A feature is that the adverb > train can be extended with "linear adverbs". The workaround for functions > that take linear modifiers as parameters, is to encode them as strings > inside gerunds, and convert them in the function itself. So G and G9 are > included. > > > ncA =: 1 : 'if. 3 ~: 4!:0 < ''u'' do. if. m ismodstring do. m ; ncS m > else. 0 ;~ ''('', m lrA ,'')'' end. else. 3;~ ''('', u lrA ,'')'' end.' > > > aatrain =: 0 daFx NB. perfectly solves the composability of double > adverbs. But fails if modifier params included. > if. 0 -.@-: 1{:: a =. v ncA do. n =. ,: a end. > if. 1 = 1 {:: (;: inv {."1 a =.(u ncA , n)) ncA do. a aatrain else. > (;: inv {."1 a) eval end. > ) > > G =: 2 : 0 NB. builds gerund. recurses until n = 0 > select. n case. 0 ;1;_1 do. u case. 2 do. tie u case. _2 do. (u tie) > case. (;/ _2 - i.20) do. (u tie)(G (n+1)) case. do. ( tie u)(G (n-1)) end. > ) > G9 =: 'if. ''9:'' -: u lrA do. n else. (u tie v) G9 end.' daF > > toG =: 1 : ' if. 1 2 e.~ 1 {:: u ncA do. a =. (m) eval else. a=.u end. > 5!:1 < ''a''' NB.makes gerund from anything. string modifiers into gerund > versions. > > > tieD =: 'u tie v' daF > tieDs =: 'v tie u' daF > tieAD =: 'u tieA v' daF > tieADs =: 'v tieA u' daF > > > Fork as multiadverb > > +/ # % ('tieDs tieD (`:6)' aatrain) NB. Alternate def fhg (middle verb > can be prebound) > +/ % # > > F =: 'G 3 (`:6)'aatrain > +/%# F > +/ % # > +: + +/ % # F F > +: + +/ % # > > 2 + 3 F + ] F NB. extra capability > > 5 + ] > > +: +: 3 F NB. monad composition > 12 > > > Composition adverb where first bound parameter is verb or conjunction. to > work with aatrain, comp must take atomic noun(if conjunction), and then you > also have to tie the modifier. But if simple composition is needed, > manually inserting 2 adverbs is best. > > > strinsert =: 1 : ' [ , u , ]' > comp =: 1 : '((}:m)tieA (({:m) 5!:0))@.(_1 strinsert/ i.<:#m)' > > 9: - +/ +"2 '@' G9 comp > -@(+/)@(+"2) > - +/ +"2 '@' G 4 comp NB. manual composition helps reading. > -@(+/)@(+"2) > > 9: - +/ +"2 tie '@' ('G9 comp' aatrain) > -@(+/)@(+"2) > > 9: - +/ +"2 (+ +:) 'G9 comp' aatrain NB. tie not needed if verb > composer > - (+ +:) +/ (+ +:) +"2 > > > Overall it makes sense to have gerund functions that are independent of > how you build the gerund especially if there are modifier parameters. > Conjunctions that take gerunds on n are especially finicky. double adverb > form makes writting them easier. the assert verb: > > > c2da =: 1 : ( 'a =. (m ,'' u'') label_. 1 : (''u 1 :'' , quote a)') > pow =: '^:' c2da > > 0 0 $13!:8 (0 e. ]) 12"_ tieD pow > 0 0 $ 13!:8^:((0 e. ])`(12"_)) > > > "Gerund math" includes applying an adverb to multiple verbs, but more > generally stitching 2 gerund arguments together. Advsert is not setup for > trains as it uses direct gerunds of modifiers. > > > Cloak =: (aar(0:`))(,^:) > combG =: '(`:6)toG' Cloak > Advsert=: 'if. -. v isgerundA do. n =. v toG end. (combG"1 m ,.(#m) $ n)' > daF NB. 2 gerund arguments. n coerced to one if not. > > +`- '/' toG Advsert , tieD comp > +/ , -/ > +`- '/' tieA '/\' Advsert , tieD comp > +/ , -/\ > > To solve a recent problem I posted regarding "recursive descent of monadic > functions down a tree structure, first note the behaviour of $: in a gerund > does not treat "same verb phrase" as including the verb in Gerund&verb, and > so if you wish to recursively apply a gerund to a tree, you need the > applying function to be an adverb. > > AltM =: 1 : '}.@:(((#m) # ,: }.@] ,~ [ , G 4) m ''(@{.)(@])'' Advsert > Advsert/)@:({. , ])' > > +:`-: AltM NB. applies monad version of verb to head of y, appening x and > rest of results on each iteration. > }.@:((}.@] ,~ [ , +:@{.@])`(}.@] ,~ [ , -:@{.@])`:3)@:({. , ]) > > +:`-: AltM 1 2 3 4 > 2 1 6 2 > (+:`-:AltM)("1)3 3$1 2 3 4 > 2 1 6 > 8 0.5 4 > 6 2 2 > > NB. only works with lists, so > > > > (+: ` -: 'each' Advsert AltM) <("1) 3 3$1 2 3 42 4 6 > 2 0.5 1 > 6 8 2 > > > for recursive parenthesizing, > > > cutP =: ({:@] ,~ ]) <;._2~ 1 ,~ (] ~: 0 , }:)@:(1 <. ])@:(([: +/\ > =/\@(''''&~:) * 1 _1 0 {~ '()' i. ]) :([: +/\ =/\@(''''&~:)@] * 1 _1 0 {~ > i.)) > > ] ]`$:@.('(' e. ;)@:cutP each tieD AltM cutP'qq((a(bd(c))g)gg(ffff))g' > > +--+---------------------------+-+ > |qq|++-------------+--+------++|g| > | |||+-+-------+-+|gg|+----+||| | > | ||||a|+--+-++|g|| ||ffff|||| | > | |||| ||bd|c||| || |+----+||| | > | |||| |+--+-++| || | ||| | > | |||+-+-------+-+| | ||| | > | |++-------------+--+------++| | > +--+---------------------------+-+ > ---------------------------------------------------------------------- > 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
