【Rust入門】トレイトを理解してコードの再利用性を高めよう！

この記事では、Rustのトレイトについて、プログラミング初心者の方にも分かるように、基本から解説していきます！

Rustを学び始めたばかりだと、トレイトってなんだか掴みどころがなくて、インターフェースとどう違うの？なんて疑問に思うかもしれませんね。

この記事を読めば、トレイトの概念から具体的な書き方、そしてどうやってコードに活かしていくのかがスッキリ理解できるようになります。

読み終わるころには、きっとRustのコードを書くのがもっと楽しくなっているはず！

この記事で学べること

• Rustのトレイトの基本的な考え方
• トレイトを定義する具体的な書き方 (`trait` キーワード)
• 構造体にトレイトを実装する方法 (`impl` キーワード)
• トレイトを使った簡単なプログラムの作り方
• トレイトの便利な機能（デフォルト実装）
• トレイト境界のさわり（ジェネリクスとの関係）
• トレイトを使う上でのちょっとした注意点

Rustのトレイトって何？まず基本を理解しよう

まず、Rustのトレイトって一体何者なんでしょう？

すごく簡単に言うと、トレイトは特定の「振る舞い」や「能力」の設計図みたいなものです。
例えば、いろんな動物がいるとして、その動物たちが共通して持っているかもしれない「鳴く」という能力。この「鳴く」という能力の仕様書がトレイトだとイメージしてみてください。

他のプログラミング言語、例えばJavaやC#を知っている人なら、「インターフェース」に近いもの、と考えると理解しやすいかもしれませんね。ただし、Rustのトレイトにはインターフェースにはない独自の機能もあったりします。

でも、今は難しく考えなくて大丈夫！

ある型（データ構造）が「こういうことができるよ」というのを定義するための仕組み、それがトレイトなんだな、くらいに覚えておけばOKです。

乗り物が「走る」、図形が「面積を計算する」みたいに、共通の振る舞いをまとめて定義できる便利なもの、それがトレイトなんです。

Rustのトレイトの基本的な書き方（`trait`キーワード）

では、実際にトレイトをどうやって書くのか見ていきましょう。
トレイトを定義するには、`trait` というキーワードを使います。
こんな感じで書くんですよ。

trait 能力の名前 {
    // この能力を持つものが実装すべき関数の「形」だけ定義する
    fn 関数名(引数: 型) -> 戻り値の型;
    // 他にも必要な関数の形を定義...
}

ポイントは、トレイトの中では関数の具体的な中身（どう動くか）は書かずに、関数の名前、引数、戻り値の型といった「形」だけを決めるという点です。

まさに設計図ですよね！

試しに、さっき例に出した「鳴く」能力を表す`Speak`トレイトを作ってみましょうか。

trait Speak {
    // speakという名前の関数を持つことを決める
    // 引数は自分自身(&self)、戻り値はなし()
    fn speak(&self);
}

シンプルですね！これで、「`Speak`トレイトを持つものは、`speak`という関数を使える」というルールが決まりました。

構造体にRustのトレイトを実装する（`impl`キーワード）

トレイトという設計図を作ったら、今度はその設計図を実際のモノ、つまり構造体（`struct`）に適用していきます。

設計図で決められた能力を、構造体が実際にどう実行するのか、その具体的な動きを書いてあげる作業です。

この作業には、`impl` キーワードを使います。

書き方はこんな感じです。

impl トレイト名 for 構造体名 {
    // トレイトで定義された関数の具体的な処理を書く
    fn 関数名(引数: 型) -> 戻り値の型 {
        // ここに実際の処理を書く！
    }
    // 他の関数も同様に...
}

`impl` の後に実装したいトレイト名、`for` の後にそのトレイトを実装する構造体名を指定します。

そして、`{}` の中に、トレイトで定義されていた関数の具体的な処理を書いていくわけです。

トレイトメソッドの実装例

それでは、先ほど作った `Speak` トレイトを、具体的な動物を表す `Dog` 構造体と `Cat` 構造体に実装してみましょう。
犬と猫では鳴き方が違いますよね？それを `impl` を使って表現します。

// まずは構造体を定義
struct Dog {
    name: String,
}

