summaryrefslogtreecommitdiff
path: root/README.md
blob: 636468fd8f1132812b55d4246450764b0d583489 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
Welcome to lambda2js
====================

Before you get any further: lambda2js is mainly a fun project.
So if you are not in the mood simply leave as it is not for you.

If you need something serious, try [PureScript](http://www.purescript.org/),
[Haste](http://haste-lang.org/), [elm](http://elm-lang.org/),
or [Fay](https://github.com/faylang/fay/wiki).

As you can guess just by looking at the name, lambda2js is compiler
that takes simple syntactically sugared untyped lambda calculus and produces
JavaScript code. Though this project is meant as fun, it actually works.

Lambda2js is open source (licensed under GPL-3) and patches are welcome.

Motivation
----------

Have you ever found yourselves writing JavaScript code and thinking:
"Oh my... How nice would it be to have this function with flipped arguments.
And now I have to write wrapper function, or at least some anonymous function
that will do what I need. In functional language I would simply use
`flip` and that would be it!" Well, now it is your time as lambda2js
was brought to light.

Example
-------

In examples you can find [simple example](examples/example.ulc),
that will get compiled into

~~~ { .javascript }
K = function(x){return function(y){return x}}
S = function(f){return function(g){return function(x){return f(x)(g(x))}}}
I = S(K)(K)
Dot = function(f){return function(g){return function(x){return f(g(x))}}}
Flip = function(f){return function(x){return function(y){return f(y)(x)}}}
True = K
Not = Flip
False = Not(True)
If = I
Zero = function(s){return function(z){return z}}
Succ = function(n){return function(s){return function(z){return n(s)(s(z))}}}
IsZero = function(n){return n(K(False))(True)}
Add = function(m){return function(n){return function(s){return function(z){return m(s)(n(s)(z))}}}}
Mul = function(m){return function(n){return function(s){return function(z){return m(n(s))(z)}}}}
Pow = function(m){return function(n){return function(s){return function(z){return n(m)(s)(z)}}}}
One = Succ(Zero)
Two = Succ(One)
Three = Succ(Two)
Tup = function(x){return function(y){return function(p){return p(x)(y)}}}
Fst = function(t){return t(K)}
Snd = function(t){return t(Flip(K))}
Fac = function(n){return Snd(n(function(t){return t(function(x){return function(y){return Tup(Succ(x))(Mul(x)(y))}})})(Tup(One)(One)))}
~~~~

which is fully functional (pun intended) JavaScript. It can be played with:
combined with small [helper library for seamless integration](examples/helper.js),
one can compute `(2+3)!`.

~~~ { .javascript }
alert(funToInt(Fac(Add(Two)(Three))))
~~~

Flipping arguments can be as simple as

~~~ { .javascript }
alert(uncurry2(Flip(curry2(Math.pow)))(2,3))
~~~

...and much more.

Origin
------

I was playing with JavaScript the other day, pondering higher functions.
Trying the usual stuff like [Church numerals](http://en.wikipedia.org/wiki/Church_encoding)
and other. I found myself under avalanche of JavaScript
boilerplate. Just compare `function(x){return x}` and `\ x . x`.

And then it occurred to me: this can be easily automated! I can
write code I like and get code I need. So I sat down to my console
and in just couple of moments I came up with 10 commandm\^W\^Wthis little
project. Enjoy.