### 2 releases

0.0.4 | Mar 27, 2020 |
---|---|

0.0.3 | Mar 27, 2020 |

Used in rual-bin

**MIT**license

56KB

1.5K
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 are written `as`
two `{`
`let` x `=` `2`
`}`
`-``-` `..`and are ivoked `as`
`two``(``)`
`-``-` `..`thus being used to represent a lazily initialized value