شمارش‌ها

enum Color {
    Red,
    Green,
    Black,
    Custom(int, int, int)
}

var c1 = Color.Red;
var c2 = Color.Custom(1, 2, 3);

var c3: Color = .Green;

enum ConnectionState {
    Disconnected,
    Connecting,
    Connected,
    Failed
}

fn is_online(state: ConnectionState) bool {
    switch (state) {
        case .Connected => {
            return true;
        }
        default => {
            return false;
        }
    }
}

enum Task {
    Compute(struct {
        id: uint64,
        priority: int
    }),
    Delay(uint32),
    Range((int, int))
}

fn process_task(t: Task) {
    switch (t) {
        case .Compute(req) => {
            printf("Compute(id: %llu, priority: %d)\n", req.id, req.priority);
        }
        case .Delay(ms) => {
            printf("Delay(ms: %u)\n", ms);
        }
        case .Range(bounds) => {
            printf("Range(start: %d, end: %d)\n", bounds.0, bounds.1);
        }
        default => {
            printf("Unknown Task\n");
        }
    }
}

pub fn main() {
    var t = Task.Compute(struct { id: 1024, priority: 5 });
    process_task(t);

    t = Task.Range((0, 100));
    process_task(t);

    t = Task.Delay(500);
    process_task(t);
}

enum Error {
    NotFound = struct { id: 1uint32, msg: "not found" },

    Custom {
        id: uint32,
        msg: const char*,
        extra: const char*
    }
}

pub fn main() {
    const err = Error.Custom { id: 2, msg: "custom error message", extra: null };

    switch (err) {
        case .NotFound => {
            printf("not found\n");
        }
        case .Custom { id, msg, .. } => {
            printf("id: %d, %s\n", id, msg);
        }
    }
}

type Kind = enum { Unknown = 0, Known = 1 };

import std::libc{printf};

enum ScalarEnum {
    A = 10,
    B = 20,
    C = 30
}

fn display_scalar_enum(value: ScalarEnum) {
    switch (value) {
        case .A(a) => {
            printf("a(%d) ", a);
        }
        case .B(b) => {
            printf("b(%d) ", b);
        }
        case .C(c) => {
            printf("c(%d) ", c);
        }
    }
}

pub fn main() {
    const x: ScalarEnum = .A;

    display_scalar_enum(x);
    display_scalar_enum(.B);
    display_scalar_enum(.C);
}

enum ScalarEnum(uint32) {
    A = 10,
    B = 20,
    C = 30
}

const a: enum(bool) { A = true, B = false } = .A;

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

pub fn main() {
    var opt: Option<int> = .None;
    display_option(opt);

    opt = .Some(10);
    display_option(opt);
}

const mode: enum { Off = 0, On = 1 } = .On;

switch (mode) {
    case .Off(x) => { /* ... */ }
    case .On(x) => { /* ... */ }
}

import std::libc{printf};

enum Color {
    Red,                     // Unit variant
    Green = "green!",        // Valued variant (scalar/constant)
    Custom(uint, uint, uint) // Tuple variant
}

pub fn main() {
    const color = Color.Green;

    switch (color) {
        case .Red => {
            printf("red\n");
        }
        case .Green(value) => {
            printf("%s\n", value);
        }
        case .Custom(a, b, c) => {
            printf("custom(%d, %d, %d)\n", a, b, c);
        }
    }
}

import std::libc{printf};

type Kind = enum { Unknown = 0, Known = 1 };

fn display_kind(value: Kind) {
    switch (value) {
        case .Unknown(x) => {
            printf("%d", x);
        }
        case .Known(x) => {
            printf("%d", x);
        }
    }
}

pub fn main() {
    const x: Kind = .Unknown;

    display_kind(.Known);
    display_kind(.Unknown);
    display_kind(x);
}

switch (err) {
    // Ignore a specific exported field
    case .Custom { id, msg, extra: _ } => {
        // 'id' and 'msg' are bound; 'extra' is ignored
    }
}

switch (err) {
    // Ignore the rest of the fields
    case .Custom { id, msg, .. } => {
        // Only 'id' and 'msg' are bound
    }
}

switch (err) {
    // Rename a field locally
    case .Custom { id, msg, extra: msg2 } => {
        msg2; // VALID: bound to the 'extra' field
        extra; // ERROR: not found
    }
}