Tacit recursion without $:
Is there ever a case for tacit recursion without the use of the
self-reference verb ($:)?
One reason is if one wants to define and fix a tacit verb in terms of one
or more tacit recursive verbs. The problem is that the official public
version of J lacks the means to provide a direct scope for the recursion
phrase containing the self-references. It is possible, but inefficient, to
circumvent this problem by employing recursion without $:. This was the
motivation for developing the recursion scope adverb (103!.0) extension
[0,1]. Thus, this is no longer an issue when using a patched version of
J.
What about when writing mutually recursive anonymous verbs?
One can even use $: to accomplish this using the recursion scope (103!.0).
How? See, for example, hint/solution (a). A reasonably interesting test
case is the implementation of the female and male sequences [7]. (See [1]
to find where to get a suitable Windows J DDL version with recursion
scope.)
What about when writing recursive tacit adverbs since $: is only meant to
self-refer verbs?
The agenda form (@. N) where N is boxed is a fairly general, but often a
cumbersome and only occasionally a convenient, scheme to write tacit
adverbs. However, the (@. N) form is not necessary. An alternative way is
via the adverb (Adv) in [2] that adverbializes a verb; see also the adverb
(av) in [3] (or a similar adverb, for example, the permissive adverb (adv)
defined in [1]). The generic defining sentence form is ((`'') (workhorse
f.Adv) (`:6)) where workhorse is a tacit verb that takes the adverb's
gerund as an argument and constructs the atomic representation of the
desired word to be produced by the adverb (and any valid computable atomic
representation can be produced, in principle, by a workhorse verb since
tacit verbal programming is (Turing) complete). The burden of working with
atomic representations can be mitigated by using heterodox wicked verbs
that can take and produce any type of word (see, [1] and references there
in) and the form is in this case simplified to (darkhorse f. Adv). There
is one issue though, the agenda form (@. N) is used in the definition of
the adverb (Adv)! However, the adverb (Adv) can be rewritten without using
the agenda form. How? See, hint/solution (b).
Thus, if a recursive method is well-advised, it could always be implemented
in the definition of the workhorse, or the darkhorse, via $:. Therefore,
there is never a case for recursion without the use of $: with just one
type of exception (as far as I know). How come? The exception occurs when
it is required because of syntactic reasons! What? Consider the following:
One can write tacitly an adverb (Recursion) that reproduces the behavior of
(`:4) described in [4]. (How? See hint/solution (c).) So that,
fact=. *`1:`*`<: Recursion NB. Factorial
fact 5
120
Fib=. >&1`(i.@>:)`(] , +/@(_2&{.)@])`<: Recursion NB. Fibonacci
Fib 7
0 1 1 2 3 5 8 13
One can even produce an adverb (Recur) that that takes the arguments
(Proposition, Basis, Combine, and Reduce) as a strand; this is a form
pioneered by Dan (see, for example, [5,6]),
fact=. * 1: * <: Recur NB. Factorial
fact 5
120
Fib=. (>&1) (i.@>:) (] , +/@(_2&{.)@]) <: Recur NB. Fibonacci
Fib 7
0 1 1 2 3 5 8 13
Furthermore, one can even write a fixed adverb (sna) that takes as a strand
(of course!) the atomic representation of any adverb, which takes a gerund
(in the form of an argument list), and (sna) also takes the tally (#) of
that gerund and produces a corresponding (fixed) adverb, which takes the
arguments as a strand. How? The subject of this message implies the
answer: recursively (without $:)! For more details see the hint/solution
(d). For instance, the adverb (Recur) was defined as,
ar=. 5!:1@<
Recur=. (ar'Recursion') 4 sna NB. Recur is fixed automatically
(Incidentally, although Recursion and Recur can produce a wide variety of
recursive verbs, more complex recursive verbs, such as the recursive
definition of the Ackermann function, do not seem to fit the (Proposition,
Basis, Combine, and Reduce) mold. Am I mistaken?)
Is there any benefit for defining adverbs in strand form (apart from
allowing one to write neat expressions)? I think so: these expressions
are, or should be, right-associative and provide flexible means to refer to
the argument of a derived adverb, the argument of the derived adverb of a
derived adverb, and so on; thus, one can easily bond adverb arguments. For
example, often the Reduce recursion part is decrement (<:), so one can
easily write an adverb (rd) that would accommodate those cases,
rd=. <: Recur NB. rd is fixed automatically
fact=. * 1: * rd
fact 5
120
Fib=. (>&1) (i.@>:) (] , +/@(_2&{.)@]) rd
Fib 7
0 1 1 2 3 5 8 13
Sometimes the order of the arguments of the source adverb might not be
convenient for bonding. For the typical adverbs taking a gerunds, it is
quite easy to derive a target adverb with an arbitrary permutation of the
arguments: just adverbialize a permutation verb first; for example, ((P&{
Adv) Recursion) where P is an arbitrary permutation. It is not as easy to
permute the arguments of adverbs taking strands. Yet, one can write a
generic adverb Permute to derive a target adverb, which takes a list of
arguments as a gerund, from a permutation verb and the (atomic
representation of the) source adverb, which takes its arguments as a
strand. The derived verb can in turn be easily converted to take its
arguments as a strand. For example,
recur=. (3 2 1 0&{) (ar'Recur') Permute 4 sna
<: * 1: * recur 5
120
<: (] , +/@(_2&{.)@]) (i.@>:) (>&1) recur 7
0 1 1 2 3 5 8 13
recur=. |. (ar'Recur') Permute 4 sna
<: * 1: * recur 5
120
<: (] , +/@(_2&{.)@]) (i.@>:) (>&1) recur 7
0 1 1 2 3 5 8 13
* 1: * <: Recur 5
120
* 1: * <: |.(ar'recur') Permute 4 sna 5
120
(>&1) (i.@>:) (] , +/@(_2&{.)@]) <: Recur 7
0 1 1 2 3 5 8 13
(>&1) (i.@>:) (] , +/@(_2&{.)@]) <: |.(ar'recur') Permute 4 sna 7
0 1 1 2 3 5 8 13
How can one write Permute? See hint/solution (e).
[0] J functional programming extensions
http://www.jsoftware.com/pipermail/programming/2013-March/031835.html
[1] J Functional Programming Extensions
http://journalofj.com/index.php/vol-2-no-2-october-2013
[2] Recursion
http://www.jsoftware.com/pipermail/programming/2013-November/034177.html
[3] Tacit adverbial programming patterns
http://www.jsoftware.com/pipermail/programming/2013-February/031673.html
[4] Gerunds and Representations
http://www.snakeisland.com/gerunds.htm
[5] How to make this conjunction tacit
http://www.jsoftware.com/pipermail/programming/2013-October/033639.html
[6] How to make this conjunction tacit
http://www.jsoftware.com/pipermail/programming/2013-October/033654.html
[7] Hofstadter's female and male sequences
http://en.wikipedia.org/wiki/Hofstadter_sequence#Hofstadter_Female_and_Male_sequences
The hints/solutions follow after the countdown:
,. @: |. @: i. 43
42
41
40
39
38
37
36
35
34
33
32
31
30
29
28
27
26
25
24
23
22
21
20
19
18
17
16
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
NB. The following were referred as hints/solutions. They are solutions
written using a
NB. permissive extended version of J described in [1]; but, there are
also hints because the
NB. ideas could be applied to write solutions using an official version
of J. Verbalized
NB. primitive adverbs and conjunctions can be produced using an
alternative definition for
NB. Cloak (]:): Cloak=.
(<(<,'4'),<(<(<,'4'),<;:'0:`'),<(<,'4'),<;:',^:') (0:`)(,^:). In
NB. addition, tacit adverbs can replace derived tacit conjunctions which
are not possible to
NB. produce using the official version. Orthodox tacit solutions are,
in principle, also
NB. possible (with the virtual exception of (a)), but probably hard to
write. As its name
NB. implies, the orthodox solution to question (b) does not require any
extensions.
NB.
NB. Moreover, for the law abiding explicit writers (if there are any
still reading this far)
NB. I do not see any reason why anonymous solutions could not be written
explicitly; then
NB. again, I do not write explicitly, what do I know?
NB. The hints/solutions are presented slightly out of order ((a), (b),
(d), (c) and (d)).
NB. General preliminary pro-words...
(ar=. 5!:1@<) (st=.7!:2@:] ; 6!:2) NB. Verbs
5!:1@< (7!:2@:] ; 6!:2)
(o=. @:) NB. Conjunction
@:
(x=. o[) (y=. o]) (g=. "_1) (e=. &.>) (c=. "_) (f=. &{::) NB. Adverbs
(((((o[)(o]))("_1))(&.>))("_))(&({::))
NB. (a) Mutual
recursion....................................................................
pre=. o <:
zip=. @.(0 = ])
NB. Odd/Even (first a classic simple example)
NB. see http://en.wikipedia.org/wiki/Mutual_recursion
NB. Using pro-verbs
Even=. ( Odd pre)`1: zip
Odd =. (Even pre)`0: zip
(Even g ,: Odd g) o i. 11
1 0 1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0 1 0
NB. Anonymously using $: and recursion scope (103!:0)
NB. The idea is to write the recursive verbs as agenda cases of a single
encompassing
NB. recursive verb.
Even=. 0&oe
Odd =. 1&oe
( oe=. ( ( Odd pre y)`1: zip)`((Even pre y)`0: zip) @. [ )
Odd@:<:@:]`1:@.(0 = ])`(Even@:<:@:]`0:@.(0 = ]))@.[
( oe=. oe f. ) NB. Unfortunately,
1&oe@:<:@:]`1:@.(0 = ])`(0&oe@:<:@:]`0:@.(0 = ]))@.[
NB. Fixing oe manually,
( oe=. ( ( (1&$:) pre y)`1: zip)`(((0&$:) pre y)`0: zip) @. [ )
1&$:@:<:@:]`1:@.(0 = ])`(0&$:@:<:@:]`0:@.(0 = ]))@.[
Even f.
0&(1&$:@:<:@:]`1:@.(0 = ])`(0&$:@:<:@:]`0:@.(0 = ]))@.[ (103!:0))
Odd f.
1&(1&$:@:<:@:]`1:@.(0 = ])`(0&$:@:<:@:]`0:@.(0 = ]))@.[ (103!:0))
(Even f.g ,: Odd f.g) o i. 11
1 0 1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0 1 0
NB. Female/Male sequences
NB.
http://en.wikipedia.org/wiki/Hofstadter_sequence#Hofstadter_Female_and_Male_sequences
NB. Using pro-verbs
female=. (] - male o (female pre))`1: zip M.
male=. (] - female o (male pre))`0: zip M.
(female f.g ,: male f.g) o i. 22
1 1 2 2 3 3 4 5 5 6 6 7 8 8 9 9 10 11 11 12 13 13
0 0 1 2 2 3 4 4 5 6 6 7 7 8 9 9 10 11 11 12 12 13
st'(female g ,: male g) o i. 222'
┌─────┬─────────┐
│19136│0.0159093│
└─────┴─────────┘
NB. Anonymously using $: and recursion scope (103!:0)
NB. Again, the idea is to define the recursive verbs as agenda cases of
a single
NB. encompassing recursive verb.
female=. 0&fm
male=. 1&fm
fm=. ((] - male o (female pre y))`1: zip)`((] - female o (male pre
y))`0: zip) @. [ M.
fm f. NB. Unfortunately,
(] - 1&fm@:(0&fm@:<:@:]))`1:@.(0 = ])`((] - 0&fm@:(1&fm@:<:@:]))`0:@.(0 =
]))@.[M.
NB. Fixing fm manually,
fm=. ((] - (1&$:) o ((0&$:) pre y))`1: zip)`((] - (0&$:) o ((1&$:) pre
y))`0: zip) @. [ M.
male f.
1&((] - 1&$:@:(0&$:@:<:@:]))`1:@.(0 = ])`((] - 0&$:@:(1&$:@:<:@:]))`0:@.(0
= ]))@.[M. (103!:0))
female f.
0&((] - 1&$:@:(0&$:@:<:@:]))`1:@.(0 = ])`((] - 0&$:@:(1&$:@:<:@:]))`0:@.(0
= ]))@.[M. (103!:0))
(female f.g ,: male f.g) o i. 22
1 1 2 2 3 3 4 5 5 6 6 7 8 8 9 9 10 11 11 12 13 13
0 0 1 2 2 3 4 4 5 6 6 7 7 8 9 9 10 11 11 12 12 13
st'(female f.g ,: male f.g) o i. 222'
┌──────┬──────────┐
│155136│0.00219392│
└──────┴──────────┘
NB. There is a space-time tradeoff but the huge savings in space and
time for
NB. both versions come from the use of memoization (M.).
NB.
........................................................................................
NB. Someone might think that in a permissive environment the rules for
writing tacitly are
NB. discarted. On the contrary, they are more relevant than ever and it
is crucial to have
NB. in mind one of my favorite generic rules, "Learn the rules so you
know how to break them
NB. properly." Why? Because the power emanating from the tacit rules
of J is multiplied
NB. when it is delivered at higher levels (where tacit rules were not
supposed to operate).
NB. General preliminary pro-words for programming wickedly...
Cloak=. ]: NB. The monadic case is equivalent to,
NB. Cloak=. (<(<,'4'),<(<(<,'4'),<;:'0:`'),<(<,'4'),<;:',^:')
(0:`)(,^:)
NB. Verbalizing all primitive adverbs and conjunctions (only a few are
used in this session),
( (X=. 'power tilde dot even odd colon obverse adverse cut fit foreign
slash slashdot back backdot trap brace rank tie knot evoke atop agenda at
amper under dual appose') (;:x ,: ]) Y=. ;: '^: ~ . .. .: : :. :: ;. !. !:
/ /. \ \. ]. } " ` `. `: @ @. @: & &. &.: &:' )
┌─────┬─────┬───┬────┬───┬─────┬───────┬───────┬───┬───┬───────┬─────┬────────┬────┬───────┬────┬─────┬────┬───┬────┬─────┬────┬──────┬──┬─────┬─────┬────┬──────┐
│power│tilde│dot│even│odd│colon│obverse│adverse│cut│fit│foreign│slash│slashdot│back│backdot│trap│brace│rank│tie│knot│evoke│atop│agenda│at│amper│under│dual│appose│
├─────┼─────┼───┼────┼───┼─────┼───────┼───────┼───┼───┼───────┼─────┼────────┼────┼───────┼────┼─────┼────┼───┼────┼─────┼────┼──────┼──┼─────┼─────┼────┼──────┤
│^: │~ │. │.. │.: │: │:. │:: │;. │!. │!: │/
│/. │\ │\. │]. │} │" │` │`. │`: │@ │@. │@:│&
│&. │&.: │&: │
└─────┴─────┴───┴────┴───┴─────┴───────┴───────┴───┴───┴───────┴─────┴────────┴────┴───────┴────┴─────┴────┴───┴────┴─────┴────┴──────┴──┴─────┴─────┴────┴──────┘
( (X)=. ]: o < e Y ) NB. Verbalizing primitive adverbs and conjunctions
┌───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───...
│(]:(<'^:'))│(]:(<,'~'))│(]:(<,'.'))│(]:(<'..'))│(]:(<'.:'))│(]:(<,':'))│(]:(<':.'))│(]:(<'::'))│(]:(<';.'))│(]:(<'!.'))│(]:(<'!:'))│(]:(<,'/'))│(]:(<'/.'))│(]:(<,'\'))│(]:(<'\.'))│(]:(<'].'))│(]:(<,'}'))│(]:(<,'"'))│(]:(<,'`'))│(]:(<'`.'))│(]:(<'`:'))│(]:...
└───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───...
( (X=. 'bdot derivative Derivative secant fix hypergeometric LevelAt
memo spread TaylorCoeff WeightedTaylor TaylorApprox') (;:x ,: ]) Y=. ;: 'b.
d. D. D: f. H. L: M. S: t. t: T.' )
┌────┬──────────┬──────────┬──────┬───┬──────────────┬───────┬────┬──────┬───────────┬──────────────┬────────────┐
│bdot│derivative│Derivative│secant│fix│hypergeometric│LevelAt│memo│spread│TaylorCoeff│WeightedTaylor│TaylorApprox│
├────┼──────────┼──────────┼──────┼───┼──────────────┼───────┼────┼──────┼───────────┼──────────────┼────────────┤
│b. │d. │D. │D: │f. │H. │L: │M. │S:
│t. │t: │T. │
└────┴──────────┴──────────┴──────┴───┴──────────────┴───────┴────┴──────┴───────────┴──────────────┴────────────┘
( (X)=. ]: o < e Y ) NB. Verbalizing the rest of the primitive adverbs
and conjunctions
┌───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┐
│(]:(<'b.'))│(]:(<'d.'))│(]:(<'D.'))│(]:(<'D:'))│(]:(<'f.'))│(]:(<'H.'))│(]:(<'L:'))│(]:(<'M.'))│(]:(<'S:'))│(]:(<'t.'))│(]:(<'t:'))│(]:(<'T.'))│
└───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┘
( train=. evoke&6 ) NB. train
evoke&6
NB. Preliminary wicked pro-words...
box=. < o train g f. NB. Boxing verbs from gerund
( an=. <@:((":0) ,&< ]) ) NB. Atomizing a noun
<@:((,'0') ,&< ])
( ew=. adverb ]: (ar'an') ) NB. Encasing a word (adv)
(1]:(<(<'@:'),<(<,'<'),<(<,'3'),<(<<;._1 ' 0 0'),(<(<,'&'),<;:',<'),<,']'))
( ew=. adverb ]: an (f.ew) )
(1]:(<(,'0');<@:((,'0') ,&< ])))
( af=. an o fix f.) NB. Atomizing after fixing (an alternative
to atomic representations)
<@:((,'0') ,&< ])@:(]:(<'f.'))
( wl=. 104!:1 ) NB. Word from linear (similar to Dan's
dont)
104!:1
NB. These (verbalized primitive adverbs and conjunctions) operate as
brain surgeons,
NB. borrowing Dan's analogy [8], on conscious patients (verbs and
nouns). Neither there is
NB. a need to knock the arguments out into atomic representations (via
`'') nor to wake them
NB. up via a culminating train (`:6).
NB. (b) Adv without (@.
N)..................................................................
NB. An orthodox way...
( a0=. `'' ) ( a1=. (@:[) ((<'&')`) (`:6) ) ( a2=. (`(an _)) (`:6) )
((`'')(((@:[)(&`))(`:6)))((`_)(`:6))
(('a0'f.) (u a1) ('a2'f.))
((`'')(&(u@:[)))((`_)(`:6))
( Adv0=. ((ar'a0')`) (`(ar'a1')) (`(ar'a2') ) (`:6) )
(((`''`)(`(((@:[)(&`))(`:6))))(`((`_)(`:6))))(`:6)
u Adv0
((`'')(&(u@:[)))((`_)(`:6))
1 2 3 % Adv0 NB. Testing...
1 0.5 0.333333
NB. A wicked way...
( Adv=. ((af'a0')`) (`(af'a1')) (`(af'a2') ) (`:6) )
(((`''`)(`(((@:[)(&`))(`:6))))(`((`_)(`:6))))(`:6)
u Adv
((`'')(&(u@:[)))((`_)(`:6))
1 2 3 % Adv NB. Testing...
1 0.5 0.333333
st e '1 2 3 % Adv0' ; '1 2 3 % Adv' NB. They look the same but they are
not,
┌─────────────────┬─────────────────┐
│┌────┬──────────┐│┌────┬──────────┐│
││6272│3.80344e_5│││5120│1.38856e_5││
│└────┴──────────┘│└────┴──────────┘│
└─────────────────┴─────────────────┘
NB.
........................................................................................
NB. adv and conj adverbs...
( adv=. 'ew'f. (adverb ]: adverb ((&]:) ew)) ) ( conj=. 'ew'f. (adverb
]: conjunction ((&]:) ew)) )
((1]:(<(,'0');<@:((,'0') ,&<
])))(1]:(<(,'0');1&]:)))((1]:(<(,'0');<@:((,'0') ,&<
])))(1]:(<(,'0');2&]:)))
Fetch=. (] ([ amper train y)(({::`'')c))e o i. f.adv NB. Word mnemonics
5 Fetch NB. Example use (see (c) below),
┌───────┬───────┬───────┬───────┬───────┐
│0&({::)│1&({::)│2&({::)│3&({::)│4&({::)│
└───────┴───────┴───────┴───────┴───────┘
NB. Strand forms...
NB. (d) Gerund to strand adverb
converter...................................................
NB. Writing the adverb (sna) is a lot easier that one might think at
first glance because,
NB. due to the right-associativity property, one only has to write one
adverb (sna) that
NB. (using the number of arguments) collects the rest of the strand as a
list (the
NB. arguments, and the adverb to be converted) and evaluates this list
as a train formed by
NB. the (atomic representation of the) curtail (}:) and the tail ({:).
NB. sna...
C=. _2 NB. Counter position
last=. 1 >: C f NB. Is the last word in the queue?
dec=. <@:(<: o (C f)) C} ] NB. Decrementing the counter
next=. {: train o , an o dec NB. Producing the next adverb
eval=. train o ((an o }:) ; {:) NB. Evaluating an adverb form ( [: (an o
}:) {: Train )
main=. (next`(eval o (C&}.)) @. last) o knot f.conj NB. knoting and
reproducing itself and finally evaluating
sna=. (af'main')&(train o ([ ,(an o (>:y ; [)))f.) adv NB. The (main)
conjunction is referring indirectly to itself
sna NB. It is fixed...
(1]:(<(,'0');(<(,'0');(2]:(<(,'0');({: (]:(<'`:'))&6@:, <@:((,'0') ,&<
])@:(<@:(<:@:(_2&({::))) _2} ]))`((]:(<'`:'))&6@:(<@:((,'0') ,&< ])@:}: ;
{:)@:(_2&}.))@.(1 >: _2&({::))@:(]:(<'`.')))))&((]:(<'`:'))&6@:([ ,
<@:((,'0') ,&< ])@:(>:@:] ; [)))))
NB.
........................................................................................
NB. Sometimes the number of arguments of an adverb is variable. This
case can be handled
NB. using a sentinel. Both, sna and particularly sa, were inspired by
[9]. Their anonymous
NB. (fixed) recursive implementation is based on the classic trick
(Gödelian self-reference,
NB. Quines, u/y combinators): self reference and reproduction via
indirect reference to a
NB. self-representation; see also [10,11,12] and references there in.
NB. sa...
cap=. (<'[:') (train x -: ]) [ NB. Using cap ([:) as a sentinel
main=. ({:y train o , an o knot)`(eval o }:y) @. cap f.conj NB. knoting
and reproducing itself and finally evaluating
sa=. (fix'main') (af'main') NB. The (main) conjunction is referring
indirectly to itself
sa NB. It is fixed...
(2]:(<(,'0');({:@:] (]:(<'`:'))&6@:, <@:((,'0') ,&<
])@:(]:(<'`.')))`((]:(<'`:'))&6@:(<@:((,'0') ,&< ])@:}: ;
{:)@:}:@:])@.((<'[:') ((]:(<'`:'))&6@:[ -: ])
[)))(<(,'0');(2]:(<(,'0');({:@:] (]:(<'`:'))&6@:, <@:((,'0') ,&<
])@:(]:(<'`.')))`((]:(<'`:'))&6@:(<...
NB. Train...
darkhorse=. (('train'(wl ew) (train x at ]) train o (([ , (;`'') ,
])/))) f.
u0`u1`u2`u3 template=. darkhorse f. adv NB. Arguments as a gerund
train@:(u0 ; u1 ; u2 ; u3)
[: u0 u1 u2 u3 Train=. (af'template') sa NB. Arguments as a strand
train@:(u0 ; u1 ; u2 ; u3)
NB. (c) Recursion (reproduces the behavior of
(`:4))........................................
( 'v0 v1 v2 v3 self'=. 5 Fetch ) NB. Verbs mnemonics
┌───────┬───────┬───────┬───────┬───────┐
│0&({::)│1&({::)│2&({::)│3&({::)│4&({::)│
└───────┴───────┴───────┴───────┴───────┘
( $:`'' ( items=. box o (,~) ) v0`v1`v2`v3 ) NB. Verbs
┌──┬──┬──┬──┬──┐
│v0│v1│v2│v3│$:│
└──┴──┴──┴──┴──┘
sentence=. (v1 tie ([: v2 (self at v3) Train)) agenda v0
NB. v1 ` ( v2 $: @: v3 ) @. v0
[: v2 (self at v3) Train NB. is just a convenient (and more meaningful)
way to write,
train@:(v2 ; self at v3)
( darkhorse=. sentence o ($:`''&items) )v0`v1`v2`v3
v1`(v2 $:@:v3)@.v0
( Recursion=. darkhorse f.adv ) NB. Recursion as a
fixed adverb
(1]:(<(,'0');((1&({::) (]:(<,'`')) (]:(<'`:'))&6@:(2&({::) ; 4&({::)
(]:(<'@:')) 3&({::))) (]:(<'@.'))
0&({::))@:((,<'$:')&(<@:((]:(<'`:'))&6)"_1@:(,~)))))
( fact=. *`1:`*`<: Recursion ) NB. Factorial
1:`(* $:@:<:)@.*
fact 5
120
( Fib=. >&1`(i.@>:)`(] , +/@(_2&{.)@])`<: Recursion ) NB. Fibonacci
i.@>:`((] , +/@(_2&{.)@]) $:@:<:)@.(>&1)
Fib 7
0 1 1 2 3 5 8 13
NB.
........................................................................................
Recur=. (ar'Recursion') 4 sna NB. Recur is fixed
automatically
fact=. * 1: * <: Recur NB. Factorial
fact 5
120
Fib=. (>&1) (i.@>:) (] , +/@(_2&{.)@]) <: Recur NB. Fibonacci
Fib 7
0 1 1 2 3 5 8 13
NB. Bonding...
rd=. <: Recur NB. rd is fixed automatically
fact=. * 1: * rd
fact 5
120
Fib=. (>&1) (i.@>:) (] , +/@(_2&{.)@]) rd
Fib 7
0 1 1 2 3 5 8 13
NB. (e)
Permutations........................................................................
'Proposition Basis Combine Reduction' (i."_ 0 &: ;:) 'Reduction Combine
Basis Proposition'
3 2 1 0
NB. Typical adverb taking a gerund
<:`*`1:`* (((3 2 1 0&{)Adv) Recursion) 5
120
tgv=. `:6
(*`1:`*`<:) (af'Recur') ga=. (af'tgv') 2 sna
1:`(* $:@:<:)@.*
(<:`*`1:`*) (3 2 1 0&{adv) (af'Recur') ga
1:`(* $:@:<:)@.*
afTemplate=. an o ([: an o ([: (0&{) ((af'adv')c) Train) ((an o (1&{))c)
((af'ga')c) Train) f.adv
( ( 3 2 1 0&{ adv ) (af'Recur' )
( ga ) )
(1]:(<(,'0');3 2 1 0&{))((2]:(<(,'0');({: (]:(<'`:'))&6@:, <@:((,'0') ,&<
])@:(<@:(<:@:(_2&({::))) _2} ]))`((]:(<'`:'))&6@:(<@:((,'0') ,&< ])@:}: ;
{:)@:(_2&}.))@.(1 >: _2&({::))@:(]:(<'`.'))))((<(,'0');(2]:(<(,'0');({:
(]:(<'`:'))&6@:, <@:((,'0') ,&< ])@:...
NB. template=. (3 2 1 0&{adv) (af'Recur') ga
NB. recur=. (af'template') 4 sna
NB. <: * 1: * recur 5
NB. <: (] , +/@(_2&{.)@]) (i.@>:) (>&1) recur 7
NB.
NB. (3 2 1 0&{) ` (af'Recur') afTemplate
NB. an o ([: an o ([: (0&{) ((af'adv')c) Train) ((an o (1&{))c)
((af'ga')c) Train) ((3 2 1 0&{)) ` (af'Recur')
NB. recur=. (((3 2 1 0&{) ` (af'Recur')) afTemplate) 4 sna
NB. recur=. ((3 2 1 0&{) (af'Recur') (af'afTemplate') 2 sna) 4 sna
Permute=. (af'afTemplate') 2 sna
recur=. (3 2 1 0&{) (ar'Recur') Permute 4 sna NB. Reversing the list os
arguments,
<: * 1: * recur 5
120
<: (] , +/@(_2&{.)@]) (i.@>:) (>&1) recur 7
0 1 1 2 3 5 8 13
recur=. |. (ar'Recur') Permute 4 sna NB. An equivalent direct
way,
<: * 1: * recur 5
120
<: (] , +/@(_2&{.)@]) (i.@>:) (>&1) recur 7
0 1 1 2 3 5 8 13
NB. Alternatively...
recur=. (3 2 1 0&{) (af'Recur') Permute 4 sna
<: * 1: * recur 5
120
<: (] , +/@(_2&{.)@]) (i.@>:) (>&1) recur 7
0 1 1 2 3 5 8 13
recur=. |. (af'Recur') Permute 4 sna
<: * 1: * recur 5
120
<: (] , +/@(_2&{.)@]) (i.@>:) (>&1) recur 7
0 1 1 2 3 5 8 13
NB. Checking...
* 1: * <: Recur 5
120
* 1: * <: |.(ar'recur') Permute 4 sna 5
120
(>&1) (i.@>:) (] , +/@(_2&{.)@]) <: Recur 7
0 1 1 2 3 5 8 13
(>&1) (i.@>:) (] , +/@(_2&{.)@]) <: |.(ar'recur') Permute 4 sna 7
0 1 1 2 3 5 8 13
NB. [8] making a 'first' adverb tacit
NB.
http://www.jsoftware.com/pipermail/programming/2013-November/033914.html
NB. [9] Third argument (was: avoid boxing with fills - ?)
NB.
http://www.jsoftware.com/pipermail/programming/2009-July/015541.html
NB. [10] J Myths Puzzles (Last Spoiler)
NB.
http://www.jsoftware.com/pipermail/programming/2008-March/009915.html
NB. [11] Tacit Programming in Action: A Decade of Experience (Slides
99-111)
NB. http://www.2bestsystems.com/j/J_Conference_2012. All
NB. [12] Y Combinator -- "the J way"
NB.
http://www.jsoftware.com/pipermail/programming/2012-June/028335.html
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