struct Cat {
    name: String,
}

// Speakトレイトを定義（再掲）
trait Speak {
    fn speak(&self);
}

// Dog構造体にSpeakトレイトを実装
impl Speak for Dog {
    fn speak(&self) {
        // 犬らしい鳴き方にする
        println!("{}「わん！」", self.name);
    }
}

// Cat構造体にSpeakトレイトを実装
impl Speak for Cat {
    fn speak(&self) {
        // 猫らしい鳴き方にする
        println!("{}「にゃーん！」", self.name);
    }
}

どうでしょう？

同じ `Speak` トレイト（同じ `speak` 関数）を実装していますが、`Dog` と `Cat` で中身の処理が違いますよね。

このように、トレイトを使うことで、型ごとに異なる具体的な振る舞いを、共通のインターフェース（関数名）で扱えるようになる。これがトレイトの強力な点のひとつなんです。

Rustのトレイトを使ってみよう

トレイトを定義して、それを構造体に実装するところまでできましたね！

いよいよ、このトレイトを使ってプログラムを動かしてみましょう。
トレイトを実装した構造体のインスタンス（実体）を作って、トレイトで定義されたメソッド（関数）を呼び出すだけです。簡単ですよ！

サンプルプログラム

`main` 関数の中で、`Dog` と `Cat` のインスタンスを作って、それぞれの `speak` メソッドを呼び出してみます。

以下のコードは、そのままコピーしてRust環境で動かせますので、ぜひ試してみてくださいね。

// Speakトレイトを定義
trait Speak {
    fn speak(&self);
}

// Dog構造体を定義
struct Dog {
    name: String,
}

// Cat構造体を定義
struct Cat {
    name: String,
}

// Dog構造体にSpeakトレイトを実装
impl Speak for Dog {
    fn speak(&self) {
        println!("{}「わん！」", self.name);
    }
}

// Cat構造体にSpeakトレイトを実装
impl Speak for Cat {
    fn speak(&self) {
        println!("{}「にゃーん！」", self.name);
    }
}

// プログラムのエントリーポイントであるmain関数
fn main() {
    // Dogインスタンスを作成
    let pochi = Dog { name: String::from("ポチ") };
    // Catインスタンスを作成
    let tama = Cat { name: String::from("タマ") };

    // それぞれのspeakメソッドを呼び出す
    pochi.speak(); // ポチが鳴く
    tama.speak();  // タマが鳴く
}

実行結果の確認

上記のプログラムを実行すると、コンソールにはこんな風に出力されるはずです。

ポチ「わん！」
タマ「にゃーん！」

ちゃんと、`Dog` は犬らしく、`Cat` は猫らしく鳴きましたね！

このように、トレイトを実装した型のインスタンスからは、ドット（`.`）を使ってトレイトのメソッドを呼び出すことができます。

これがトレイトの基本的な使い方です。定義して、実装して、使う。この流れを掴んでおきましょう！

Rustのトレイトの便利な使い方：デフォルト実装

トレイトには、もうひとつ便利な機能があります。それがデフォルト実装です。

これは、トレイトを定義する時点で、メソッドの基本的な動作（デフォルトの処理）をあらかじめ書いておける機能なんです。

どういう時に役立つかというと、例えば、ほとんどの型では同じ処理で良いんだけど、一部の型だけ特別な処理をしたい、という場合です。

デフォルト実装があれば、特別な処理が必要ない型については、`impl` ブロックでわざわざそのメソッドを実装しなくても、デフォルトの動作が使われるようになります。楽ちんですよね！

例を見てみましょう。自己紹介する能力 `Describe` トレイトを考えます。多くの型はデフォルトの挨拶で良いけど、特別な挨拶をしたい型もある、という状況です。

trait Describe {
    // このメソッドはデフォルト実装を提供
    fn describe_default(&self) {
        println!("私はデフォルトの存在です。");
    }

    // このメソッドは各型で実装する必要がある（デフォルト実装なし）
    fn describe_unique(&self);
}

struct NormalPerson {
    name: String,
}

struct SpecialPerson {
    name: String,
    title: String,
}

