如果我們今天定義了一個方法，想用於不同的型態，就可以使用 Trait

Trait 怎麼用

我們先定義一個 trait ，並在裡面定義方法

另外再定義出一個資料型態

我們會用 impl 的方式，為這個型態掛上 trait

讓這個型態可以使用裡面的方法

fn main() {
    trait Calculator {
        fn method_one(&self);
        fn method_two(&self, arg: i32) -> bool;
    }

    struct Numbers {
        value: i32,
    }

    impl Calculator for Numbers {
        fn method_one(&self) {
            println!("{}", self.value)
        }

        fn method_two(&self, arg: i32) -> bool {
            if arg > 0 {
                println!("positive number");
                return true;
            } else {
                println!("negative number");
                return false;
            }
        }
    }

    let instance = Numbers { value: 32 };

    instance.method_one();
    instance.method_two(instance.value);
}
        

> cargo run

32
positive number

那如果我們有多種型態呢？

一樣可以用 impl 來幫他們擴充

fn main() {
    trait CandyShop {
        fn method_one(&self);
    }

    struct Fudge {
        flavor: String,
    }

    struct Ingredient {
        main: String,
        second: String,
    }

    impl CandyShop for Fudge {
        fn method_one(&self) {
            println!("My candy shop has sell {} of Fudge", self.flavor)
        }
    }

    impl CandyShop for Ingredient {
        fn method_one(&self) {
            println!("Our Fudge is made of {}, and {}", self.main, self.second)
        }
    }

    let mocha_fudge = Fudge {
        flavor: "mocha".to_string(),
    };

    mocha_fudge.method_one();

    let mocha_fudge_ingredient = Ingredient {
        main: "milk".to_string(),
        second: "sugar".to_string(),
    };

    mocha_fudge_ingredient.method_one();
}

我們可以根據不同型態，在 function 中做不同的事情

執行後就會依照不同型態，跑出不同的結果

> cargo run

My candy shop has sell mocha of Fudge
Our Fudge is made of milk, and sugar

如果之前有學習過物件導向的程式語言

trait 就有點像是 module

我們可以幫型態來擴充他們的特徵

derive

另外我們還要提到 derive

derive 是 rust 中的 macro 之一，

裝上它之後會自動依照型態實現 Rust 內建的 trait，

需要指定 trait 給他，但如果這個型態不能用，就會噴錯

下方我們指定使用 Copy 以及 Clone ， derive 就會幫我們自動實現 Copy 以及 Clone 這兩個 trait

• 實現這個詞可能有點難理解，我自己的解釋是 「提供」方法

fn main() {
    trait Calculator {
        fn method_one(&self);
        fn method_two(&self, arg: i32) -> bool;
    }

    #[derive(Copy, Clone)]
    struct Numbers {
        value: i32,
    }

    impl Calculator for Numbers {
        fn method_one(&self) {
            println!("{}", self.value)
        }

        fn method_two(&self, arg: i32) -> bool {
            if arg > 0 {
                println!("positive number");
                return true;
            } else {
                println!("negative number");
                return false;
            }
        }
    }

    let instance = Numbers { value: 32 };
    let instance_copy = instance;

    instance_copy.method_one();
    instance_copy.method_two(instance_copy.value);
}

> cargo run

32
positive number