Lambda-Lite-js
a tiny FUNCITONAL LANGUAGE implemented by javascript.
online demo: https://moevis.github.io/lambda-lite-js/ (中文版)
Support
- Lambda function (including sugar for declearing multi-parameters function)
- currying, lazy evaluation, recursive in anonymous function (z combinator)
- Basic pattern matching
- Point-free style: compose function together with
.
- Basic type system: bool, number, list, function and string.
Tutorial
Lambda function
Using backsplash and arrow to declear an anyoumous function. Lambda function only accept one parameter, but you can use some magic method to break this limit.
\n -> n + 1;
\n -> n * n;
\n -> n + n * n;
Creating function which accepts two parameters.
(\n -> \m -> m + n) 1 2 --- output: 3
Now, declear a function with single-param or multi-params can be write as below:
let add x y = x + y
let result = add 1 2
Pattern matching
Pattern matching is an useful feature in some functional language. The ll language has a basic pattern matching implements.
let func a@1 = a + 1;
let func a@2 = a + 2;
print (func 2);
let echo a@Number = print 'Number';
let echo a@String = print 'String';
let echo a@* = print 'Other';
echo 'this is string';
echo true;
Pattern matching has some limits in ll.js .
- The all parameters should be in the same order.
- The lengths of the functions which have same name also should be equal.
- Every parameter should have a pattern declearation like
Number
,String
,Boolean
, or*
for other types. - Matching progress is from top to bottom, from left to right.
Various declaration
The keyword let
leads an assignment, in forms of let ... = ... (-> ...)
. The symbol ->
is options, only if you want return a value.
let x = 5;
let y = \n -> n + 1;
let z = let a = 3 -> a * a;
Binary condition
The binary condition is in form of if ... then ... else ...
.
print (if true then 1 else 0)
Native function
now some native functions are accessiable. As well as the basic calculation operators: +-*/
.
print "hello";
print (length [1,2,3,4]);
print (reverse [1,2,3,4]);
print [1,2,3,4] !! 2;
print (not true);
Recursive calling
Recursive programming is an elegant programming style.
let fact = \n ->
if n == 1 then 1
else n * (fact n - 1);
print (fact 5);
Lambda function can recursive by using z-combinator instead of calling itself.
let z = \f->(\x -> f (\y -> x x y)) (\x -> f (\y -> x x y));
let makeFact = \g -> \n -> if n < 2
then 1
else n * (g n - 1);
let fact = z makeFact;
print (fact 5);
Point-free programming
Use .
and $
to pretifier your code, less brackets
now !!!
Beblow is a sample for calculating (10 + 10) ^ 2
let double = \n -> n + n;
let square = \n -> n * n;
print $ double $ square 10;
let func = double . square;
print $ func 10;
Play with Church Number
let True x y = x;
let False x y = y;
let Zero f x = x;
let One f x = f x;
let Two f x = f (f x);
let Three f x = f (f (f x));
let Add a b f x = a f (b f x);
let Mul a b f x = a (b f) x;
print $ Two (\n -> n + 1) 0;
print $ Add One Two (\n -> n + 1) 0;
print $ Mul Two Three (\n -> n + 1) 0;