Can someone define or link to an explanation of a.r.s? It sounds like an
important concept that is new to me.
On Nov 3, 2013 11:38 AM, "Dan Bron" <[email protected]> wrote:
> Lest my messages are taken as idle pun-ditry and Raul decides I need a puns
> in the face, let me try to add some value.
>
> I wrote:
> > knockOut =: ("_) (`'')
> > strip =: ((<":noun)`) (({.@>@{:)`) (@.(0; 1 2))
> > prep =: knockOut strip
>
> Raul responded:
> > And, of course, with these definitions:
> >
> > strip
> > |domain error
> >
> > I'm not sure I can take this much puns.
>
> I take, from Raul's message, that he was inspecting 'strip', most likely to
> see how it works. Let me try to shed some light.
>
> The adverb 'strip' takes an atomic representation as input, and produces
> another, related a.r. as output. Specifically, it strips out the "_
> inevitably added in "knockOut", leaving the unadulterated a.r. of the
> original input.
>
> It achieves this by creating an intermediate a.r., which is explicitly
> marked as a noun, tacking the a.r. of a specific verb in front of it (the
> one that will strip off the "_) and executing that verb-noun bident,
> invoking the "monad" parser rule, and causing the verb to be applied to the
> noun.
>
> After that, the concepts are straightforward J. The verb's input is the
> a.r. of a noun, which is simply a boxed structure. Because we've normalized
> the input, that boxed structure will always have the form '"';< something
> ;<'0';_ (which is how something"_ is represented as an a.r.). So, the verb
> simply traverses the boxed structure, and pulls out the 'something' (i.e.
> drops the "_).
>
> Since a.r.s are recursive, and we pulled 'something' out of an a.r., then
> it, too, is an a.r. . Specifically, 'something' is the a.r. of the
> original
> input, be it a noun or a verb. QED.
>
> Procedurally, the adverb breaks down into the following steps, in order:
> (0) input
>
> (1) ("_) : convert nouns and verbs to verbs of infinite rank.
>
> (2) (`'') : generate a.r. of (1), which has a little more
> structure than (0), but the a.r. of (0) necessarily appears
> in the a.r. of (1)
>
> (3) ((<":noun)`): tack (<,'0') onto the result of (2), creating
> a 2-element gerund
>
> (4) (({.@>@{:)`): tack a de-ornamentation verb onto the result
> of (3), creating a 3-element gerund
>
> (5) (@.(0; 1 2)): execute the 3-element gerund as V NI where V
> is the verb tacked on in (4), and NI is the atomic composition
> of (2) and (3); that is, the a.r. produced in (2), marked up
> with (3) to say "treat me [NI] as a noun, so when I'm executed,
> produce identically (2), rather than the object it represents
> (which, of course, is (1))".
>
> The only real trick here, besides 'knockOut', is the RHA to @. , which
> isolates and composes N (i.e. ":0, the noun marker) with I (the a.r. of
> input"_), producing NI, the a.r. of the a.r. of input"_ . That is,
> V`N`I@.(0; 1 2) produces V,<N,I or V,NI and executes it as a train: v ni
> (where V is the a.r. of v and NI is the a.r. of ni ).
>
> -Dan
>
>
> ----------------------------------------------------------------------
> For information about J forums see http://www.jsoftware.com/forums.htm
>
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
