https://github.com/synrc/shen
🐉 SHEN: Erlang JavaScript Compiler
https://github.com/synrc/shen
Last synced: 10 months ago
JSON representation
🐉 SHEN: Erlang JavaScript Compiler
- Host: GitHub
- URL: https://github.com/synrc/shen
- Owner: synrc
- License: isc
- Created: 2013-07-20T00:48:24.000Z (almost 13 years ago)
- Default Branch: master
- Last Pushed: 2021-02-04T16:20:54.000Z (over 5 years ago)
- Last Synced: 2024-04-14T04:22:45.213Z (about 2 years ago)
- Language: Erlang
- Homepage:
- Size: 73.2 KB
- Stars: 234
- Watchers: 28
- Forks: 29
- Open Issues: 2
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
SHEN: Erlang JavaScript Compiler
================================
Simple
Libraries
---------
We support following stack by Erlang JavaScript compiler:
* matches.js -- Erlang-like matching syntax
* tailrec.js -- optimize tail calls
* beacon.js -- FRP event streaming
The only real practical fast solution is to translate Erlang AST into JavaScript
using JavaScript helpers like matches.js and tailrec.js.
Usage
-----
* Compilation to JavaScript, node.js, Browser, Client-Side FRP
* Macros, String Templates, Embedding Mode, Server-Side, N2O
Compilation to Pure JavaScript
------------------------------
In case of Client-Logic, Off-line clients, Client-side FRP Event System
use can export you functions in module with -js attribute.
All function will be stored to the same filename with js extension.
fac.erl:
```erlang
-module(fac).
-compile({parse_transform, shen}).
-compile(export_all).
-js([start/0,fac/1]).
start() ->
N = fac(5),
console:log("factorial ~p", [J, N]).
fac(0) -> 1;
fac(N) -> N * fac(N-1).
```
Compile with Erlang:
$ erlc shen.erl
$ erlc -pa . fac.erl
And you will get fac.js:
```javascript
var pattern = require("matches").pattern;
var start = pattern({
'': function() {
j = 5;
n = fac(j);
return console.log('factorial ~p',[j,[n,[]]]);
}});
var fac = pattern({
'0': function(x1) {
return 1;
},
'n': function(n) {
return n * fac(n - 1);
}});
start();
```
Now you can check:
$ node fac.js
factorial ~p [ 5, [ 120, [] ] ]
JavaScript Macros
-----------------
Let say we want to generate JavaScript in our Erlang code which is very useful
for Server-Logic Event System, so you can write programs in Erlang and expand
them into JavaScript using -jsmacro attribute. Specified functions will be
expanded to JavaScript during compilation.
```erlang
-module(fac).
-compile({parse_transform, shen}).
-compile(export_all).
-jsmacro([macro/3]).
macro(A,B,C) ->
ws:send('Bert':encodebuf(
[{source,'Bert':binary(A)},
{x,C},
{pickle,'Bert':binary(B)},
{linked,C}])).
main() ->
A = "1",
B = "2",
Script = macro(A,B,"3"),
io:format("JS Macro: ~s",[Script]).
```
Lets try it:
7> fac:main().
JS Macro: ws.send(Bert.encodebuf({source:Bert.binary(1),x:3,pickle:Bert.binary(2),linked:3}));
ok
Roadmap
-------
1. multiple clauses for lambdas
2. list comprehensions
3. more JavaScript/OTP mappings
4. if statement :-)
Credits
-------
* Maxim Sokhatsky
* Andrew Zadorozhny
OM A HUM