Enums & Algebraic Data Types

Wyn enums are algebraic data types — each variant can carry different data.

Simple Enums

enum Color { Red, Green, Blue }

fn main() -> int {
    var c = Color.Red
    match c {
        Color.Red => println("red")
        Color.Green => println("green")
        Color.Blue => println("blue")
    }
    return 0
}

Enums with Data

Each variant can carry a value:

enum Shape {
    Circle(float)
    Square(float)
    Rectangle(float)
}

fn area(s: Shape) -> float {
    return match s {
        Shape.Circle(r) => 3.14159 * r * r
        Shape.Square(side) => side * side
        Shape.Rectangle(w) => w * 2.0
    }
}

fn main() -> int {
    var c = Shape.Circle(5.0)
    println("Area: ${area(c)}")
    return 0
}

Returning Enums from Functions

enum Result {
    Ok(string)
    Err(string)
}

fn divide(a: int, b: int) -> Result {
    if b == 0 { return Result.Err("division by zero") }
    return Result.Ok("${a / b}")
}

fn main() -> int {
    var r = divide(10, 3)
    match r {
        Result.Ok(val) => println("Result: ${val}")
        Result.Err(msg) => println("Error: ${msg}")
    }
    return 0
}

Pattern Matching

Match expressions return values:

fn describe(n: int) -> string {
    return match n {
        0 => "zero"
        1 => "one"
        _ if n < 0 => "negative"
        _ if n > 100 => "big"
        _ => "other"
    }
}

Match on Strings

fn greet(lang: string) -> string {
    return match lang {
        "en" => "Hello"
        "es" => "Hola"
        "fr" => "Bonjour"
        _ => "Hi"
    }
}