A functional language
that ships 33 KB.

The language

Nine constructs, and no others. Everything below is the whole of the syntax.

Data, and taking it apart

A type is a list of the shapes a value can have. match tests the shape and binds the pieces in one step, and the compiler checks that you covered every case.

type Shape
  Circle(r: Float)
  Rect(w: Float, h: Float)

fn area(s) = match s
  Circle(r) -> 3.14159 * r * r
  Rect(w, h) -> w * h

fn main() =
  shapes = Cons(Circle(1.0), Cons(Rect(2.0, 3.0), Nil))
  println(sum(map(shapes, area)))

$ rill run shapes.rill
9.14159

Leave out a case and the program does not compile — and the compiler names the one you forgot:

colour.rill: type error at line 6: match is not exhaustive; no arm matches `Blue`

fn sum_to(n) = go(n, 0)

fn go(i, acc) =
  if i == 0 then acc
  else go(i - 1, acc + i)

go(20000000, 0) → 1.3 MB resident

range(1, 10)
  |> filter(\x -> x % 2 == 0)
  |> map(\x -> x * x)
  |> sum

220

Concurrency: strands

Many lightweight threads over typed channels, taken from Go. One of them is a strand — a strand of a rope, of which a program is many. A hundred thousand of them cost about 56 MB and start in microseconds.

fn worker(jobs, results) =
  n = recv(jobs)
  send(results, n * n)
  worker(jobs, results)          # a loop that never ends

fn main() =
  jobs = channel()
  results = channel()
  spawn worker(jobs, results)
  send(jobs, 7)
  println(recv(results))

49

No collector

The compiler works out where each value's last use is and inserts the release there, following ownership rules. Nothing runs periodically; a value is freed at the instruction after it dies. Set one variable and the runtime tells you what was still alive at exit:

$ RILL_DEBUG_ALLOC=1 ./program
100000
live allocations: 0

What you get

Numbers

Apple M4, outputs verified identical across all three languages. Reproduce with python3 benchmarks/run.py.

Four microbenchmarks are not a workload. The first row is really “both of these are LLVM-quality code generation”; the rows that carry information are the third, where the concurrency implementation differs by seven times, and the second, where a compiler inserting frees beats two mature garbage collectors on time and memory.

What it does not have

Some of these are choices and some are a version number. Both are listed.

• MutationChosen. No assignment, no mutable fields — except Buf, a counted array, for C and for hot tables.
• A garbage collectorChosen. Reference counting decided at compile time. The cost is that reference cycles leak.
• Exceptions and nullChosen. Result and Option instead.
• LazinessChosen. Strict evaluation, so allocation appears where you wrote it.
• A standard library worth the nameVersion number. Lists, strings, options, results, sockets. No map, no sort, no formatted printing.
• Unicode-aware stringsVersion number. Strings are byte-indexed. ASCII is fine; anything else needs care.
• Tuples, and blocks inside match armsVersion number. Both cost you an extra named type or an extra function.
• An ecosystemVersion number. One implementation, no package manager, nobody else has hit your bug.

Rill is version 0.2. It is a good language to learn these ideas in and a bad one to run a business on, and this page would rather say so than have you find out.

The book

Getting it

git clone …/funclang && cd funclang
cargo build --release          # builds ./target/release/rill

rill run   program.rill        # compile to a temporary binary and run
rill build program.rill -o p   # keep the binary
rill fmt   program.rill        # canonical formatting
rill repl                      # definitions persist for the session

Needs Rust and LLVM 18. The runtime is no_std and links as a static library, which is most of why the binaries are the size they are.