Rust: 열거형

개요

• 구조체와 유사하게 다양한 타입과 메소드를 가질 수 있음

Option

• 값이 있거나 없는 경우를 나타내는 열거형
• Rust는 null 개념이 없고 Option을 사용
• null 값을 null 이 아닌 값처럼 사용하려는 실수를 방지

예제

• 코드

        #[derive(Debug)]
        enum Test1 {
            A,
            B,
        }

        #[derive(Debug)]
        enum Test2 {
            A(i32),
            B(String),
            C(i32, String),
        }

        #[derive(Debug)]
        struct Struct {}

        #[derive(Debug)]
        enum Test3 {
            A(Struct),
        }
        impl Test3 {
            fn print(&self) {
                println!("call print");
            }
        }

        fn main() {
            println!("1 : {:?}", Test1::A);
            println!("2 : {:?}", Test1::B);

            println!("3 : {:?}", Test2::A(1));
            println!("4 : {:?}", Test2::B(String::from("a")));
            println!("5 : {:?}", Test2::C(1, String::from("a")));

            match Test2::A(1) {
                Test2::A(i) => println!("6 : {}", i),
                Test2::B(s) => println!("6 : {}", s),
                _ => println!("6 : other"),
            }

            match Test2::C(1, String::from("a")) {
                Test2::A(i) => println!("7 : {}", i),
                Test2::B(s) => println!("7 : {}", s),
                _ => println!("7 : other"),
            }

            println!("8 : {:?}", Test3::A(Struct {}));
            Test3::A(Struct {}).print();

            let o: Option<i32> = None;
            println!("9 : {}", o.is_some());
            println!("10 : {}", o.is_none());
            match o {
                Some(t) => println!("11 : Some - {}", t),
                None => println!("11 : None"),
            }

            let o: Option<i32> = Some(1);
            println!("12 : {}", o.is_some());
            println!("13 : {}", o.is_none());
            match o {
                Some(t) => println!("14 : Some - {}", t),
                None => println!("14 : None"),
            }

            match Some(1) {
                Some(1) => println!("15 : Some(1)"),
                Some(t) => println!("15 : Some - {}", t),
                _ => println!("15 : other"),
            }

            match Some(3) {
                Some(1) => println!("15 : Some(1)"),
                Some(t) => println!("15 : Some - {}", t),
                _ => println!("15 : other"),
            }

            let o: Option<i32> = Some(1);
            if let Some(1) = o {
                println!("16 : Some(1)");
            }
        }

• 실행 결과

        1 : A
        2 : B
        3 : A(1)
        4 : B("a")
        5 : C(1, "a")
        6 : 1
        7 : other
        8 : A(Struct)
        call print
        9 : false
        10 : true
        11 : None
        12 : true
        13 : false
        14 : Some - 1
        15 : Some(1)
        15 : Some - 3
        16 : Some(1)