```rslt ← {larg} (func ##.tc) rarg             ⍝ Trace of function application.

Monadic operator [tc] applies its [func]tion operand to/between its argument(s).
As a side-effect, the arguments, function and result are displayed in the  sess-
ion.

[tc] can be used as a debugging aid and to observe the behaviour of primitive or
defined operators.

"... for it [correcting code] is damnably troublesome work, & plagues me."  Ada,
Countess of Lovelace in a letter to Charles Babbage, 6 July 1843.

In  the case of a _primitive_ operator, [tc] shows its _formal_  reduction sequ-
ence. When unobserved by [tc], the interpreter is free to "cheat" in a number of
ways: for example, +/ of a boolean array is actually performed 8-items-at-a-time
and for associative functions such as + and ×, scan (\) operates cumulatively in
one pass from left to right.

Technical note:

tc←{⍺←⊢                             ⍝ Trace of function application.
fn←⍺⍺{⍙←⍺⍺ ⋄ ~∘' ⍙'⍕⊂⎕OR'⍙'}⍵   ⍝ function representation.
↑⊢/⎕←⍺ fn ⍵'=>',⊂⍺ ⍺⍺ ⍵         ⍝ display and result.
}

As '⍺⍺' is outside the domain of ⎕OR, the function representation is produced by
naming the operand function within an inner operator.

fn←⍺⍺{⍙←⍺⍺ ⋄ ········⎕OR'⍙'}⍵   ⍝ function representation.

The other part of this inner function:

fn←⍺⍺{·······~∘' ⍙'⍕⊂······}⍵   ⍝ function representation.

Removes the assigned name (⍙) and superfluous blanks  from the format of the ⎕OR
of a defined function, leaving it represented by a single ∇ character.

Examples:

1 2 3 +tc 4 5 6               ⍝ vector addition.
1 2 3  +  4 5 6  =>  5 7 9
5 7 9

1 2 3 +tc¨ 4 5 6              ⍝ item-wise addition.
1  +  4  =>  5
2  +  5  =>  7
3  +  6  =>  9
5 7 9

⍳tc¨2 3                       ⍝ monadic function application.
⍳  2  =>  1 2
⍳  3  =>  1 2 3
┌───┬─────┐
│1 2│1 2 3│
└───┴─────┘

×tc/⍳5                        ⍝ reduction
4  ×  5  =>  20
3  ×  20  =>  60
2  ×  60  =>  120
1  ×  120  =>  120
120
×tc\⍳5                        ⍝ scan
1  ×  2  =>  2
2  ×  3  =>  6
1  ×  6  =>  6
3  ×  4  =>  12
2  ×  12  =>  24
1  ×  24  =>  24
4  ×  5  =>  20
3  ×  20  =>  60
2  ×  60  =>  120
1  ×  120  =>  120
1 2 6 24 120

0 +tc foldl ⍳5                  ⍝ +foldl: fold from left
0  +  1  =>  1
1  +  2  =>  3
3  +  3  =>  6
6  +  4  =>  10
10  +  5  =>  15
15
+tc/⍳5                        ⍝ compare with reduction (fold from right).
4  +  5  =>  9
3  +  9  =>  12
2  +  12  =>  14
1  +  14  =>  15
15

{⍵ ⍵}tc¨⍳3                    ⍝ non-primitive operand represented as '∇'
∇  1  =>  1 1
∇  2  =>  2 2
∇  3  =>  3 3
┌───┬───┬───┐
│1 1│2 2│3 3│
└───┴───┴───┘