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