[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)