Anemone

Anemone is an implemented (see talk page), Turing-complete (see proof) language by User:Afarnen which builds upon combinatory logic, pattern recognition, algebraic data types, and similar concepts.
== Syntax, semantics ==
The syntax of a term (expression):
* If a is an atom, then 'a' is a term. Atoms are the basic units of a term.
* If X and Y are terms, then '(X Y)' is a term. This is called "application". Here X is applied to Y.
Application is left-associative, so '(X Y) Z' can be written as 'X Y Z'.
However, reduction of terms has not been defined. There is no "abstraction" as there is in the Lambda Calculus--instead, a program is made up of a series of "reduction rules" which take the form:
 <rule> ::= <left-term> '=' <right-term> '.'
which reads as "<left-term> reduces to <right-term>." A single step of computation is a single reduction according to one such rule. The reduction strategy is call-by-value, where the outer-most reducible term is reduced.
Rules are applied (attempted to be applied) in the order they are written (left->right), unlike languages such as Thue in which this is non-deterministic.
Unlike a Matrioshka language, you do not actually define, in the program, the initial term which is to be reduced. Instead, an interactive interpreter repeatedly asks the user for a term, which is printed back to the user after being reduced according to the loaded program(s).
=== A simple example ===
For example, one way to write Boolean AND and OR is:
 and t t = t.
 and t f = f.
 and f t = f.
 and f f = f.
 
 or t t = t.
 or t f = t.
 or f t = t.
 or f f = f.
=== Variables ===
We employ "variables" in our reduction rules as wild cards to take the place of a single term. For instance, we can shorten our implementations of Boolean AND and OR, and even make them short-circuit:
 and t X = X.
 and f X = f.
 
 or t X = t.
 or f X = X.
To distinguish atoms from variables, a variable must start with an uppercase, and an atom must not. Neither atoms nor variable names may include white-space, equals signs, periods, or parentheses.
=== Equal terms, order of rules ===
The following defines the predicate "equals":
 eq X X = t.
 eq X Y = f.
This works because the first rule uses the same variable name twice, meaning that eq must be applied to two equivalent terms.
Also, the order in which the rules are written is important. If we changed the order of these two rules, "equals" would always return false, which isn't correct. For this reason, rules will typically be written in the order more specific->less specific.
== Examples ==
This section includes implementations of common calculi, data types and functions, as well as example "test runs" which show how a term would reduce given a set of rules.
=== SKI combinator calculus ===
The following is a complete implementation of SKI combinator calculus, which is Turing-complete.
 s X Y Z = X Z (Y Z).
 k X Y = X.
 i X = X.
==== Test runs ====
Self application:
 (s i i) a
 i a (i a)
 a (i a)
 a a
Reversal:
 (s (k (s i)) k) a b
 (k (s i)) a (k a) b
 (s i) (k a) b
 i b ((k a) b)
 b ((k a) b)
 b a
=== B, C, K, W ===
 b X Y Z = X (Y Z)
 c X Y Z = X Z Y
 k X Y = X
 w X Y = X Y Y
=== cons, car, cdr, map ===
The following implements cons, written 'cons X Y', and the related functions car, cdr and map. Map recursively applies a given term to every leaf in a binary tree (cons).
 car (cons X Y) = X.
 cdr (cons X Y) = Y.
 
 map T (cons X Y) = cons (map T X) (map T Y).
 map T X = T X.
==== Test runs ====
Get the third element out of a list:
 car (cdr (cdr (cons a (cons b (cons c (cons d (cons e)))))))
 car (cdr (cons b (cons c (cons d (cons e)))))
 car (cons c (cons d (cons e)))
 c
Boolean NOT every element in a list:
 map not (cons t (cons f (cons t (cons t f))))
 cons (map not t) (map not (cons f (cons t (cons t f))))
 cons (not t) (map not (cons f (cons t (cons t f))))
 cons f (map not (cons f (cons t (cons t f))))
 cons f (cons (map not f) (map not (cons t (cons t f))))
 cons f (cons (not f) (map not (cons t (cons t f))))
 cons f (cons t (map not (cons t (cons t f))))
 cons f (cons t (cons (map not t) (map not (cons t f))))
 cons f (cons t (cons (not t) (map not (cons t f))))
 cons f (cons t (cons f (map not (cons t f))))
 cons f (cons t (cons f (cons (map not t) (map not f))))
 cons f (cons t (cons f (cons (not t) (map not f))))
 cons f (cons t (cons f (cons f (map not f))))
 cons f (cons t (cons f (cons f (not f))))
 cons f (cons t (cons f (cons f t)))
=== Natural numbers and common functions ===
The following program is the natural numbers, as well as some common functions on them.
 + X 0 = X.
 + X (s Y) = s (+ X Y).
 
 * X 0 = 0.
 * X (s Y) = + X (* X Y).
 
 fib 0 = s 0.
 fib (s 0) = s 0.
 fib (s (s X)) = + (fib (s X)) (fib X).
 
 fact 0 = s 0.
 fact (s X) = * (s X) (fact X).
