earlgrey
Version:
Programming language compiling to JavaScript, featuring macros, dynamic typing annotations and pattern matching.
131 lines (100 loc) • 3.97 kB
Markdown
Earl Grey
=========
[](https://gitter.im/breuleux/earl-grey?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
Earl Grey ([website](http://earl-grey.io)) is a new
language that compiles to JavaScript (ES6). Here's a quick rundown of
its amazing features:
* Python-like syntax
* Fully compatible with the node.js ecosystem
* Generators and async/await (no callback hell!)
* Powerful, deeply integrated pattern matching
* Used for assignment, function declaration, looping, exceptions...
* A DOM-building DSL with customizable behavior
* A very powerful hygienic macro system!
* Define your own control structures or DSLs
* Macros integrate seamlessly with the language
* Macro libraries! Test with
[earl-mocha](https://github.com/breuleux/earl-mocha),
build with [earl-gulp](https://github.com/breuleux/earl-gulp),
make dynamic pages with
[earl-react](https://github.com/breuleux/earl-react), etc.
* And much more!
Resources
---------
* [Website](http://earl-grey.io/)
* [Installation instructions](http://earl-grey.io/use.html)
* [Documentation](http://earl-grey.io/doc.html)
* [Editor support](http://earl-grey.io/tooling.html)
* [Contributing](http://earl-grey.io/contrib.html)
* [Try it here!](http://earl-grey.io/repl.html)
Examples
--------
Counting all words in a block of test. Note that `count-words` is a
variable name, not a subtraction (it is equivalent to the name
`countWords`, if that's the notation you prefer).
count-words(text) =
counts = new Map()
words = text.split(R"\W+")
words each word ->
current-count = counts.get(word) or 0
counts.set(word, current-count + 1)
consume(counts.entries()).sort(compare) where
compare({w1, c1}, {w2, c2}) = c2 - c1
`{x, y, ...}` is the notation for arrays in Earl Grey. Objects are
denoted `{field = value, field2 = value2, ...}`
**Generators**: the following defines a generator for the Fibonacci
sequence and then prints all the even Fibonacci numbers less than
100. It shows off a little bit of everything:
gen fib() =
var {a, b} = {0, 1}
while true:
yield a
{a, b} = {b, a + b}
fib() each
> 100 ->
break
n when n mod 2 == 0 ->
print n
The `each` operator accepts multiple clauses, which makes it especially
easy to work on heterogenous arrays.
**Asynchronous**: EG has `async` and `await` keywords to facilitate
asynchronous programming, all based on Promises. Existing
callback-based functionality can be converted to Promises using
`promisify`:
require: request
g = promisify(request.get)
async getXKCD(n = "") =
response = await g('http://xkcd.com/{n}/info.0.json')
JSON.parse(response.body)
async:
requests = await all 1..10 each i -> getXKCD(i)
requests each req -> print req.alt
**Classes**:
class Person:
constructor(name, age) =
@name = name
@age = age
advance-inexorably-towards-death(n > 0 = 1) =
@age += n
say-name() =
print 'Hello! My name is {@name}!'
alice = Person("alice", 25)
**Pattern matching** acts like a better `switch` or `case`
statement. It can match values, types, extract values from arrays or
objects, etc.
match thing:
0 ->
print "The thing is zero"
< 0 ->
print "The thing is negative"
R"hello (.*)"? x ->
;; note: R"..." is a regular expression
print 'The thing is saying hello'
Number? x or String? x ->
print "The thing is a number or a string"
{x, y, z} ->
print 'The thing is an array of three things, {x}, {y} and {z}'
{=> name} ->
print 'The thing has a "name" field'
else ->
print "I don't know what the thing is!"