kmap ← {xk←(⊂,⊂∘kind)⎕nl-⍳10} ##.kk fnop    ⍝ Kind Koloring of d-fnop named ⍵.

Result [kmap] is a vector of character vectors of the "kinds" of names  in  each
line of the ⎕NR of right argument function or  operator  [fnop].  Optional  left
argument [xk] is a dictionary of the kinds of external names.

Background
----------
We  can't  parse the following line of APL until we know whether the names refer
to variables, functions or operators:

    report ← lines print title pages

For example, "print" could be a dyadic function (F), which takes the array-pair
(title pages) as right argument and array (lines) as left:

    report ← lines print title pages        ⍝ print is a function
                   FFFFF

or title could also be a (monadic) function:

    report ← lines print title pages        ⍝ print and title are functions
                   FFFFF FFFFF

or title could be a monadic operator (M), which takes function print as left
operand:

    report ← lines print title pages        ⍝ title is a monadic operator
                   FFFFF MMMMM

or print could be a dyadic operator (D), taking title as right operand:

    report ← lines print title pages        ⍝ print is a dyadic operator
             FFFFF DDDDD FFFFF

If we acknowledge that the expression to the right of the assignment arrow might
resolve  to  a function _train_, making "report" a function, there are many more
possibilites, including:

    report ← lines print title pages        ⍝ (lines print title) "atop" pages
    FFFFFF   FFFFF DDDDD       FFFFF

In general, an APL expression can be parsed if and only if its names can be
classified into one of four "kinds", depending on their referent values:

  N: array or niladic function
  F: function
  M: monadic operator
  D: dyadic operator

Here are some more examples using N and F to "kind-colour" names (and brackets):

    mean←{ sum←+⌿⍵ ⋄ num←≢⍵ ⋄ ( sum÷num ) }     ⍝ (sum÷num) nilad
    FFFF·F·NNN·······NNN······N·NNN·NNN·N·F

    mean←{ sum←+⌿⍵ ⋄ num←≢  ⋄ ( sum÷num )⍵}     ⍝ (sum÷num) Agh train
    FFFF·F·NNN·······FFF······F·NNN·FFF·F·F

    mean←{ sum←+⌿  ⋄ num←≢  ⋄ ( sum÷num )⍵}     ⍝ (sum÷num) fgh train
    FFFF·F·FFF·······FFF······F·FFF·FFF·F·F

In addition to names,  [kk]  colours parentheses and curly braces to reflect the
kinds of their contained expressions.

(muse:

    How many valid parsings are there of ⍵ consecutive distinct names?  We can
    try permutations of representatives (0 + ¨ ⍤) from each of the four kinds,
    trapping syntax errors for invalid sequences.  Here are the numbers for seq-
    uences of lengths from one to twelve, showing an approximately exponential
    increase. For a dozen adjacent distinct names there are over a million sep-
    arate interpretations:

        ⎕ ← kinds ← {+/,{2::0 ⋄ _←⍎'0+¨⍤'[⍵] ⋄ 1}¨⍳⍵/4}¨ 1 to 12
    3 7 19 60 200 669 2258 7644 25974 88475 302052 1033072

        ⌊ 0.5+ ⍟kinds               ⍝ exponential ←→ log approximately linear
    1 2 3 4 5 7 8 9 10 11 13 14

    Here are all 19 valid sequences of length 3:

        {~∘0,{2::0 ⋄ _←⍎'0+¨⍤'[⍵] ⋄ 'NFMD'[⍵] }¨⍳⍵/4} 3
    ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐
    │NNN│NNM│NFN│NFF│NMF│NMM│NDN│NDF│FNN│FNM│FFN│FFF│FFM│FMN│FMF│FMM│FDN│FDF│DNN│
    └───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘
)

A Colouring Experiment
----------------------
As an experiment [kk] has been used to colour the webpages for the code of the
functions and operators from this workspace.  Click the ##.kk link in the header
line above to see the effect.  As suggested by Morten Kromberg in his blog post,
the pages use _italics_ to distinguish array from function and operator values.