// NormalPersonにはDescribeトレイトを実装
impl Describe for NormalPerson {
    // describe_defaultは実装しない → デフォルト実装が使われる
    fn describe_unique(&self) {
        println!("私の名前は{}です。普通の人間です。", self.name);
    }
}

// SpecialPersonにはDescribeトレイトを実装
impl Describe for SpecialPerson {
    // こちらはdescribe_defaultも独自に実装（オーバーライド）
    fn describe_default(&self) {
        println!("私は特別な存在、{}様だ！", self.title);
    }

    fn describe_unique(&self) {
        println!("我が名は{}、{}であるぞ！", self.name, self.title);
    }
}

fn main() {
    let person1 = NormalPerson { name: String::from("山田") };
    let person2 = SpecialPerson { name: String::from("田中"), title: String::from("勇者") };

    person1.describe_default(); // デフォルト実装が呼ばれる
    person1.describe_unique();

    person2.describe_default(); // 独自実装が呼ばれる
    person2.describe_unique();
}

実行結果

私はデフォルトの存在です。
私の名前は山田です。普通の人間です。
私は特別な存在、勇者様だ！
我が名は田中、勇者であるぞ！

`NormalPerson` は `describe_default` を実装していないので、トレイトで定義されたデフォルトのメッセージが表示されています。

一方で `SpecialPerson` は `describe_default` を独自に実装しているので、そちらのメッセージが表示されました。

このようにデフォルト実装を使えば、実装の手間が省ける場合がある超便利機能なので、覚えておくと良いでしょう。

Rustのトレイト境界（ジェネリクスとの連携）入門

少しだけステップアップした話になりますが、トレイトはジェネリクスという機能と一緒に使うことで、さらにその真価を発揮します。

ジェネリクスは、具体的な型を決めずに、いろんな型で使いまわせる関数や構造体を作る機能のことです。

ここで登場するのがトレイト境界（Trait Bounds）です。

これは、ジェネリックな関数などを作るときに、「どんな型でもOK！」ではなく、「このトレイトを実装している型だけ受け付けますよ！」という制約を付けられる機能なんです。

例えば、`Speak` トレイトを実装している型なら何でも引数に取って、その `speak` メソッドを呼び出す関数を作りたい、と考えたとします。

そんな時にトレイト境界を使います。書き方は、型のパラメータの後ろに `: トレイト名` を付けます。

// Speakトレイト（再掲）
trait Speak {
    fn speak(&self);
}
struct Dog { name: String }
impl Speak for Dog { fn speak(&self) { println!("{}「わん！」", self.name); } }
struct Cat { name: String }
impl Speak for Cat { fn speak(&self) { println!("{}「にゃーん！」", self.name); } }
struct Bird {} // Speakを実装しない

// ジェネリックな関数 `make_speak` を定義
// Tという型パラメータに、Speakトレイト境界を指定 (`T: Speak`)
fn make_speak<T: Speak>(animal: &T) {
    println!("さあ、鳴いてごらん！");
    animal.speak(); // TはSpeakを実装していることが保証されるので、speakメソッドを呼べる
}

fn main() {
    let pochi = Dog { name: String::from("ポチ") };
    let tama = Cat { name: String::from("タマ") };
    let piyo = Bird {};

    make_speak(&pochi); // DogはSpeakを実装しているのでOK
    make_speak(&tama);  // CatはSpeakを実装しているのでOK

    // make_speak(&piyo); // これはコンパイルエラー！ BirdはSpeakを実装していないため
}

この `make_speak` 関数は、`Speak` トレイトを実装している `Dog` や `Cat` は引数に取れますが、実装していない `Bird` を渡そうとするとコンパイルエラーになります。

トレイト境界を使うことで、関数の安全性を高めつつ、コードの使い回しがもっと上手になるテクニックです。

ジェネリクス自体は奥が深いですが、トレイトと組み合わせるとこんなことができるんだな、と知っておくだけでも全然違いますよ！

Rustのトレイトを使う上での注意点

トレイトはとても便利ですが、いくつか知っておくと良いルールや注意点があります。ここでは特に初心者が戸惑いがちな点を２つ紹介しますね。

孤児ルール (Orphan Rule)