Enums aur Pattern Matching

Ek enum ek type ko kai naam wale variants mein se ek define karta hai. Kai languages ke enums ke ulat, jo bas labeled numbers hote hain, Rust ke enums ko exhaustively match kiya ja sakta hai, aur har variant apna khud ka data bhi carry kar sakta hai.

enum Direction {
    Up,
    Down,
    Left,
    Right,
}

fn describe(dir: Direction) -> &'static str {
    match dir {
        Direction::Up => "going up",
        Direction::Down => "going down",
        Direction::Left => "going left",
        Direction::Right => "going right",
    }
}

fn main() {
    println!("{}", describe(Direction::Left));
}

going left

match ek value ko baari baari har variant ke against compare karta hai, aur compiler check karta hai ki har possible variant cover hua hai — ek bhi chhod do, to yeh ek compile error hoga, na ki runtime par hone wala ek bug.

Data carry karne wale enums

Ek enum ka har variant apna khud ka data apne khud ke shape mein hold kar sakta hai — Shape::Circle ek single f64 carry karta hai, jabki Shape::Rectangle do carry karta hai. match jo bhi variant actually present hai use destructure kar deta hai, uske data ko ek naam se bind karke jise aap directly use kar sakte ho.

enum Shape {
    Circle(f64),
    Rectangle(f64, f64),
}

fn area(shape: Shape) -> f64 {
    match shape {
        Shape::Circle(radius) => 3.14159 * radius * radius,
        Shape::Rectangle(w, h) => w * h,
    }
}

fn main() {
    println!("{:.2}", area(Shape::Circle(2.0)));
    println!("{:.2}", area(Shape::Rectangle(3.0, 4.0)));
}

12.57
12.00

Aage: Option aur Result — Rust null aur exceptions ko do ordinary enums se kaise replace karta hai.