Memory safety you don’t have to spell out.

use std.map.{Map};
use std.math.{PI};

variant Shape { Dot, Circle(f64), Rect { w: f64, h: f64 } }

struct Counter { seen: Map<string, i64> }

fn area(s: Shape): f64 {
    match s {
        Shape.Dot => 0.0,
        Shape.Circle(r) => PI * r.powi(2),
        Shape.Rect { w, h } => w * h,
    }
}

impl Counter {
    fn empty(): Counter { Counter { seen: Map.empty() } }

    fn note(self, name: string) {
        let before = match self.seen.get(name.clone()) { Some(n) => n, None => 0 };
        self.seen.set(name, before + 1);
    }
}

fn main(): i32 {
    let c = Counter.empty();
    c.note("circle");
    c.note("rect");

    let shapes = [Shape.Circle(1.0), Shape.Rect { w: 2.0, h: 3.0 }, Shape.Dot];
    let total = 0.0;
    for s in shapes { total += area(s); }

    println(`${c.seen.len()} kinds, area ${total}`);
    0
}

// A borrow has no sigil: `string`, never `&string`. Nothing is written for the
// borrow itself - a place handed to a function that only reads it becomes a
// borrow of that place, and the callee reads it where it lies.
fn longest_len(a: string, b: string): i64 {
    if a.len() >= b.len() { a.len() } else { b.len() }
}

// The clause after a signature says what a function does to the caller's
// values. `edits` mutates, `takes` keeps. Both are optional, and a function
// that says nothing is checked exactly as strictly.
fn push_twice(xs: Array<i64>, v: i64) {
    xs.push(v);
    xs.push(v);
}

fn consume(name: string) {
    println(name);
}

// There is no move operator and no `mut`. A move is a consuming use, and the
// compiler knows one when it sees one: the last read of a place takes it
// rather than copying it.
fn main(): i32 {
    let xs = [1, 2];
    push_twice(xs, 7);
    consume("kept");
    let a = "abc";
    let b = "de";
    // Nothing is written at the call site: `a` and `b` are read, not copied.
    println(`${xs.len()} items, longest ${longest_len(a, b)}`);
    0
}

// `variant` is the tagged union and `enum` is the numbered set: two
// declarations, because they are two different things.
use std.math.{PI};

variant Shape { Dot, Circle(f64), Rect { w: f64, h: f64 } }

enum Level { Low, Medium, High }

fn area(s: Shape): f64 {
    match s {
        Shape.Dot => 0.0,
        Shape.Circle(r) => PI * r.powi(2),
        Shape.Rect { w, h } => w * h,
    }
}

// An `enum` case carries no data and answers the number it was given.
fn threshold(l: Level): i64 {
    match l {
        Level.Low => 10,
        Level.Medium => 100,
        Level.High => 1000,
    }
}

fn main(): i32 {
    println(`${area(Shape.Rect { w: 2.0, h: 3.0 })} and ${threshold(Level.High)}`);
    0
}

# when the public beta lands:
git clone <repository> talor && cd talor
make                             # the C core and talorboot
make stage1                      # build/stage1/talor-stage1
make verify-stage1               # gen2 == gen3: the compiler is a fixpoint of itself
make install                     # puts it on PATH as `talor`

talor run program.talor

npm install talorlang