Rust

Rustでジェネリクスしつつ関数のオーバーロードのようなことをしてみる

Rustはジェネリックな構造体を定義できる。
関数のオーバーライドもオーバーロードもできないが、ジェネリックなトレイトを親に持てば引数の型が違う同名メソッドを複数定義できるので、「引数の型によって振る舞いが違うメソッド」というものを作ることができる。
ということは、それらを同時にやったら（ジェネリックな構造体に「引数の型によって振る舞いが違うメソッド」をインプリメンテーションすることが）できるのか？と思ってやってみたらできた。

trait TraitHoge<T> {
    fn prn(&mut self, c: T);
}

struct Hoge<U, V> {
    v1: U,
    v2: V,
}

impl<U, V> TraitHoge<i32> for Hoge<U, V> where U: std::fmt::Display, V: std::fmt::Display {
    fn prn(self: &mut Hoge<U, V>, arg: i32) {
        println!("i32 arg:{} v1:{} v2:{}", arg, self.v1, self.v2);
    }
}

impl<U, V> TraitHoge<f64> for Hoge<U, V> where U: std::fmt::Display, V: std::fmt::Display {
    fn prn(self: &mut Hoge<U, V>, arg: f64) {
        println!("f64 arg:{} v1:{} v2:{}", arg, self.v1, self.v2);
    }
}

impl<U, V> TraitHoge<String> for Hoge<U, V> where U: std::fmt::Display, V: std::fmt::Display {
    fn prn(self: &mut Hoge<U, V>, arg: String) {
        println!("String arg:{} v1:{} v2:{}", arg, self.v1, self.v2);
    }
}

fn main() {
    let mut h1 = Hoge{ v1: 10i32, v2: 10.23f64 };
    let mut h2 = Hoge{ v1: 3.14f32, v2: String::from("hello") };
    let mut h3 = Hoge{ v1: 255u8, v2: 1000i64 };

    h1.prn(5i32);
    h1.prn(22.33f64);
    h1.prn(String::from("good night"));
    println!();

    h2.prn(5i32);
    h2.prn(22.33f64);
    h2.prn(String::from("good night"));
    println!();

    h3.prn(5i32);
    h3.prn(22.33f64);
    h3.prn(String::from("good night"));
    println!();
}

[ 戻る ]