9. Enums, algebraic types and matching

enums.md

9. Enums, algebraic types and matching

• Simple enums, construction, handling
• Enums as tagged variants, construction, handling
• Enum arguments
• Matching and destruction
• Methods for enums

Simple enums

#[derive(Debug)]
enum E {
    Value1,
    Value2,
    Value3,
}

fn main() {
    let e : E = E::Value1;
    let mut e2 = E::Value2;
    println!("{:?}", e2);
    e2 = E::Value3;
    println!("{:?} {:?}", e, e2);
}

Enums as tagged variants, construction, handling

#[derive(Debug)]
enum E {
    Number(u64),
    Text(String),
}

fn main() {
    let e : E = E::Number(12);
    let mut e2 = E::Text("abc".to_string());
    println!("{:?}", e2);
    e2 = E::Number(13);
    println!("{:?} {:?}", e, e2);
}

#[derive(Debug)]
struct A {
    a : String,
}

#[derive(Debug)]
enum E {
    Tuple(u64, u64),
    Text(A),
}

use E::Tuple;
use E::Text;

fn main() {
    let aa = A{a:"xyz".to_string()};
    println!("{}", aa.a);
    let e : E = Tuple(12, 13);
    let mut e2 = Text(A{a:"abc".to_string()});
    println!("{:?}", e2);
    e2 = E::Tuple(13, 12);
    println!("{:?} {:?}", e, e2);
}

Enum arguments

#[derive(Debug)]
struct A {
    a : String,
}

#[derive(Debug)]
enum E {
    Tuple(u64, u64),
    Text(A),
}

use E::Tuple;
use E::Text;

fn f(e: E) {
    println!("In f: {:?}", e);
}

fn main() {
    let aa = A{a:"xyz".to_string()};
    println!("{}", aa.a);
    let e : E = Tuple(12, 13);
    let mut e2 = Text(A{a:"abc".to_string()});
    println!("{:?}", e2);
    f(e2);
    e2 = E::Tuple(13, 12);
    println!("{:?} {:?}", e, e2);
}

Matching

#[derive(Debug)]
struct A {
    a : String,
}

#[derive(Debug)]
enum E {
    Tuple(u64, u64),
    Text(A),
}

use E::Tuple;
use E::Text;

fn f(e: E) {
    match e {
        Tuple(x, y) => {
            println!("f got a tuple: x={}, y={}", x, y);
        },
        Text(a) => {
            println!("f got a text: a={:?}", a);
        },
    }
}

fn main() {
    let aa = A{a:"xyz".to_string()};
    println!("{}", aa.a);
    let e : E = Tuple(12, 13);
    let mut e2 = Text(A{a:"abc".to_string()});
    println!("{:?}", e2);
    f(e2);
    e2 = E::Tuple(13, 12);
    println!("{:?} {:?}", e, e2);
    f(e);
}

Methods for enums

#[derive(Debug)]
struct A {
    a : String,
}

#[derive(Debug)]
enum E {
    Tuple(u64, u64),
    Text(A),
}

use E::Tuple;
use E::Text;

impl E {
    fn f(&self) {
        match self {
            Tuple(x, y) => {
                println!("f got a tuple: x={}, y={}", x, y);
            },
            Text(a) => {
                println!("f got a text: a={:?}", a);
            },
        }
    }
}

fn main() {
    let aa = A{a:"xyz".to_string()};
    println!("{}", aa.a);
    let e : E = Tuple(12, 13);
    let mut e2 = Text(A{a:"abc".to_string()});
    println!("{:?}", e2);
    e2.f();
    e2 = E::Tuple(13, 12);
    println!("{:?} {:?}", e, e2);
    e.f();
}

Inline structs

#[derive(Debug)]
enum E {
    Empty,
    Value(i64),
    Tuple(u64, u64),
    Person{name: String, first_name: String, age: u16},
}

fn main() {
    let a = E::Empty;
    let b = E::Value(12);
    let c = E::Tuple(1, 2);
    let d = E::Person{name: "Miller".to_string(),
                      first_name: "Mike".to_string(),
                      age: 37};
    println!("{:?} {:?} {:?} {:?}", a, b, c, d);
}

References:

• Rust book: https://doc.rust-lang.org/book/ch06-01-defining-an-enum.html
• Video: https://youtu.be/fOZTs290tm0
• Overview: https://gist.github.com/max-itzpapalotl/18f7675a60f6f9603250367bcb63992e