Pascal Jasmin wrote:
> (`'') is an anonymous tacit adverb that will produce the atomic rep of
> its verb argument that seems pretty cool, but I haven't been able to
> grasp a use for it yet.
Advanced adverbial programming -- past the outskirts of (`:6), beyond the
hinterlands of the sneaky agenda trick -- often involves transforming atomic
representations. That is, writing verbs which take a.r.s as input and
produce different, related a.r.s as output. The adverb (`'') is a short,
simple way to convert input into its atomic representation, and so prepare
it for further transformation.
Think of it as anesthesia for verbs: like people, verbs prefer to be
unconscious during surgery, so (`'') puts them under the beginning, and
(`:6) wakes them up at the end, transformed.
-Dan
PS: "But wait,", you remark, "adverbs can take nouns for input as well as
verbs. So what implications does (`'') have for them?". Good question. It
really depends on what your adverb is doing. The first thing to note is
that (`'') is mostly an identity function for nouns: x`'' is identical to x,
except where x is scalar, in which case it's identical to ,x (viz, x,'' ).
So, in a sense, (`'') is a normalizing preprocessor: it ensures all inputs
are nouns (verbs are converted to nouns, and nouns are left alone, mostly).
So, if your only requirement is that the inputs to the core of your adverb
are nouns, (`'') is perfect. However, since we're discussing the method of
adverbial programming which transforms atomic representations, we require a
deeper normalization than that. Recall that (`'') converts verbs to nouns,
but not any old nouns; no, verb inputs are converted to a special type of
noun, in a restricted domain: atomic representations. So, to really put
verb and noun inputs on equal footing, to achieve true homogenization, so
that our core transformation doesn't have to care whether the original input
was a verb or a noun (unless it wants to), we need to do something extra.
We need to force nouns into the same restricted domain as verbs: to
nondestructively convert a noun to its own atomic representation.
One quick, cute (and arguably elegantly symmetric) method to do that is
simple: just convert all nouns to verbs before converting all verbs to
nouns! But ... doesn't that beg the question? Surely if we could distinguish
noun from verb input, we wouldn't need to convert nouns to verbs in the
first place? Or, conversely, if we try to coerce nouns to verbs without
knowing what kind of input we have, won't that have unintended consequences
for verbal input?
Well, kinda. What we'd really like is some kind of identity adverb. Sort of
like (`''), which converts verbs to nouns and (mostly) leaves nouns alone.
Only we want its dual: we wish to convert nouns to verbs, and leave verbs
(mostly) alone. Sound familiar?
Convert noun to verb: N"_ . Leave verb (mostly) alone: f"_ . Tada!
So, how's this for a homogenizing utility adverb? ("_) (`'') . Pretty
sweet! First, all nouns are converted to verbs (N"_) and verbs are mostly
left alone (f"_ will never change the results of f applied to arguments,
though it may change other verbs derived from f ). Second, all verbs (now
meaning: all input) are converted to nouns, specifically atomic
representations. Voila! We have evolved from raw chloroform to balanced
anesthesia.
Of course, there are some artifacts left behind: the needle in the vein, or
the mask over the face, which may interfere with our operation. But, since
the patient is safely knocked out, we can remove these extranea without
fear; he'll sleep until we're ready to wake him. In this case, the
obstructive mask is ("_) : our verb (or noun) wasn't wearing that when he
walked in. Let's take it off, and give ourselves complete access to the
patient.
knockOut =: ("_) (`'')
strip =: ((<":noun)`) (({.@>@{:)`) (@.(0; 1 2))
prep =: knockOut strip
ar =: 1 : '5!:1<,''u'''
(+ ar ) -: + prep NB. a.r. of plus
1
(+/ ar) -: +/ prep NB. a.r. of sum
1
(3 ar ) -: 3 prep NB. a.r. of three
1
(a: ar) -: a: prep NB. a.r. of ace
1
Pretty neat. A tacit adverb which produces the unadulterated atomic
representation of its input, with a total domain (i.e. all nouns and all
verbs: everything an adverb could possibly take as an argument).
However, we lost a little something of the elegance of 'knockOut' by
introducing 'strip' (which I considered naming 'stripNude', but since the
NSA is watching, I thought it prudent to be more prudish). As compensation,
'strip' serves both as a self-documenting example and a utility. That is, it
demonstrates how to manipulate atomic representations to modify code, while
also producing exactly the a.r.s intended to be so manipulated. And, as a
utility, it can save you a step. Rather than use the output of 'strip', you
could layer your own transformation on top of the one it applies, and then
execute the result.
For example:
stripNtriple =: ((<":noun)`) (((<3;~":noun),#`'',{.@>@{:)`)
(@.(0; 1 2))
+/ knockOut stripNtriple 1 2 3
6 6 6
6 knockOut stripNtriple
6 6 6
Anyway, that's the "why" and "how" of (`''). For more examples of the
"what", try searching the Forum archives or the Wiki for instances of (`'')
or (''`) .
PPS: Exercise for the very ambitious reader: define a tacit adverb opTheat
(operating theatre), which, given a verb (the surgeon), derives another
tacit adverb, such that
surgeon OpTheat
((<":0)`) (surgeon`) (@.(0; 1 2))
The objective is to be able to provide an convenient utility / interface for
adverbial programmers, so that their responsibility is only to write the
core a.r.-transforming function (i.e. perform the surgery), and not always
have to prepare the patient and the operating theatre themselves.
Note that excessive quoting will somewhat defeat the purpose of the exercise
(defining the adverb _tacitly_; it's easy to do explicitly, exactly because
that's just quoted code).
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
