/ 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