You might use -.&a: to clean a result before `:6 hits it?
Thanks,
--
Raul
On Wed, Mar 5, 2014 at 9:24 PM, Pascal Jasmin <godspiral2...@yahoo.ca>wrote:
>
>
> Looks nice. Here is a continuation of my gerund manipulation approach:
>
> conjoin=: (,@:[ <@:; <@:])"1
>
> ('@' conjoin -.`*) `:6
> -.@*
>
> '@' conjoin (-.`'') ," 1 ,. *`-`+
> ┌──────────┬──────────┬──────────┐
> │┌─┬──────┐│┌─┬──────┐│┌─┬──────┐│
> ││@│┌──┬─┐│││@│┌──┬─┐│││@│┌──┬─┐││
> ││ ││-.│*││││ ││-.│-││││ ││-.│+│││
> ││ │└──┴─┘│││ │└──┴─┘│││ │└──┴─┘││
> │└─┴──────┘│└─┴──────┘│└─┴──────┘│
> └──────────┴──────────┴──────────┘
>
> stitchtrains =: ,.&(G2train@:(<"1))
>
> (-.`'') stitchtrains ,. *`-`+
> ┌──┬─┐
> │-.│*│
> ├──┼─┤
> │-.│-│
> ├──┼─┤
> │-.│+│
> └──┴─┘
>
> ('@' conjoin (-.`'') stitchtrains *`'') `:6
> -.@*
>
> G2train turns out to be a pretty good idea for working with informal lists
> of verbs and combining them into trains/tacit definitions. But working
> with tables of gerunds is a bad idea bc `:6 fails when a:/fills are present.
>
> To complete my last example:
>
> shortcircuits =: ((,'@:'); [<@:;])/ @:(_2&}. , (,'@:') <@:; _2&{ <@:, {:)
>
> (< shortcircuits '^:' conjoin (]`>vvtie"1 0]9 12 2) stitchtrains~
> ]`+vvtie"1 0]5+i.3) `:6
> (] + 5"_)^:(] > 9"_)@:((] + 6"_)^:(] > 12"_)@:((] + 7"_)^:(] > 2"_)))
>
>
> AndDoTrains =: ([: <@:shortcircuits '^:' conjoin [ stitchtrains ])
>
> ( (]`>vvtie"1 0]9 12 2) AndDoTrains~ ]`+vvtie"1 0]5+i.3)`:6
> (] + 5"_)^:(] > 9"_)@:((] + 6"_)^:(] > 12"_)@:((] + 7"_)^:(] > 2"_)))
>
> though it turns out this was the wrong spec, as it has the same result as
> the [: version (fails > 12, but still execs later >9)
>
> ( (]`>vvtie"1 0]9 12 2) AndDoTrains~ ]`+vvtie"1 0]5+i.3)`:6"0 ] 1 2 3
> 4 5 6
> 1 2 15 16 17 24
>
> So, I'm no longer sure there is a way to tacitly break execution on the
> first fail test. Or actually, I need to paren the whole left side of any
> ^: ... which was probably a needed manipulation function anyway.
>
>
>
>
>
>
>
> _____________________
> ( shortcircuit=.train o ((power&.:train ~)`(at&.:train ~)/) o |.)
> v0`t0`v1`t1`v2`t2
> v0^:t0@:v1^:t1@:v2^:t2
>
> ShortCircuit=. shortcircuit sv
>
> [: v0 t0 v1 t1 v2 t2 v3 t3 v4 t4 ShortCircuit
> v0^:t0@:v1^:t1@:v2^:t2@:v3^:t3@:v4^:t4
>
>
>
>
>
>
> ----- Original Message -----
>
> code at bottom of message,
>
> G2train is needed to make "formal trains" even though `:6 can sometimes
> evaluate a list of boxed verbs as a train, if we add conjunctions to the
> train, it needs to be formalized as a group of verbs.
>
> ( '^:'(4<]) addconj"1 0 G2train <"1 ]`+vvtie"1 0]2 4) train6"0 0] 5 4
> 7 4
> ( '^:'(4<]) addconj"1 0 G2train <"1 ]`+vvtie"1 0]2 4) train6"1 0] 5 4
> 11 4
>
> (+jointrains '^:'(4<]) addconj"1 0 G2train <"1 ]`+vvtie"1 0]2 4)
> train6"1 0] 5 4 2 1
> 16 8 4 2
>
>
> (+jointrains '^:'(4<]) addconj"1 0 G2train <"1 ]`+vvtie"1 0]2 4)`:6
> (] + 2"_)^:(4 < ]) + (] + 4"_)^:(4 < ])
>
>
>
> addconjar can add tests to each train.
> (+jointrains (4<])`(2<]) '^:' addconjar"0 G2train <"1 ]`+vvtie"1 0]2
> 4) train6"1 0] 5 4 3 1
> 16 12 10 2
>
> seems a useful way to build and chain a series of power conjunctions
>
> (composetrains (7<])`(2<]) '^:' addconjar"0 G2train <"1 ]`+vvtie"1 0]2
> 4) train6"1 0] 5 4 3 1
> 11 10 7 1
>
> but doesn't quite work the same as a real short circuit:
>
> (composetrains (9<])`(12<])`(2<]) '^:' addconjar"0 G2train <"1
> ]`+vvtie"1 0] 5+i.3) train6"1 0] 10 4 3 1
> 28 16 15 1
>
> here the 3 input fails the >12 test, but still evaluates and passes the
> (3+7)> 9 test.
>
> (composetrains (9<])`(12<])`(2<]) '^:' addconjar"0 G2train <"1
> ]`+vvtie"1 0] 5+i.3) `:6
> [: (] + 5"_)^:(9 < ]) [: (] + 6"_)^:(12 < ]) (] + 7"_)^:(2 < ])
>
> note that the tests can also be buit by parameters (and doesn't need the
> G2train processing to pass the `:6 parser.:
>
> (composetrains ( <"1 ]`> vvtie"1 0]9 12 2) '^:' addconjar"0 G2train <"1
> ]`+vvtie"1 0] 5+i.3) `:6
> [:^:((] + 5"_) (] > 9"_)) [:^:((] + 6"_) (] > 12"_))^:((] + 7"_) (] > 2"_))
>
> the above is not a useless pattern, but it would still be nice to have a
> real short circuit.
>
> the pattern: doN^:testN...@:do2^:test2@:do1^:test1
>
> might be implementable using clever `:3, and ^:`@: but its not
> straightforawd to tie two conjunctions (^:`@: is error). I'm not sure that
> would work, but there is a simpler approach anyway. Rewrite addconj as a
> verb where y is a pair of gerunds corresponding to left and right
> conjunction arguments, then join pairs of do, test with ^:, and resulting
> pairs with @:. maybe next post.
>
> the code:
>
> Cloak1=: (0:`)(,^:) NB. Conjunction to cloak adverbs and conjunctions as
> verbs
> Cloak=: (5!:1@<'Cloak1')Cloak1 NB. Cloaking Cloak
> vtie =: 2 : 'try. ((u"_)`(v"_)"_)^:(0=L.) (u`v) catch. try. u`(v"_) catch.
> (u"_)`(v"_) end. end.'
> vvtie =: Cloak <'vtie'
> train6 =: 4 : ' x `:6 y'
>
>
> jointrains=: 1 : '( [ , (u`'''') ,])/'
> composetrains =: [:`'' , {:,~[: jointrains@:}:
> ar =: 1 : '5!:1 <''u'''
> G2train =: 3 : '; y `:6(`'''')' each
> addconj =: 1 : (':';' <(,x);<y ; u ar')("1 0)
> addconj2 =: 1 : (':';' <(,u);<y ; x ar')
> addconjar =: 1 : (':';' <(,u);<y ; x')
>
>
> ----- Original Message -----
> From: Pascal Jasmin <godspiral2...@yahoo.ca>
> To: "programm...@jsoftware.com" <programm...@jsoftware.com>
> Cc:
> Sent: Monday, March 3, 2014 7:57:42 AM
> Subject: Re: [Jprogramming] Generating code from templates
>
> Here is a bit of a breakthrough on this type of code:
>
> (uses definitions quoted below including those from Jose)
> consider
>
> ]`+vvtie"1 0]2 3
>
> ]`+vvtie"1 0]2 3
> ┌─┬─┬─────────────────┐
> │]│+│┌─┬─────────────┐│
> │ │ ││"│┌─────┬─────┐││
> │ │ ││ ││┌─┬─┐│┌─┬─┐│││
> │ │ ││ │││0│2│││0│_││││
> │ │ ││ ││└─┴─┘│└─┴─┘│││
> │ │ ││ │└─────┴─────┘││
> │ │ │└─┴─────────────┘│
> ├─┼─┼─────────────────┤
> │]│+│┌─┬─────────────┐│
> │ │ ││"│┌─────┬─────┐││
> │ │ ││ ││┌─┬─┐│┌─┬─┐│││
> │ │ ││ │││0│3│││0│_││││
> │ │ ││ ││└─┴─┘│└─┴─┘│││
> │ │ ││ │└─────┴─────┘││
> │ │ │└─┴─────────────┘│
> └─┴─┴─────────────────┘
>
>
>
> or to avoid copying definitions:
>
> 2:`+`] ,: 3:`+`]
> ┌──┬─┬─┐
> │2:│+│]│
> ├──┼─┼─┤
> │3:│+│]│
> └──┴─┴─┘
>
>
> that created 2 gerund trains that are equivalent to functions storing 2
> functions f1 and f2.
>
> Although this is a good essay, it doesn't provide the same functionality
> described below
> http://www.jsoftware.com/pipermail/programming/2013-November/034177.html
>
> train6 =: 4 : ' x `:6 y'
> train0 =: 4 : ' x `:0 y'
>
> With these verbs we can apply lists of functions to lists of arguments.
> One of the more useful ones has mysterious magic behind it:
> ..f1 f2 y (acutally wrong... see below. It is (f1 f2) y. A hook.)
>
> (<"1 2:`+`] ,: 3:`+`]) train6 4 6
> 9 11
>
> ..each f1 and f2 to y
> (<"1 2:`+`] ,: 3:`+`]) train6"0 1] 4 6
> 6 8
> 7 9
> ..f1 y1 , f2 y2 NB. one of the most useful forms
> (<"1 2:`+`] ,: 3:`+`]) train6"0 ] 4 6
> 6 9
> or
> (<"1 2:`+`] ,: 3:`+`]) train6 &> 4 6
> 6 9
>
> combinable as:
> ....f1 each y , f2 each y
> (<"1 2:`+`] ,: 3:`+`]) train6 each"0 1 ] 1 4 6;2 3;1 1
> ┌─────┬───┬───┐
> │3 6 8│4 5│3 3│
> ├─────┼───┼───┤
> │4 7 9│5 6│4 4│
> └─────┴───┴───┘
>
> train0 is a bit less useful, but still
> (<"1 2:`+`] ,: 3:`+`]) train0 each"0 1 ] 1 2
> ┌─────┬─────┐
> │2 1 1│2 2 2│
> ├─────┼─────┤
> │3 1 1│3 2 2│
> └─────┴─────┘
> 2:`+`] `:0 ] 1
> 2 1 1
>
>
> can do train of trains:
>
> ( ( [ , +`'' ,])/ <"1 2:`+`] ,: 3:`+`]) train6 1 3 5
> 7 11 15
>
> where:
> ( ( [ , +`'' ,])/ <"1 2:`+`] ,: 3:`+`])
> ┌────────┬─┬────────┐
> │┌──┬─┬─┐│+│┌──┬─┬─┐│
> ││2:│+│]││ │ │3:│+│]││
> │└──┴─┴─┘│ │└──┴─┴─┘│
> └────────┴─┴────────┘
>
> ( [ , +`'' ,])/ <"1 ]`+vvtie"1 0]2 3 4
>
> not shown due to formatting prob on this comp, but joins 3 outer verb
> trains with + as pivot
>
> (( [ , +`'' ,])/ <"1 ]`+vvtie"1 0]2 3 4) train6 1 3 5
> 12 18 24
>
> notice that there is a generic function adverb there:
> jointrains=: 1 : '( [ , (u`'''') ,])/'
> +jointrains <"1 ]`+vvtie"1 0]2 3 4
>
> this still doesn't quite get to a compose trains function, but its close.
> one way to get compose is to use the [: form in trains:
>
> composetrains =: [:`'' , {:,~[: jointrains@:}:
>
> (composetrains <"1 ]`+vvtie"1 0]2 3) train6 1 2 4
> 6 7 9
> (composetrains <"1 ]`+vvtie"1 0]2 3 4) train6 1 2 4
> 10 11 13
>
> (both compose and join require 2+ verbs)
>
>
> From: Pascal Jasmin <godspiral2...@yahoo.ca>
> To: "programm...@jsoftware.com" <programm...@jsoftware.com>
> Cc:
> Sent: Friday, February 21, 2014 2:18:07 PM
> Subject: Re: [Jprogramming] Generating code from templates
>
> The usefulness of Cloak (and verbifying) is that you can then apply
> adverbs and conjunctions (" ~ ...)to what are essentially adverbs and
> conjunctions.
>
> Consider the now badly named conjunction vtie which is an enhancement to
> tie designed to always produce verbs (promoting nouns with "_), and so is
> useful for the most common gerund cases. see:
> http://www.jsoftware.com/pipermail/programming/2014-February/034913.html
>
> vtie =: 2 : 'try. ((u"_)`(v"_)"_)^:(0=L.) (u`v) catch. try. u`(v"_) catch.
> (u"_)`(v"_) end. end.'
> 'tie vvtie'=. (Cloak @: < each) @: ;: '` vtie'
>
>
> This produces the 2 hooks (+ 2:) and (+ 3:), and returns them as a single
> storable result (equivalent to +&3 and +&2
>
> (+`'' vvtie"1 0 ] 2 3)
> ┌─┬─────────────────┐
> │+│┌─┬─────────────┐│
> │ ││"│┌─────┬─────┐││
> │ ││ ││┌─┬─┐│┌─┬─┐│││
> │ ││ │││0│2│││0│_││││
> │ ││ ││└─┴─┘│└─┴─┘│││
> │ ││ │└─────┴─────┘││
> │ │└─┴─────────────┘│
> ├─┼─────────────────┤
> │+│┌─┬─────────────┐│
> │ ││"│┌─────┬─────┐││
> │ ││ ││┌─┬─┐│┌─┬─┐│││
> │ ││ │││0│3│││0│_││││
> │ ││ ││└─┴─┘│└─┴─┘│││
> │ ││ │└─────┴─────┘││
> │ │└─┴─────────────┘│
> └─┴─────────────────┘
>
> ((+`'' vvtie"1 0 ] 2 3){~0) `:6 ] 5 NB. selects the first function and
> applies it to 5
> 7
>
> (]`+ vvtie"1 0 ] 2) `:6 NB. another way of (]+2:) ie. +&2
> ] + 2"_
> (]`+ vvtie"1 0 ] 2) `:6 ] 3
> 5
>
> when searching for a way to apply rank to `:6 to get a list of results, I
> found this:
>
> (<"1 ]`+ vvtie"1 0 ] 2 3) `:6 &> 4
> 9
>
> That will apply f1 f2 4 , where f1 is (]+2), f2 is (]+3). I havent found
> how to get the list (append) of each function
>
> can parameterize both the start and end of an implicit definition this way.
> [`+ vvtie"1 0 ] #`]
> ┌─┬─┬─┐
> │[│+│#│
> ├─┼─┼─┤
> │[│+│]│
> └─┴─┴─┘
> [`+ vvtie~"1 0 ] #`]
> ┌─┬─┬─┐
> │#│[│+│
> ├─┼─┼─┤
> │]│[│+│
> └─┴─┴─┘
>
> %`# vvtie~"1 0 ] +/`(-/)
> ┌───────┬─┬─┐
> │┌─┬───┐│%│#│
> ││/│┌─┐││ │ │
> ││ ││+│││ │ │
> ││ │└─┘││ │ │
> │└─┴───┘│ │ │
> ├───────┼─┼─┤
> │┌─┬───┐│%│#│
> ││/│┌─┐││ │ │
> ││ ││-│││ │ │
> ││ │└─┘││ │ │
> │└─┴───┘│ │ │
> └───────┴─┴─┘
>
>
>
> ----- Original Message -----
> From: Pascal Jasmin <godspiral2...@yahoo.ca>
> To: "programm...@jsoftware.com" <programm...@jsoftware.com>
> Cc:
> Sent: Friday, February 21, 2014 1:11:32 PM
> Subject: Re: [Jprogramming] Generating code from templates
>
> neat.
>
> tie
> ,^:(0:``)
>
> tie&'' f.
> ,^:(0:``)&''
>
> which is using the gerund (v1`v2) version of ^: . This appears to be
> undocumented in that v2 here is a conjunction(`). I assume that using an
> adverb as v2 is impossible?
>
> The other peculiarity is that v1 is 0: which means that , never executes.
> Is that right?
>
>
>
> ----- Original Message -----
> From: Jose Mario Quintana <jose.mario.quint...@gmail.com>
> To: Programming forum <programm...@jsoftware.com>
> Cc:
> Sent: Friday, February 21, 2014 11:31:56 AM
> Subject: Re: [Jprogramming] Generating code from templates
>
> The verbalized conjunctions tie and rank can be produced as follows:
>
> 9!:14 ''
> j701/2011-01-10/11:25
>
> Cloak=. (0:`)(,^:) NB. Conjunction to cloak adverbs and conjunctions as
> verbs
> Cloak=. (5!:1@<'Cloak')Cloak NB. Cloaking Cloak
>
> 'tie rank'=. (Cloak @: < each) @: ;: '` "' NB. Cloaking tie (`) and rank
> (")
>
>
> cf=. {.@(tie&'')@(rank&_)"0 f.
> 100"_`(200"_)`(300"_) -: cf 100 200 300
> 1
>
>
> Cloak can also be produced without using ^: (although with a caveat).
> Members interested in following the beginnings of the story can look at
> http://www.jsoftware.com/pipermail/programming/2013-March/031883.html .
>
>
> On Thu, Feb 20, 2014 at 8:52 PM, Raul Miller <rauldmil...@gmail.com>
> wrote:
>
> > This would be more fun if you provided definitions for tie and rank (and
> > others you use) in an addon.
> >
> > Without that, it feels like deus ex machina (and does not execute for me
> > like it does for you).
> >
> > Thanks,
> >
> > --
> > Raul
> >
> >
> > On Thu, Feb 20, 2014 at 6:06 PM, Jose Mario Quintana <
> > jose.mario.quint...@gmail.com> wrote:
> >
> > > "
> > > Anyway, thought I'd share, and see if anyone else has useful tools for
> > > manipulating J code (metaprogramming).
> > > "
> > >
> > > Dan, I will try to show some meta-programming exercises soon. I am
> > jumping
> > > into the darkness hoping that I will land well; so far, so good. In
> the
> > > meantime, the following is a F^4 underground verb corresponding to
> Raul's
> > > explicit verb (using verbalized primitive conjunctions):
> > >
> > > cf=. {.@(tie&'')@(rank&_)"0 f.
> > >
> > > 100"_`(200"_)`(300"_) -: cf 100 200 300
> > > 1
> > >
> > >
> > >
> > > On Thu, Feb 20, 2014 at 2:39 PM, Dan Bron <j...@bron.us> wrote:
> > >
> > > > There was a question on StackOverflow today on generating constant
> > > > functions from the items of an array. As in, 100 200 300 <==>
> > > > 100"_`(200"_)`(300"_) .
> > > >
> > > > As a more general question, how can we specify code templates and
> then
> > > use
> > > > them to dynamically produce gerunds for later execution? *
> > > >
> > > > Here's one idiom I've found useful in such situations:
> > > >
> > > > substit =: [^:(__-:])L:_ 0
> > > >
> > > > template =: __"_ NB. The template; note the __
> > > > TEMPLATE =: {. template f.`'' NB. Atomic rep of template
> > > >
> > > > GERUND =: TEMPLATE substit"_1 _~ 100 * 1 + i.3
> > > >
> > > > GERUND`:6
> > > > (100"_) (200"_) 300"_
> > > >
> > > > GERUND@.0
> > > > 100"_
> > > >
> > > > GERUND@.2 'hello'
> > > > 300
> > > >
> > > > The basic idea is to "fill in the blanks" in the template with the
> > > inputs.
> > > > Here, the blank is __ (negative infinity), so we look for that in the
> > > > gerund template, and when we find it, we replace it with the input. I
> > > kind
> > > > of like how the verb does this: first, we only bother looking at
> level
> > 0
> > > > (because __ is unboxed, so it will never appear above level 0), and
> > > > second, the verb is passive until __ is detected (because ^:(]-:__)
> is
> > > > ^:0, i.e. "do nothing and just return the RHA" until then).
> > > >
> > > > One possible issue is what we use to denote "blank". If we're going
> to
> > > > allow users to pass in any gerund, then he could potentially want to
> > > > include __ as part of the code to be produced, rather than replaced.
> > > There
> > > > are a couple possible ways to address that limitation. First, we
> could
> > > use
> > > > a value which a user is very unlikely to want to produce (as opposed
> to
> > > > replace), i.e. _. :
> > > >
> > > > substit =: [^:(1-:128!:5@])L:_ 0
> > > > SPARTA =: ({. _."_ `'') substit"_1 _~ 300
> > > > SPARTA`:6
> > > > 300"_
> > > >
> > > > Or, we could define substit as an adverb (adjective), which takes the
> > > > "blank" as an argument:
> > > >
> > > > Substit =: (-:&) (@]) ([^:) (L:_ 0)
> > > >
> > > > substit =: 'blank' Substit
> > > > substit
> > > > [^:(-:&'blank'@])L:_ 0
> > > >
> > > > ; , ((< {. 'blank'&;`'') substit~&.> ;:'fill in the blanks' )`:0
> '!'
> > > > fill!in!the!blanks!
> > > >
> > > > But if we do that, we have to start wondering about the 0 in L:_ 0 ,
> > > > because the user's "blank" might be boxed, and therefore have L.>0 .
> Of
> > > > course, we could fix this up by making the L: dynamic:
> > > >
> > > > Substit =: adverb : '[^:(m-:])L:(_,L.m)'
> > > >
> > > > NOTNULL =: ({. ~:&a:` '') a: Substit~ <'#N/A#'
> > > > NOTNULL`:6
> > > > ~:&(<'#N/A#')
> > > >
> > > > But it might be more fun to go meta-meta:
> > > >
> > > > (({. substit f.`'') substit~ _999)`:6
> > > > [^:(_999 -: ])L:_ 0
> > > >
> > > > Here, define the "standard" blank to be __, and then let the user
> > change
> > > it
> > > > by using substit :)
> > > >
> > > > Anyway, thought I'd share, and see if anyone else has useful tools
> for
> > > > manipulating J code (metaprogramming).
> > > >
> > > > -Dan
> > > >
> > > > * For a recent example of where such metaprogramming might be
> useful,
> > or
> > > > convenient, see the postscript of:
> > > >
> > > >
> > > >
> > http://www.jsoftware.com/pipermail/programming/2013-December/034373.html
> > > >
> > > > Other examples can be found with a forum archive search for the
> string
> > > L:0
> > > > _
> > > >
> ----------------------------------------------------------------------
> > > > 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
