Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/viclib/LiScript

Fully-featured, blazingly-fast language that compiles to beautiful, hand-made-like JavaScript. Implemented in less than 100 lines.
https://github.com/viclib/LiScript

Last synced: about 1 month ago
JSON representation

Fully-featured, blazingly-fast language that compiles to beautiful, hand-made-like JavaScript. Implemented in less than 100 lines.

Awesome Lists containing this project

README

        

# LiScript
LiScript replaces JavaScript's syntax by lisp's powerful S-Expressions and macro system.

Differently from other languages that compile to JavaScript, it does not try to make it a completely different language - which is the root of many common problems such as messy generated code, overheads, painful compilation and hard debugging - all of which compensate for the theoricall benefits. Instead, as very thin layer - the whole implementation being less than 100 lines - it's generated code is **fast, readable, beautiful, zero-overheaded, workeable and easy to debug**.

In summary, it's a programming language that combines JavaScript's high level features, ridiculous cross-platformness and blazing speed with lisp's awesome, powerful syntax loved by hackers all around the world. For more info on it, I recommend reading Paul Graham's "Beating the Averages": http://www.paulgraham.com/avg.html

#### Installation
There's no installation guide yet (this will be updated soon). For now, just download LiScript, require the file on node.s or include it in a HTML script tag and call `LiScript.compile("(your source code)")`. This will return the compiled JavaScript.

**You can also try it online: http://evanhahn.github.com/Try-LiScript/**

#### Tutorial / Using
Using LiScript is very easy. I'll expose the whole language with examples. If you find trouble understanding those, you could may on S-Expressions. Looking at the source could be a good idea. Also, feel free to contact me! Notice that this is the crude form of the language - to actually use it you'll certainly load with macros which will calibre the syntax to fill your needs. The language core is very easy. It has 4 basic forms, which map directly to their JavaScript counterparts:
* String: `"this is a string"`
* Array: `["this" "is" "an" "array"]`
* Object: `{foo 5 bar 7}`
* Function/macro calling: `(func 1 2 3)`

It also comes with the following functions out-of-the-box:

* Math operators: `sum sub mul div mod`
```
(sum 1 2 3 (mul 2 2))
Output: 10
```

* Boolean comparisons: `and or eq dif less greater lesseq greatereq`
```
(eq 2 2)
Output: true
```

* Assignment: `def`
```
(def foo 5)
This is the same as "foo = 5" in JavaScript.
```

* Conditional: `if`
```
(def rnd (Math.random))
(if (less rnd 0.05)
(console.log "You won :D")
(console.log "Bad luck, try again."))
Output: ?
```

* Function definition: `fn`
```
(fn (a b) (sum a b))
Output: function(a,b){ return a+b; };
```

* Member access: `get set`
```
(def my_obj {a 1 b 2 c 3})
(set my_obj "b" 4)
(console.log (get my_obj "b"))
Output: 4
```

* Loop: `while`
```
(def i 0)
(while (less i 4)
(console.log i)
(def i (sum i 1)))
Output: 0 1 2 3
```

* Iteration: `iter`
```
(iter {a 1 b 2 c 3}
(console.log [key val]))
Output: ["a",1] ["b",2] ["c",3]
```

* Macro: `defmacro`
Macros work by modifying the code **before** it's compiled to JavaScript. and it couldn't be easier: just return an array of strings representing the new form of your code! Let's make a macro that inverts an expression:
```
(defmacro swap (a b) [b a])
(swap "test" console.log)
This becomes `(console.log "test")` which outputs `"test"`!
```
Another example:
```
(defmacro unless (cond T F) ["if" cond F T])
(def yell (fn (a) (call a "toUpperCase")))
(def im_sad false)
(unless im_sad (yell "What a great day!"))
Output: "WHAT A GREAT DAY!"
```
This is an interesting fact about Lisp: clever user of macros can make the language sound just like speech. There's no syntax: just a bunch of phrases that tell your program what to do. Sometimes it's too abstracted away you don't even notice you are programming: `(make me a sandwitch in 2 hours)`, one could perfectly make this work. Lisp code from a great hacker is a piece of art. But maybe you're the type that likes terse syntax and symbols? No problems...

* Readers: `defreader`
Readers are similar to macros, except they work for special forms (not parenthesis). Readers on LiScript are a little different: you just define a name and enclosing symbols. You can, then, further process it with normal macros. For example, lets define the form < a > to return the square of a:
```
(defreader square < >)
(defmacro square (a) (mul a a))
(console.log <3>)
The form above becomes (console.log (square 3)),
which becomes (console.log (mul 3 3)),
which becomes (console.log 9),
which outputs 9.
```
That is much simpler than traditional reader macros! For more advanced cases you can just edit the parser itself: it's a 25-lines-long function on the source, so it shouldn't be hard. Given how no other lisp-to-js language implement reader macros at all, it's pure win.

Well, that's it! This is the whole language. Again, the out-of-the-box package must be temperated with macros. For example, you could certainly improve the loops - a "for" macro could work as CoffeeScript's array comprehension. A "let" macro might prove handy, and a facility to concatenate arrays would make defining new macros easier. The point is: LiScript allows you to do whatever you want; you control the language!

#### Next steps:
LiScript is just a first step towards a goal: increasing programmer productivity to new levels. There is still needs some work - for example, "var x=3" is not an expression in JavaScript. Because of this, all variables are defined on the global scope. I'm thinking in a solution for this. Anyway, the idea is reaching a point of stability where the language doesn't need to be ever changed anymore, making it future-proof. At this point, efforts must be done towards the concretization of:

1. A centralized, cloud-based, taggeable, computer-analyzable, queriable database of functions and macros (NOT libraries!)

2. A powerful, shortcut-optimized, VIM inspired, web-based IDE to access those.

3. A huge community with a good communication system. (this is the hard part ;/)

If this all interests you, feel free to contact me!