Ion is a little language that compiles to JavaScript. It doesn't try to be completely different than JavaScript, but it attemps to strip it to the minimal set of functional features of the language, while extending it to have some more. It relies heavily on libraries supporting Fantasy Land, such as Ramda, Santuary and Folktale
The following example is a solution to the "async problem", using the same tools behind the scenes as the task solution.
path = require('path')
read = path.resolve
| fs.readFile
| map(toString)
| map(split('\n'))
| map(map(fs.readFile))
| chain(task.waitAll)
| map(map(toString))
| map(join(','))
| map(put)
read('./index.txt').mapRejected(put).run()
- Improved type detection and comparisons;
- All variables are
const
s; - All functions are curried;
- Blocks can have only one expression, and this is returned by default;
- Ramda is treated as the stdlib;
- Operators are seen as functions;
- Range type (only for integers so far);
- Some new operators:
->
,|
,@
,**
and more; where
construct;
Things removed:
this
,class
and all things OO;function
: only lambdas;typeof
: use onlytype
function;switch/case
: usecond
function;try/catch
: usetryCatch
function orResult
;- All mutable ops, like
-=
,*=
,++
...; - All 3 char ops, like
===
,!==
; - Many unknown JS features, like
>>
,>>>
;
// JS | // Ion
typeof null | type(null)
// 'object' | // 'Null'
typeof [] | type([])
// 'object' | // 'Array'
typeof {} | type({})
// 'object' | // 'Object'
typeof /a/ | type(/a/)
// 'object' | // 'Regexp'
// JS | // Ion
1 == "1" | 1 == "1"
// true | // false
NaN == NaN | NaN == NaN
// false | // true
[] == [] | [] == []
// false | // true
{} == {} | {} == {}
// false | // true
/a/ == /a/ | /a/ == /a/
// false | // true
// JS | // Ion
const age = 22 | age = 22
let age = 22 | // check "where" below
var age = 22 | // check "where" below
sayTo = (greet, name) =>
`${greet}, ${name}!`
sayTo('Hello', 'John') // 'Hello, John!'
sayTo('Hello')('John') // 'Hello, John!'
sayHelloTo = sayTo('Hello')
sayHelloTo('John') // 'Hello, John'
age = 22
status = if(age >= 18)
'adult'
else
'minor'
addFive = (n) => n + 5
map((a) => a + 1, [1, 2, 3]) // => [2, 3, 4]
map(+(1), [1, 2, 3]) // => [2, 3, 4]
map(+(1), [1..3]) // => [2, 3, 4]
// `<-` is map
+(1) <- [1..3] // => [2, 3, 4]
// `|` is pipe (sorta like in bash)
add2AndThenMult3 = +(2) | *(3)
add2AndThenMult3(1) // => 9
// `@` gets attribute of object, may be deep
'name' @ {name: 'John'} // => 'John'
['movies', 0, 'name'] @ {movies: [{name: 'Rambo'}, ...]} // => 'Rambo'
dupAllPrices = map(@('price') | *(2))
dupAllPrices([{price: 1}, {price: 2}]) // => [2, 4]
Where makes sure variables are local, and they are part of an expression. It's a safe substitute for var/let:
foo = (x) =>
a + b where
a = x * 2,
b = x * 3
// Maybe
Maybe.fromNullable(undefined) // Nothing
Maybe.fromNullable('john') // Just(john)
// Result
Result.Ok(5)
Result.Error('Ooops')
// task (equivalent of Promise)
wait = (secs) =>
task.task((resolver) =>
resolver.cleanup(() => clearTimeout(timer)) where
timer = setTimeout(() => resolver.resolve(secs), secs * 1000))
// gets first task to succeed and automatically cleans up others
task.waitAny([wait(2), wait(1)]).map(put).run()
ion -h // help
ion -c file.ion // compiles to JS, returns to stdout
ion -c file.ion > file.js // compiles to JS, writes to file.js
ion -e file.ion // compiles to JS, executes with node (4+ will work)
ion -a file.ion // returns ion's AST
ion -r 'put("Hello")' // executes some arbitrary code
ion -t file.ion // simply tries parsing and return true or error
ion is inspired by:
- Ramda;
- Haskell: operators as functions, currying by default, etc...;
- Elm/Elixir: nice operators for composition;
- io: everything is a function / very few reserve words;
- es6/7: spreads, template strings, lambda syntax...;
- es5: everything else;
- Cobol: just kidding;
Ion is still a toy language and far from 1.0. Beware.