Attempting to use a BOLD font-style for operators widened the characters, caus-
ing misalignment of the comment symbols and rendering the overall effect rather
untidy.  To avoid this, monadic and dyadic operator names have been coloured in
medium and lighter blue, respectively:

       Font     Colour          Kind
       ----     ------          ----
    N: normal   black           niladic (array)
    F: italic   black           function
    M: italic   medium blue     monadic operator
    D: italic   lighter blue    dyadic operator

For example, in the code at http://dfns.dyalog.com/c_kk.htm, notice that:

1. In the second line, because ⊂∘kind is a function, the parenthesised express-
   ion as a whole is a _fork_ and so the parentheses are italicised. The ital-
   ics should help when reading the line, by indicating that the parenthesised
   expression consumes, rather than provides a left argument for, the result of
   the ⎕NL:

   [1]   ⍺←(⊂,⊂∘kind)⎕NL-⍳10                ⍝ (...) is a function
           F    FFFFF

   (muse: This identification of function trains may alone be sufficient reason
          for adopting kind-colouring.)

2. Within the definition of sub-function [body], notice that [dq] and [expr] are
   both identified as functions. The colouring helps with reading the ⊃ and / to
   their right as "first" and "reduction" respectively:

   [19]  K∆←1⊃dq⊃expr/(⌽⍺),⊂E∆ K ⍬          ⍝ dq is a fn, so ⊃ is "first"
              FF FFFF


The code for →rats← at http://dfns.dyalog.com/c_rats.htm provides examples of
several more cases:

1. [rats] itself is a (medium-blue-coloured) monadic operator.  With colouring,
   we can determine this immediately from the colours of the name and opening
   curly brace, without having to scan the body of the code for the presence of
   an ⍺⍺ (and the absence of an ⍵⍵, which would make it a _dyadic_ operator).

   [0]  rats←{⎕ML ⎕IO←1                     ⍝ rats is a monadic operator
        MMMM M

2. Inner [arith] is also easily identified as a monadic operator:

    [2]     arith←{                         ⍝ arith is a monadic operator
            MMMMM M

3. Inferring the kind of rats' operand ⍺⍺ is currently beyond kk's ability and
   so name "aa" in line[3] is coloured (red) for "unknown".

   [3]  fn←⍺⍺{aa←⍺⍺ ⋄ ⊃⎕CR'aa'}⍵            ⍝ aa is coloured "unknown"
             M??              M

4. [norm] and [sum] reference a function and monadic operator, respectively:

   [4]      '+'≡fn:norm ⍺+sum ⍵             ⍝ sum is a monadic operator
                   FFFF   MMM

5. Towards the end of the code some functions are derived from dyadic operators:

   [59] else←{⍺⍺ ⍵:⍵ ⋄ err ⍵⍵}              ⍝ else is a dyadic operator
        DDDD D               D                ¯¯¯¯
   [60] echk←{⍵≡⌊⍵}else'irrational'         ⍝ ... deriving function echk
        FFFF F    FDDDD                                             ¯¯¯¯
   [63] err←⎕SIGNAL∘11                      ⍝ err is a derived function
        FFF                                   ¯¯¯
   [65] imin←∩mesh⌊                         ⍝ dyadic op mesh derives fn imin
        FFFF  DDDD                                      ¯¯¯¯            ¯¯¯¯
   [67] gcd←imin over umax                  ⍝ dyadic op over derives fn gcd
        FFF FFFF DDDD FFFF                              ¯¯¯¯            ¯¯¯

The code for →joy← at http://dfns.dyalog.com/c_joy.htm shows the binding of ⍺ as
left operand of a multi-line monadic operator to form a derived function "prt":

   [208]    prt←⍺{                          ⍝ ⍺{...⍺⍺...} derives fn prt
            FFF  M                             ¯        ¯            ¯¯¯
Without the colouring of both prt and the left brace, this snippet would be hard
to parse  without noticing that nothing follows the matching brace fifteen lines
further down the code.

Kind-polymorphism
-----------------
Depending on context, some expressions can resolve to more than one kind.  Exam-
ples include the four "hybrid" tokens: / ⌿ \ ⍀,  which can each be of kind F  or
M, depending  on what is to their left, and operand tokens, ⍺⍺ and ⍵⍵, which can
each be either N or F. In isolation, the colours for names "slash" and "left" in
slash←/ and left←⍺⍺ cannot be  determined.

This is not a shortcoming of the kind-inference process: given this property  of
the Dyalog language, drawing attention to such ambiguities with distinct colours
can be considered a virtue.

For example, the name "left" in this operator:

    twice ← {left←⍺⍺ ⋄ left left ⍵}

has kind F if the operator is called with a function operand,  and N if an array
operand is used. In this case [kk] correctly infers a composite kind: N∨F.

[kk] employs a total of 11 colours: N, F, M, D, f, r, h, o, ·, Z and ?:

                        ┌────────── Example of referent value
                        │
N: niladic              ⍬           (name assigned to ⍬ is coloured N)
F: function             +           (name assigned to + is coloured F)
M: monadic operator     ⌸            etc
D: dyadic operator      ⍤

r: N∨F                  ⍺⍺ ⍵⍵       ("r" stands for opeRand)
h: · F∨M                / ⌿ \ ⍀     ("h" stands for Hybrid)
o: · · M∨D              ∇∇          ("o" stands for Operator)

f: monadic function     1+          (temporary kind used internally)
?: unresolved                       (kind could not be determined)
·: not coloured         ⍝...        (for tokens other than names and brackets)
Z: internal error                   (indicates a fault in the parse table)

In the web pages for the code at dfns.dyalog.com, colour _red_ is used for kinds
other than the primary N, F, M and D.  See: http://dfns.dyalog.com/c_ratsum.htm,
which contains several such expressions.

Kind-forcing
------------
When coding APL, it is often possible to "force" the kind of a polymorphic expr-
ession.  For example, it may be intended that the [twice] operator  be used only
to apply its operand _function_ twice to an argument array.

    twice ← {left←⍺⍺ ⋄ left left ⍵}

    ⊂twice 'this'           ⍝ enclosed twice
┌──────┐
│┌────┐│
││this││
│└────┘│
└──────┘

However, as coded, the operator is equally happy with an _array_ operand:

    '<'twice 'this'         ⍝ prefixed twice
┌─┬─┬────┐
│<│<│this│
└─┴─┴────┘

To force kind F for name "left", we could code:

    twice←{left←⍺⍺∘⊢ ⋄ left left ⍵}
                ¯¯¯¯
    ⊂twice 'this'           ⍝ function operand: enclosed twice
┌──────┐
│┌────┐│
││this││
│└────┘│
└──────┘

    '<'twice 'this'         ⍝ array operand is a no-op.
this

In similar fashion, adding ⊣0 to the end of line[131] of →ratsum← to become:

    [131]  digs←↑↓/(1 ¯1×'{}'≡ext ⍺⍺),⊂⍺⍺⊣0    ⍝ digits without surrounding {}s.
                                         ¯¯
... removes much of the red colouring from: http://dfns.dyalog.com/c_ratsum.htm.

Finally, note that (1+⍺⍺) has a compound kind of N∨F, whereas the kind of (⍺⍺+1)
is simply N. If ⍺⍺ always references an array, the latter coding should reduce
the burden on the human reader.

Technical notes:

0. kk's optional left argument ⍺ defaults to a dictionary of the →kind← of each
   name in the current namespace. A dictionary is a pair of vectors (names
   values) from which function [val], given a name, can obtain its value.

1. Function →tokens← is used to create a vector of token vectors from the lines
   of the ⎕NR of the subject function.

2. The tokens vectors for each line are joined with a synthetic newline token
   (,'┘') to produce a single vector [toks] of tokens. With respect to parsing,
   newlines are the same as diamonds.

3. Function [lint] removes tokens (comments and white space), not needed in the
   parsing, and returns a vector of indices into [toks] of the remaning ones.
   The orginal tokens can be retrieved from this vector with function [tx] and
   in the following descriptions the word "token" will often be used inter-
   changeably with "token index". In addition, surplus newlines and diamonds are
   removed, as are tokens for outer-product (∘.) so that all remaining ∘s can be
   treated as the commute operator. This works because kind(∘.f) ←→ kind(f).
   There are several similar transformations:

        kind(x.y)  ←→ kind(y)
        kind(x[y]) ←→ kind(x)
        kind(x←y)  ←→ kind(y)

4. The kind-inference process uses four mutually-recursive functions: [fnop],
   [body], [expr] and [tokn], together with a de-queueing function [dq] Here
   are their types:

    fnop :: S E K Q ← Tinx ∇ S E K Q
    body ::   E K   ← Body ∇   E K
    expr ::   E K Q ← Expr ∇   E K Q
    tokn :: S E K Q ← Tinx ∇ S E K Q
      dq ::     K   ←      ∇   E K Q

   where:
       S := [Kind]                  ⍝ Stack: vector of kinds
       E := [Tinx][Kind]            ⍝ Environment: maps tokens to kinds
       K := [Tinx Kind]             ⍝ Colour map: vector of token/kind pairs
       Q := [Body]                  ⍝ Queue of deferred fnop bodies
    Kind := N F M D _F NF H MD U Z  ⍝ Kind
    Body := [Expr]                  ⍝ Vector of ⋄:┘-separated exprs
    Expr := [Tinx]                  ⍝ Expression: vector of token indices
    Tinx := Indx | [Tinx]           ⍝ Index or indices into toks vector

    [fnop] takes a nested triple: '{' body '}'; logs the colours of the { and }
    braces by looking for the presence of ⍺⍺ or ⍵⍵ in the fnop body; and splits
    tokens into ⋄-, :- and ┘-separated expressions; with which it calls function
    [body].

    [body] processes the vector of expressions, which constitute the fnop body,
    with a left-to-right [expr]-reduction, accumulating E K and Q vectors.

    [expr] takes a vector of tokens, representing an expression, together with:
    an environment (E); current colour map (K); and body queue (Q), and returns
    new values for E, K and Q. The expression is processed with a right-to-left
    [tokn]-reduction.

    [tokn] takes a token to its left and the tuple (S E K Q) as right argument.
    E, K, and Q are as above and S is a stack of the kinds of tokens already
    visited. For a complete and correct expression, the stack S can be resolved
    into a single kind by function [parse]

5. The Queue Q

    The parsing process distinguishes fnop _definitions_ from _applications_.
    Applications are processed immediately on encounter but definitions are
    deferred until the end of the current body. The following code illustrates
    why this is necessary, when colouring instances of name "sum" within the two
    inner functions:

        {
            sum←+/          ⍝ sum:F    "sum is of kind F"
            def←{sum ⍵}     ⍝ def:F     sum:N (from below)
            app←{sum ⍵}⍵    ⍝ app:N     sum:F (from above)
            sum←+/⍵         ⍝ sum:N
            def 0           ⍝ def:F
        }

    After  processing all expressions in a fnop body, function [dq] is called to
    flush the queue.

Auxiliary functions:

    toks                        ⍝ token vector with white-space and ┘-newlines
┌───┬─┬─┬─┬────┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬────┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
│foo│←│{│┘│    │a│←│(│b│+│c│)│+│(│(│d│+│e│)│×│f│)│┘│    │a│[│g│]│∘│.│{│⍺│ │⍵│}│⍵│┘│}│
└───┴─┴─┴─┴────┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴────┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘

Function [lint] discards surplus tokens and returns a vector of the indices of
the remaining ones.

    lint toks                   ⍝ indices of de-fluffed tokens vector
0 1 2 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 24 25 26 27 30 31 33 34 35 37

[tx] reconstitutes tokens from their indices:

    tx lint toks                ⍝ reconstituted by [tx] function
┌───┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
│foo│←│{│a│←│(│b│+│c│)│+│(│(│d│+│e│)│×│f│)│┘│a│[│g│]│{│⍺│⍵│}│⍵│}│
└───┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘

[nest] encloses each occurrence of top-level of brackets into a triple.

    tx '{}'nest lint toks       ⍝ nested at {} tokens
┌───┬─┬─────────────────────────────────────────────────────────────┐
│foo│←│┌─┬───────────────────────────────────────────────────────┬─┐│
│   │ ││{│┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐│}││
│   │ ││ ││a│←│(│b│+│c│)│+│(│(│d│+│e│)│×│f│)│┘│a│[│g│]│{│⍺│⍵│}│⍵││ ││
│   │ ││ │└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘│ ││
│   │ │└─┴───────────────────────────────────────────────────────┴─┘│
└───┴─┴─────────────────────────────────────────────────────────────┘

    body ← 2 1⊃'{}'nest lint toks   ⍝ function body
    tx body
┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
│a│←│(│b│+│c│)│+│(│(│d│+│e│)│×│f│)│┘│a│[│g│]│{│⍺│⍵│}│⍵│
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘

    tx '()[]'nest body              ⍝ top-level () and [] nesting
┌─┬─┬─────────────┬─┬─────────────────────┬─┬─┬─────────┬─┬─┬─┬─┬─┐
│a│←│┌─┬───────┬─┐│+│┌─┬───────────────┬─┐│┘│a│┌─┬───┬─┐│{│⍺│⍵│}│⍵│
│ │ ││(│┌─┬─┬─┐│)││ ││(│┌─┬─┬─┬─┬─┬─┬─┐│)││ │ ││[│┌─┐│]││ │ │ │ │ │
│ │ ││ ││b│+│c││ ││ ││ ││(│d│+│e│)│×│f││ ││ │ ││ ││g││ ││ │ │ │ │ │
│ │ ││ │└─┴─┴─┘│ ││ ││ │└─┴─┴─┴─┴─┴─┴─┘│ ││ │ ││ │└─┘│ ││ │ │ │ │ │
│ │ │└─┴───────┴─┘│ │└─┴───────────────┴─┘│ │ │└─┴───┴─┘│ │ │ │ │ │
└─┴─┴─────────────┴─┴─────────────────────┴─┴─┴─────────┴─┴─┴─┴─┴─┘

Bugs:

1. [kk] confuses names in "dotted expressions":

    nil←0 ⋄ ⎕se.nil←⊢ ⋄ nil         ⍝ rightmost "nil" should be NNN
    NNN         FFF     FFF

2. It is possible to confound the kind inferencing by re-using the same name for
   different kinds within a particular fnop body.  Look  at  name  "what" in the
   following code:

    {
        what←0          ⍝ what:N
        fun←{what ⍵}    ⍝ what:?
        0⊣fun 0:        ⍝ first call on fun what:N
        what←⊢          ⍝ what:F
        fun 0           ⍝ second call on fun: what:F
    }

   In this example, name "what", within function "fun", will be coloured F by
   the de-queueing process. Ideally it should be coloured N∨F(r) but this would
   require a significantly more complex treatment.  Of course, refraining from
   changing the kind of a name, which is (arguably) good practice, should avoid
   this problem.

3. Primitive function execute (⍎) can return an array, function or monadic oper-
   ator: kind(⍎⍵) → N∨F∨M. [kk] ignores this fact and infers N.

        what←⍎'+'           ⍝ "what" wrongly coloured as N
        NNNN

   This could be improved slightly by adding some execute-specific binding rules
   but it hardly seems worth the increase in complexity. To force the colouring
   of an execute expression that is known to return a function, we could code:

        what←(⍎'+')∘⊢
        FFFF N    N

   ... although the parentheses remain as N.

Possible improvements:

1. Some kinds can be inferred from their context. For example, for correct code:

    The kind of a guard or error-guard must be N:

        (0<⍺⍺):⍵
        N    N

    Some primitive operators are known to accept only kind F operands:

        (0<⍺⍺)¨⍵
        F    F

    Some primitive functions are strictly dyadic so an expression to its left
    must be of kind N:

        (0<⍺⍺)∧⍵
        N    N

    Only kind N may be returned as the result of a function or operator:

        (0<⍺⍺)
        N    N

    An assignment of _multiple_ names must be of kind N:

        this that ← (0<⍺⍺)
        NNNN NNNN   N    N

    ... and so on.

2. A Mk-II version of [kk] might choose to deal in only the four primary kinds:
   N F M D.

   The inference process would create a parse-tree for the whole capsule (fnop)
   with ambiguous nodes represented as _vectors_ of multiple interpretations: a
   tree-of-trees. Items of stack S would, in general be vectors of kinds:

        S := [[K]]                              ⍝ Stack: vector vectors of kinds

   and [parse] would be applied to the outer-product-join reduction of the stack.
   A unification process (see →unify←) would filter consistent combinations from
   the tree-of-trees:

        S∆ E∆ ← E unify filter parse¨ ,⊃∘.,/ S  ⍝ all consistent interpretations
                                      ¯¯¯¯¯¯
   ... leaving some, though in practice probably few, multi-coloured names:

      {⍵/'NFMD'}¨1↓,⎕io≠⍳4/2                    ⍝ all possible kind colours
    ┌─┬─┬──┬─┬──┬──┬───┬─┬──┬──┬───┬──┬───┬───┬────┐
    │D│M│MD│F│FD│FM│FMD│N│ND│NM│NMD│NF│NFD│NFM│NFMD│
    └─┴─┴──┴─┴──┴──┴───┴─┴──┴──┴───┴──┴───┴───┴────┘

   In particular it could:

   1. Automatically make use of the kinds of operands passed to inner operators.
      For example, if local operator "twice" is only ever called with a function
      operand, then expressions that include ⍺⍺ within its body can be treated
      accordingly:

        {
            twice←{left←⍺⍺ ⋄ left left ⍵}   ⍝ left is FFFF because:
            this←⊂twice ⍺                   ⍝   twice is only ever called
            that←+/twice ⍵                  ⍝       with a _function_ as operand
            ...
        }

      Given this technology, it might be appropriate to colour the ⍺⍺, ⍵⍵ and ∇∇
      tokens themselves.

   2. Accumulate inference information between lines. For example, in the first
      line below, "nums" might reference either an array or a function (train).
      However, assuming the second line to be correct code, the expression to
      the left of the guard (which in isolation could also evaluate to a train)
      must reduce to 0 or 1, implying nums to be a nilad: NNNN.

        nums←1↓⍺⍺               ⍝ nums could be NNNN or FFFF
        0∊nums:'error'          ⍝ nums must be NNNN

3. In addition to resolving ambiguities, _conflicting_ kind determinations could
   be flagged as errors in the code.

Requires: →tokens← →kind←

Examples:

    mean←{
        sum←+⌿⍵
        num←≢
        (sum÷num)⍵
    }

      (⎕nr ,[0.5] kk)'mean'         ⍝ source lines and colours
┌──────┬───────────┬─────────┬──────────────┬─┐
│mean←{│    sum←+⌿⍵│    num←≢│    (sum÷num)⍵│}│
├──────┼───────────┼─────────┼──────────────┼─┤
│FFFF·F│····NNN····│····FFF··│····FNNN·FFFF·│F│
└──────┴───────────┴─────────┴──────────────┴─┘

    ⍝ The following function interleaves the lines of its argument function
    ⍝ with their kind colours:

    crkk←{↑↑,/(⎕NR ⍵){⍺ ⍵}¨kk ⍵}    ⍝ ⎕cr interleaved with line colouring

    crkk'mean'                      ⍝ colours per line of function "mean"
mean←{
FFFF·F
    sum←+⌿⍵
····NNN····
    num←≢
····FFF··
    (sum÷num)⍵
····FNNN·FFFF·
}
F

    crkk'crkk'                      ⍝ (selfie)
crkk←{↑↑,/(⎕NR ⍵){⍺ ⍵}¨kk ⍵}
FFFF·F····N·····NF···F·FF··F

See also: parse tokens kind alists to

Back to: contents

Back to: Workspaces