Loop is a scheme-ish language which compiles to javascript.
It's javascript, but with parentheses (and hence hygenic macros).
This is still super-alpha software. Don't use it!
node
npm
git submodule update --init
npm install -g jake
npm install -g jison
npm install -g mocha
jake deps
Install dependencies, (as above), and run:
jake
Proposed syntax:
7 => 7
"foo" => "foo"
'foo' => 'foo'
[1,2,3] => ([] 1 2 3) (syntactic sugar: [1 2 3] or [1,2,3] or [1,2,3,])
{ a: 'b', c: 'd' } => ({} a 'b' c 'd') (syntactic sugar: { a 'b' c 'd' } or { a 'b', c 'd'} or { a 'b', c 'd',})
foo => foo
foo() => (foo)
function() { x + x } => (function () (+ x x))
=> (lambda () (+ x x))
x = 10 => (= x 10)
var x = 10 => (var (x 10))
=> (define x 10)
var x, => (var (x)
y = 20 (y 20))
foo.bar => foo.bar
foo.bar = 10 => (= foo.bar 10)
foo['bar'] => ([] foo 'bar')
foo['bar'] = 10 => (= ([] foo 'bar') 10)
foo.bar() => (foo.bar)
foo = {} => (= foo {})
[1,2,3,4] => [ 1 2 3 4 ]
x[2] => ([] x 2)
a && b => (&& a b)
a || b => (|| a b)
/a.*b/ => /a.*b/
new Object(1,2,3) => (new Object 1 2 3)
if (x) { y() } => (if x
(y))
if (x) { y() } => (if x)
else { z(); } (y)
(z))
if (a) { => (cond (a (b))
b(); (c (d))
} else if (c) { (else (e)))
d();
} else {
e();
}
// foo => // foo
(notes on if:
- it can only be used with an else - it can't be used in an else if construction
- if and else statements must have only one expression.
Essentialy, it's just a shorthand for a 'cond')
switch (foo.bar) { => (switch foo.bar
case 'one': (case 'one'
console.log('one'); (console.log 'one')
break; (break))
default: (default
console.log('default'); (console.log 'default)))
}
Macros follow the conventions behind scheme's define-syntax / syntax-case. For instance, here's let:
(define-macro
(let ((key value) ...)
body ...)
((function (key ...)
body ...) value ...)
Which would take:
(let ((x 10)
(y 20))
(console.log (+ x y)))
and expand it (at compilation time) into:
(function (x, y) {
console.log(x + y);
})(10, 20);