[Rust] 제네릭

예제

• 코드

  •  #[derive(Debug)]
     enum Test1<T> {
         I(i32),
         T1(T),
     }
            
     #[derive(Debug)]
     struct Test2<T1, T2> {
         t1: T1,
         t2: T2,
     }
     impl<T1, T2> Test2<T1, T2> {
         fn from(t1: T1, t2: T2) -> Test2<T1, T2> {
             Test2 { t1, t2 }
         }
            
         fn f1<T3>(self, t3: T3) -> Test2<T1, T3> {
             Test2 {
                 t1: self.t1,
                 t2: t3,
             }
         }
            
         fn t1(&self) -> &T1 {
             &self.t1
         }
            
         fn t2(&self) -> &T2 {
             &self.t2
         }
     }
            
     fn f1<T>(t: T) -> T {
         t
     }
            
     fn main() {
         println!("1.1 : {:?}", Test1::<i64>::I(1));
         println!("1.2 : {:?}", Test1::T1(1));
         println!("1.3 : {:?}", Test1::T1(String::from("a")));
            
         println!("2.1 : {:?}", Test2 { t1: 1, t2: 1.1 });
         println!("2.2 : {:?}", Test2::from(1, String::from("a")));
         println!("2.3 : {:?}", Test2::from(1, 2).t1());
         println!("2.3 : {:?}", Test2::from(1, 2).t2());
         println!("2.4 : {:?}", Test2::from(1, 2).f1(1.1));
            
         println!("3.1 : {}", f1(1));
         println!("3.2 : {}", f1(1.1));
     }
    

• 실행 결과

  •  1.1 : I(1)
     1.2 : T1(1)
     1.3 : T1("a")
     2.1 : Test2 { t1: 1, t2: 1.1 }
     2.2 : Test2 { t1: 1, t2: "a" }
     2.3 : 1
     2.3 : 2
     2.4 : Test2 { t1: 1, t2: 1.1 }
     3.1 : 1
     3.2 : 1.1