3 releases
0.0.2 | Mar 18, 2020 |
---|---|
0.0.1 | Mar 18, 2020 |
0.0.0 | Feb 28, 2020 |
#650 in Programming languages
37KB
1K
SLoC
rual
A small, functional-first, embeddable language for Rust, inpired by Lua.
Language design
- Simple syntax
- All values should be immutable
- Values can be shadowed
Simple and non-obtrusive function definitions
-- this is a single-line comment..
-{
this is
a multiline comment
}-
-- a flat lambda
f: x, y -> x + y
-- or with a block
g: x, y -> {
let z = 5
x + y + z
}
Simple built-in types
let x = 3
let b = true
let s = 'string'
Out-of-the-box tuples, lists & maps
-- a tuple
let (p, q) = (1, 7)
-- a list of `i32`
let xs = [ 1..10 ]
-- this `xs` shadows the previous definition
let [x, ...xs] = map(xs, \x -> 11 - x) -- x = 10, xs = [ 9..1 ]
-- a map with `Num` keys and `String` values
let m = { 1: '0x01', 0: '0x00' }
Syntax
Not all of the syntax is currently supported
Declarations
let num = 73
let [t, f] = [true, false]
let (x, y) = (21, 'fhtagn')
Decision making
-- the good ol' `if-else`
if condition {
-- ..
}
else {
-- ..
}
-- ..or a slightly different version
-- this is equivalent to a chain of `if/else if/else` statements
if {
| condition1 -> routine1(),
| condition2 && condition3 -> routine2(),
| _ -> fallback(), -- a fallthrough is necessary
}
-- ..or standard pattern matching
let lvl = match tup {
| (1, 8) -> 1,
| (x, y) when x % y == 0 -> 2,
| _ -> 3
}
Functions
-- parameters are listed after `:`, separated by `,`
factorial: x -> {
if {
| x < 2 -> 1,
| _ -> factorial(x - 1)
}
}
sum: x, y -> {
let z = x + y
-- functions return the last expression in their block
z
}
-- functions without parameters can be written with an explicit `: ()`, such as
one: () -> {
let x = 1 -- assignment has type of `()`
}
-- ..or without it
two {
let x = 2
}
-- ..and are ivoked as
one()
two()