I forgot. The form for Adv is (whitehorse f.Adv) and the verb whitehorse is supposed to be a purist verb; therefore, Adv has to be patched (for instance) as follows,
Adv=. (train f. @:) (train o ((af'a4') ; ] ; (af'a3')"_) f.av) So, for example, (i.2 3) ]Adv 0 1 2 3 4 5 (i.2 3) ((<'*:') ; ]) Adv 0 1 4 9 16 25 On Mon, Dec 14, 2015 at 7:54 PM, Jose Mario Quintana < [email protected]> wrote: > > Dan writes: > > " > I have yet to find a satisfactory, general, and elegant way to express the > clause: > > ((<":noun)`) (((":noun) <@:; <^:2)`) (@.(0; 1 2)) > ... > > What I’d really like is a general adverb that > > - Accepts a verb as input, deriving another adverb > - That adverb converts its own input, whether noun or verb, to its > atomic representation > - Then the derived adverb applies the original verb to the atomic rep > it just created, allowing it to produce a new atomic rep > > That is, the verb input to this adverb would be an “atomic rep > manipulator”; having this adverb would make essentially reduce general > tacit adverbial programming in J to general tacit verb writing, which is a > much better explored field, and easier to do. > " > > I have never really liked the @. way very much but for a while I thought > it was necessary but it is not. The solution that you did not see uses the > form (workhorse f.av (`:6)) but it is not quite what you have in mind. > In Jx i have been using for quite some time an adverb (adv) that is very > close to it; the form to produce an adverb is (darkhorse f.adv) . So, for > example, ]adv is, of course, the identity adverb. The Jx version is just a > variant of a new primitive in the latest version of the interpreter but I > just rewrote a draft version of adv for an official J interpreter (it has > been just midly tested)... > > JVERSION > Installer: j602a_win.exe > Engine: j803/2014-10-19-11:11:11 > Library: 6.02.023 > > (i.2 3) ]adv > 0 1 2 > 3 4 5 > !@# ]adv > !@# > u`v ]adv > ┌─┬─┐ > │u│v│ > └─┴─┘ > > > !@# <adv NB. Boxing !@# ! > ┌───┐ > │!@#│ > └───┘ > > An alternative version more acceptable to a purist has the form (workhorse > f.Adv) where the workhorse verb takes the atomic (gerundial?) > representation of the argument, > > > (i.2 3) ]Adv > ┌─────────┐ > │┌─┬─────┐│ > ││0│0 1 2││ > ││ │3 4 5││ > │└─┴─────┘│ > └─────────┘ > !@# ]Adv > ┌─────────┐ > │┌─┬─────┐│ > ││@│┌─┬─┐││ > ││ ││!│#│││ > ││ │└─┴─┘││ > │└─┴─────┘│ > └─────────┘ > u`v ]Adv > ┌─────────┐ > │┌─┬─────┐│ > ││0│┌─┬─┐││ > ││ ││u│v│││ > ││ │└─┴─┘││ > │└─┴─────┘│ > └─────────┘ > > Both, adv and Adv are tacit, fixed, and @. free,: > > adv > ((`'')(&(,^:(0:``:)&6@:((<(,'0');"_) ; ] ; (<(,'0');(@:(,^:(0:``:)&6@ > :(<@:((0;1;0)&({::)))))((((`''`)(`(((@:[)(&`))(`:6))))(`((`_)(`:6))))(`:6)))"_)@:[)))((`_)(`:6)) > Adv > ((`'')(&(,^:(0:``:)&6@:((<(,'0');"_) ; ] ; > (<(,'0');(@:(<@:((0;1;0)&({::))))((((`''`)(`(((@:[)(&`))(`:6))))(`((`_)(`:6))))(`:6)))"_)@:[)))((`_)(`:6)) > > > Later I would try to add more tools and provide some examples but in the > meantime you can play with the toolkit if you like. > > NB. > ---------------------------------------------------------------------------- > NB. Wicked Tacit Toolkit... > NB. > ---------------------------------------------------------------------------- > > NB. Load it using 0!:0 or similar or > NB. paste it on an J editing window and use Crtl-A Crtl-E or > NB. of course, load it using a hot key or ... > > o=. @: > e=. &.> > > an=. <@:((,'0') ,&< ]) > Cloak=. (<(<,'4'),<(<(<,'4'),<;:'0:`'),<(<,'4'),<;:',^:') (0:`)(,^:) > > 'evoke fix tie'=. Cloak o < e o ;: '`: f. `' > train=. evoke&6 f. > > af=. an o fix > > (a0=. `'') (a1=. (@:[) ((<'&')`) (`:6)) (a2=. (`(<(":0);_)) (`:6)) > av=. ((af'a0')`) (`(af'a1')) (`(af'a2') ) (`:6) > NB. Adverbing a monadic verb (adv) > assert 1 4 9 -: 1 2 3 *: adv > > aw=. < o ((0;1;0)&{::) NB. Fetching the atomic representation > > a3=. (o (train o aw f.)) ('av'f.) > a4=. "_ > > adv=. train o ((af'a4') ; ] ; (af'a3')"_) f.av > > a3=. (o (aw f.)) ('av'f.) > Adv=. train o ((af'a4') ; ] ; (af'a3')"_) f.av > > PS. The adverb adv is intrinsically and proudly wicked; the writing a > purist version of Adv is left as an easy exercise for the reader ;) > > > > > Pepe wrote: > > This is a puzzle for adverbial tacit writing fans: Write a purist tacit > > adverb (sf1) such that, for example, > > > > (v0 v1 v2)sf1 > > v0@[ v1 v2@] > > > > 3 4 (+: + -:)sf1 2 4 > > 7 10 > > > I’m sure your solution is more elegant, but I haven’t looked yet, so > here’s my attempt: > > LMR =: (`'') ((<":noun)`) (((":noun) <@:; <^:2)`) (@.(0; 1 2)) > (xform`) (`:6) (`:6) > xform =: (left center right)`'' ('[' atop~ ])`(']' atop~ > ])`]@.((;:'left right') i. [)"0 L:1 ] > atop =: '@' <@; <@:,&boxopen > > For example: > > (v0 v1 v2) LMR > v0@[ v1 v2@] > > 3 4 (+: + -:)LMR 2 4 > 7 10 > > The approach is general in the sense that it simply converts the train > into its atomic representation, then manipulates that representation > structurally, then executes the manipulated atomic rep to produce the > desired verb. > > I have yet to find a satisfactory, general, and elegant way to express the > clause: > > ((<":noun)`) (((":noun) <@:; <^:2)`) (@.(0; 1 2)) > > Which is almost-but-not-quite repeated in all the code I’ve written along > these lines (e.g. in “anonymous evoke”, etc). It converts the atomic rep of > (v0 v1 v2), which is: > > <(":verb) ;< ;:'v0 v1 v2' > +--------------+ > |+-+----------+| > ||3|+--+--+--+|| > || ||v0|v1|v2||| > || |+--+--+--+|| > |+-+----------+| > +--------------+ > > to the atomic representation _of that atomic representation_, which is: > > <(":noun) ;<(":verb) ;< ;:'v0 v1 v2' > +------------------+ > |+-+--------------+| > ||0|+-+----------+|| > || ||3|+--+--+--+||| > || || ||v0|v1|v2|||| > || || |+--+--+--+||| > || |+-+----------+|| > |+-+--------------+| > +------------------+ > > Doing this is necessary so that we can then prepend the manipulating verb > (in this case, xform) to this atomic rep, then execute the resulting gerund > (array of 2 atomic reps: the verb and the box above), so that the verb acts > on the atomic rep of the train. > > I thought I could do something along the lines of > > (`'') ((<":noun)`) (xform`) (@.(0;1 2)) > > That is, just create an array of 3 boxes, then use the boxed-RHA version > of @. to nest the gerund appropriately, but unfortunately in this case, the > input to xform needs an extra layer of boxing, and (@.(0;1 ;<2)) etc didn’t > work. > > What I’d really like is a general adverb that > > - Accepts a verb as input, deriving another adverb > - That adverb converts its own input, whether noun or verb, to its > atomic representation > - Then the derived adverb applies the original verb to the atomic rep > it just created, allowing it to produce a new atomic rep > > That is, the verb input to this adverb would be an “atomic rep > manipulator”; having this adverb would make essentially reduce general > tacit adverbial programming in J to general tacit verb writing, which is a > much better explored field, and easier to do. > ---------------------------------------------------------------------- For information about J forums see http://www.jsoftware.com/forums.htm
