Enums & Pattern Matching

Enums are tagged unions — variants can carry data.

Defining enums

enum Shape {
    Circle(f64),
    Rect(f64, f64),
    Point,
}

let s = Shape.Circle(3.14)

Pattern matching

match is exhaustive — the compiler rejects unhandled cases.

fn area(s: Shape): f64 {
    match s {
        Shape.Circle(r)  => 3.14159 * r * r
        Shape.Rect(w, h) => w * h
        Shape.Point      => 0.0
    }
}

Use _ as a wildcard:

match s {
    Shape.Circle(r) => print("circle")
    _ => print("something else")
}

Generic enums

enum Option<T> {
    Some(T),
    None,
}

enum Result<T, E> {
    Ok(T),
    Err(E),
}

Both Option and Result are built into the language with special syntax support.

if let

For when you only care about one variant:

let x = Option.Some(42)
if let Option.Some(val) = x {
    print("got ", val)
}

Option shorthand

T? is shorthand for Option<T>:

fn find(id: i32): i32? {
    if id == 1 {
        return Option.Some(42)
    }
    return Option.None
}

Next: Error Handling →