I tried to run your script but I was not able to go very far:
JVERSION
Engine: j805/j64/windows
Beta-12: commercial/2016-09-30T15:50:47
Library: 8.05.09
Qt IDE: 1.5.2/5.6.1
Platform: Win 64
Installer: J805 install
InstallPath: g:/program files/j
Contact: www.jsoftware.com
isNoun =: (0 = 4!:0 ::0:)@:<
isgerund =: 0:`(0 -. at 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 '/'
┌─┬─────┐
│+│┌─┬─┐│
│ ││0│/││
│ │└─┴─┘│
└─┴─────┘
+ tieA '/\'
┌─┬─────────┐
│+│┌─┬─────┐│
│ ││4│┌─┬─┐││
│ ││ ││/│\│││
│ ││ │└─┴─┘││
│ │└─┴─────┘│
└─┴─────────┘
lr_z_ =: 3 : '5!:5 < ''y'''daF =: 1 : 'a =. (''2 : '', (quote m) , ''
u'') label_. 1 : (''u 1 :'' , quote a)'
|value error
| a=.('2 : ',(quote m),' u')
Incidentally, the beta error report seems to be incomplete compare to
previous versions.
Anyway, what would be the product of (+:`-:AltM)("1) 3 3 3$1 2 3 4 ?
On Wed, Dec 14, 2016 at 3:03 PM, 'Pascal Jasmin' via Programming <
[email protected]> wrote:
> 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
