" I doubt non like-for-like substitutions (in terms of word class) will ever
work; at least not in general."
I understand that the source template still has to parse before and after
substitutions. Candidates for the placeholders would be:
_: for verbs
The difficulty for adverbs and conjunctions is that they don't necessarily
parse to any verb and noun. Its also a stretch to need to parameterize them,
and so I think can be ignored. There is also the straightforward explicit
parameterization with sprintf, and :
n : (textvariable sprintf p1;p2;p3)
" unless we insist on a distinct "blank token" for each substitution"
One approach if it is simpler, is to just use unusual numbers for the
parameters. Say:
_999010999
_999020999
_999030999
the natural choice for verb parameters would be _1: , _2: ...
----- Original Message -----
From: Dan Bron <j...@bron.us>
To: "programm...@jsoftware.com" <programm...@jsoftware.com>
Cc:
Sent: Thursday, February 20, 2014 8:20:55 PM
Subject: Re: [Jprogramming] Generating code from templates
Adverb and conjunction templates are straightforward. Multiple substitutions
won't be difficult, but will inflate our codebase a bit (the L: approach is
well suited to single substitutions, but unless we insist on a distinct "blank
token" for each substitution [like named parameters], we'll have to make it
vector or higher rank, which will entail an entirely different approach).
Verb/adverb/conjunction substitutions will take more thought, as we'll need to
understand the structure of (the atomic representations of) both the template
and the substitution in order to marry them seamlessly. I doubt non
like-for-like substitutions (in terms of word class) will ever work; at least
not in general.
I'll try to take a whack at these extensions, and your timer code, tomorrow.
-Dan
> On Feb 20, 2014, at 5:37 PM, Pascal Jasmin <godspiral2...@yahoo.ca> wrote:
>
> very cool. To help people understand it, the requirements for the template
> are that it is an implicit definition, and that it parses ok, and also that
> it is a verb (modifiers don't play well as gerunds).
>
> with that in mind, here are some verbs to make things a bit easier:
>
> substit =: [^:(__-:])L:_ 0
> substit2 =: substit"_1 _~
> mktemplate =: 1 : '{. u f. `'''''
>
> One useful "verb" that requires 3 arguments, and has special code as an
> adverb is power residue &|@^
>
> (3&|@^) will raise x to the y power and then take the residue to 3.
> Basically Dan's code allows to fix these verbs. Once you have created your
> template implicit verb
>
> powmod3 =: __&|@^ mktemplate substit2 3
>
> powmod3`:6
> 3&|@^
>
> Dan, is there a way to make multiple substitutions, ie. for this template:
>
> (__ + __&|@^) mktemplate NB. could it substitute 2 seperate nouns from y?
>
>
>
> Also are verbs (modifiers?) substitutable?
>
> In terms of other examples,
>
> Here is a class that wraps around Jqt 's new timer functionality. There is
> only one global timer callback available, and so assuming the possibility
> that more than one routine would like to be run, without knowing that any
> other routine has been set, this could work: (not tested extensively)
>
> Its not gerunds, but it was was pretty straight forward to write. The class
> accumulates the sequence of callbacks into the callback variable (in add
> variation), and tells the timer to run them all.
>
>
> cocurrent 'timer'
> callback =: ]
>
> set=: 4 : 0 NB. x is explicit code to run/string. y is miliseconds interval
> if. y do.
> callback =: (3 : x)
> sys_timer_z_=: callback f. "_
> wd 'timer ',":y
> else.
> wd 'timer 0'
> sys_timer_z_=: ]
> end.
> EMPTY
> )
> add =: 4 : 0
> if. y do.
> callback =: (callback f.)`(3 : x)
> sys_timer_z_=: callback"_ `:0
> wd 'timer ',":y
> else.
> wd 'timer 0'
> sys_timer_z_=: ]
> end.
> EMPTY
> )
>
> ________________________________
> From: Dan Bron <j...@bron.us>
> To: programm...@jsoftware.com
> Sent: Thursday, February 20, 2014 2:39:49 PM
> Subject: [Jprogramming] Generating code from templates
>
>
> 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
