CodeMirror: Lambda Calculus mode

# Ignored arguments
false = \ _a b . b
true = \ a _b . a
not = \ b . b false true
const = true

# Multiple definition
true = not false

# Invalid whitespace (tabs)
whitespace	=	()

# Bare lambda
(\ f x . f (x x))

# Bare term
const f x

# Symbols
< a b c >  => < a a a >

# Unbound
some-func = \ local . true non-existent local

# Out of scope args
other-func = \ x . const (\ scoped-arg . x ()) scoped-arg x

# Debug mode on
#debug

# Invalid names - Debug
%value = ()

# Bare lambda - Debug
(\ f x . f (x x))

# Bare term - Debug
const f x

# Symbols - Debug
< a b c >  => < a a a >

# Unbound - Debug
some-func = \ local . true non-existent local

# Out of scope args - Debug
other-func = \ x . const (\ scoped-arg . x ()) scoped-arg x

# Debug mode off
#debug

# More code
zero = false
succ = \ n f x . f (n f x)
is-z = \ n . n (const false) true
add = \ a b f x . a f (b f x)
mul = \ a b f . a (b f)
three = succ (succ (succ zero))
mt = mul three
nine = mul three three

pair = \ a b c . c a b
fst = \ c . c true
snd = \ c . c false

nil = pair false ()
null = \ l . not (fst l)
head = \ l . fst (snd l)
tail = \ l . snd (snd l)
cons = \ x xs . pair true (pair x xs)
replicate = \ n v . n (cons v) nil
repeat = \ v . cons v (repeat v)
foldr = \ f b as . null as b (f (head as) (foldr f b (tail as)))
pred = \ n f x . foldr (const f) x (tail (replicate n ())) # Bit janky lol
map = \ f xs . null xs nil (cons (f (head xs)) (map f (tail xs)))
sum = foldr add zero
drop = \ n . n tail
take = \ n xs . is-z n nil (cons (head xs) (take (pred n) (tail xs)))
col = \ n xs . head (drop n xs)
colS = \ n xs . cons (col n xs) (cons (col (succ n) xs) (cons (col (succ (succ n)) xs) (nil)))
row = \ n xs . map (col n) xs
row-s = \ n xs . cons (row n xs) (cons (row (succ n) xs) (cons (row (succ (succ n)) xs) (nil)))
chunk = \ a b xs . row-s a (colS b xs)
append = \ as bs . null as bs (cons (head as) (append (tail as) bs))
concat = foldr append nil
eq? = \ a b . is-z a (is-z b) (is-z b false (eq? (pred a) (pred b)))
all = foldr (\ a b . a b false) true
allf = \ f xs . all (map f xs)

{{ result }} {{ error }}

Options

purity numEncoding verbosity