# rual

[![Crate](https://img.shields.io/crates/v/rual.svg)](https://crates.io/crates/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
```rual
-- 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
```rual
let x = 3

let b = true

let s = 'string'
```

### Out-of-the-box tuples, lists & maps
```rual
-- 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
```rual
let num = 73

let [t, f] = [true, false]

let (x, y) = (21, 'fhtagn')
```

### Decision making
```rual
-- the good ol' `if-else`
if condition {
  -- ..
}
else {
  -- ..
}
```
```rual
-- ..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
}
```
```rual
-- ..or standard pattern matching
let lvl = match tup {
| (1, 8) -> 1,
| (x, y) when x % y == 0 -> 2,
| _ -> 3
}
```

### Functions
```rual
-- parameters are listed after `:`, separated by `,`
factorial: x -> {
  if {
  | x < 2 -> 1,
  | _     -> factorial(x - 1)
  }
}
```
```rual
sum: x, y -> {
  let z = x + y

  -- functions return the last expression in their block
  z
}
```
```rual
-- 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()
```