==== Test runs ====
The sixth Fibonacci number:
 fib (s (s (s (s (s 0)))))
 + (fib (s (s (s (s 0))))) (fib (s (s (s 0))))
 + (+ (fib (s (s (s 0)))) (fib (s (s 0)))) (fib (s (s (s 0))))
 + (+ (fib (s (s (s 0)))) (fib (s (s 0)))) (+ (fib (s (s 0))) (fib (s 0)))
 + (+ (+ (fib (s (s 0))) (fib (s 0))) (fib (s (s 0)))) (+ (fib (s (s 0))) (fib (s 0)))
 + (+ (+ (fib (s (s 0))) (fib (s 0))) (+ (fib (s 0)) (fib 0))) (+ (fib (s (s 0))) (fib (s 0)))
 + (+ (+ (fib (s (s 0))) (fib (s 0))) (+ (fib (s 0)) (fib 0))) (+ (+ (fib (s 0)) (fib 0)) (fib (s 0)))
 + (+ (+ (fib (s (s 0))) (fib (s 0))) (+ (fib (s 0)) (fib 0))) (+ (+ (fib (s 0)) (fib 0)) (s 0))
 + (+ (+ (fib (s (s 0))) (fib (s 0))) (+ (fib (s 0)) (fib 0))) (s (+ (+ (fib (s 0)) (fib 0)) 0))
 s (+ (+ (+ (fib (s (s 0))) (fib (s 0))) (+ (fib (s 0)) (fib 0))) (+ (+ (fib (s 0)) (fib 0)) 0))
 s (+ (+ (+ (fib (s (s 0))) (fib (s 0))) (+ (fib (s 0)) (fib 0))) (+ (fib (s 0)) (fib 0)))
 s (+ (+ (+ (fib (s (s 0))) (fib (s 0))) (+ (fib (s 0)) (fib 0))) (+ (s 0) (fib 0)))
 s (+ (+ (+ (fib (s (s 0))) (fib (s 0))) (+ (fib (s 0)) (fib 0))) (+ (s 0) (s 0)))
 s (+ (+ (+ (fib (s (s 0))) (fib (s 0))) (+ (fib (s 0)) (fib 0))) (s (+ (s 0) 0)))
 s (s (+ (+ (+ (fib (s (s 0))) (fib (s 0))) (+ (fib (s 0)) (fib 0))) (+ (s 0) 0)))
 s (s (+ (+ (+ (fib (s (s 0))) (fib (s 0))) (+ (fib (s 0)) (fib 0))) (s 0)))
 s (s (s (+ (+ (+ (fib (s (s 0))) (fib (s 0))) (+ (fib (s 0)) (fib 0))) 0)))
 s (s (s (+ (+ (fib (s (s 0))) (fib (s 0))) (+ (fib (s 0)) (fib 0)))))
 s (s (s (+ (+ (+ (fib (s 0)) (fib 0)) (fib (s 0))) (+ (fib (s 0)) (fib 0)))))
 s (s (s (+ (+ (+ (fib (s 0)) (fib 0)) (s 0)) (+ (fib (s 0)) (fib 0)))))
 s (s (s (+ (s (+ (+ (fib (s 0)) (fib 0)) 0)) (+ (fib (s 0)) (fib 0)))))
 s (s (s (+ (s (+ (fib (s 0)) (fib 0))) (+ (fib (s 0)) (fib 0)))))
 s (s (s (+ (s (+ (fib (s 0)) (fib 0))) (+ (s 0) (fib 0)))))
 s (s (s (+ (s (+ (fib (s 0)) (fib 0))) (+ (s 0) (s 0)))))
 s (s (s (+ (s (+ (fib (s 0)) (fib 0))) (s (+ (s 0) 0)))))
 s (s (s (s (+ (s (+ (fib (s 0)) (fib 0))) (+ (s 0) 0)))))
 s (s (s (s (+ (s (+ (fib (s 0)) (fib 0))) (s 0)))))
 s (s (s (s (s (+ (s (+ (fib (s 0)) (fib 0))) 0)))))
 s (s (s (s (s (s (+ (fib (s 0)) (fib 0)))))))
 s (s (s (s (s (s (+ (s 0) (fib 0)))))))
 s (s (s (s (s (s (+ (s 0) (s 0)))))))
 s (s (s (s (s (s (s (+ (s 0) 0)))))))
 s (s (s (s (s (s (s (s 0)))))))
The factorial of three:
 fact (s (s (s 0)))
 * (s (s (s 0))) (fact (s (s 0)))
 * (s (s (s 0))) (* (s (s 0)) (fact (s 0)))
 * (s (s (s 0))) (* (s (s 0)) (* (s 0) (fact 0)))
 * (s (s (s 0))) (* (s (s 0)) (* (s 0) (s 0)))
 * (s (s (s 0))) (* (s (s 0)) (+ (s 0) (* (s 0) 0)))
 * (s (s (s 0))) (* (s (s 0)) (+ (s 0) 0))
 * (s (s (s 0))) (* (s (s 0)) (s 0))
 * (s (s (s 0))) (+ (s (s 0)) (* (s (s 0)) 0))
 * (s (s (s 0))) (+ (s (s 0)) 0)
 * (s (s (s 0))) (s (s 0))
 + (s (s (s 0))) (* (s (s (s 0))) (s 0))
 + (s (s (s 0))) (+ (s (s (s 0))) (* (s (s (s 0))) 0))
 + (s (s (s 0))) (+ (s (s (s 0))) 0)
 + (s (s (s 0))) (s (s (s 0)))
 s (+ (s (s (s 0))) (s (s 0)))
 s (s (+ (s (s (s 0))) (s 0)))
 s (s (s (+ (s (s (s 0))) 0)))
 s (s (s (s (s (s 0)))))
Category: 2010
Category: Languages
Category: Meta-languages
Category: Turing complete
Category: Implemented
Category: Functional paradigm