```/ This script is an example of Min, a minuscule functional language.
/ Call min from APL by typing:
/
/      min''
/
3           / Only single digit numbers may be entered: 0-9.
3
123         / When we make a mistake, a rather terse error message results.
?
+4          / '+', next successive number, is min's sole primitive function.
5
+(+4)       / We can use ()s to make complex expressions. In this example,
6
++3         / ···  we need them as functions associate (bind) to the left.
?
i = 0       / =  makes a definition using only a single character name: a-z.

f x = +(+x) / Functions are defined thus.

f(fi)       / We don't need blank spaces and in fact they are ignored.
4

/ We  can  see  that min is very simple and on the face of it, immensely feeble:
/ Only  single digit numbers; only single character names; only a single primit-
/ ive function. It also takes rather a long time to evaluate any non-trivial ex-
/ pression.  However, with a sufficiently powerful computer and a fair amount of
/ patience, one can do some interesting things:

t f x = f(f x)     / Functions can take functions as arguments.

t + 0              / t applies its first arg twice to its second arg.
2
t t + 0
4
t t t + 0          / Remember, functions associate to the left.
16
/   t t t t + 0        / Would eventually return 65536, but life's too short.

n 0 = 1            / Functions use _patterns_ to match specific arguments.
n 1 = 0            / This function implements 'not'.

n 0
1
n 1
0
n 2                / (domain error)
?
x   0  = 0         / Sign of: (signum)
x (+n) = 1         / Patterns may be expressions.

x 0
0
x 2
1

/ Pattern:  i   matches     0   1   2   3   ···
/         (+i)    ..            1   2   3   ···
/       (+(+i))   ..                2   3   ···
/               and so on.
/
/ Equations must not "overlap". For example, the definition:
/           x 0 = ···
/           x i = ···
/ ··· is ambiguous because _both_ patterns match an argument of 0.
/
/ A  function  may  take more than one argument and an equation is selected when
/ _all_ of its patterns match the given arguments. The function body (right hand
/ side  of  the equation) is then evaluated with any occurrences of each pattern
/ variable having a value consistent with the match. For example, when equation:
/ z i (+(+j)) (+k) = ···  matches arguments of 4, 5 and 6; variables i, j, and k
/ assume values of 4, 3, 5 respectively.
/
/   Pattern:        i   (+(+j))     (+k)
/   Matches:        4       5         6
/   Therefore:    i=4     j=3       k=5

s i  0   = i               / Sum: is defined recursively        s i j ≡≡ i+j
s i (+j) = +(s i j)        / in terms of successor and sum.

s 2 3                      / sum of 2 and 3.
5
p i  0   = 0               / Product: is defined recursively    p i j ≡≡ i×j
p i (+j) = s (p i j) i     / in terms of sum and product.

p 2 3                      / product of 2 and 3.
6
e i  0   = 1               / Exponent is defined recursively    e i j ≡≡ i*j
e i (+j) = p (e i j) i     / in terms of product and exponent.

e 2 3                      / 2-to-the-power-3
8
d i j = s (p (+9) i) j     / Decimal decode.                 d i j ≡≡ 10⊥i j

d(d12)3                    / One hundred and twenty three.
123
l   0    0  = 0            / Less than:                         l i j ≡≡ i<j
l   0  (+j) = 1
l (+i)   0  = 0
l (+i) (+j) = l i j

l 2 3
1
c 1 t f = t                / Condition: t or f depending on the value of the
c 0 t f = f                / first argument. Note: t and f may be functions.

m i j = c (l i j) j i      / Maximum:                           m i j ≡≡ i⌈j

m 2 3
3

/ A  function applied to fewer than its defined number of arguments yields a new
/ function  of the remaining ones. This phenomenon known as "currying" after the
/ American logician Haskell Curry, was discovered by Schönfinkel in 1924 follow-
/ ing an idea by Frege in 1893:

q = p 4                    / quadruple.

q 3
12
y = l 0                    / Alternative signum using less than.

y 0
0
y 3
1

/ Note  that  as  function application associates left, currying occurs with any
/ function of more than one argument. Using sum defined above:

s 2 3                       / sum 2 3 is interpreted as:
5
(s 2) 3                     / (sum 2) 3
5

/ We can trace the evaluation of an expression by appending a semicolon.

t+0;
SBI+0
¯¯¯¯
B+(I+)0
¯¯¯¯¯¯¯
+(I+0)
¯¯
+(+0)
¯¯
+1
¯¯
2

/ Min has two system commands:
/
/   ~ removes definition(s) and displays remaining ones.
/   ) exits from the min session returning the current set of definitions.

~                           / Display definitions.
i f t n x s p e d l c m q y
~ifq                        / Remove: i, f, and q.
t n x s p e d l c m y
)                           / Quit.

Back to: contents
```