Rust ジェネリクスとトレイト

ジェネリクスはプログラミング言語にとって不可欠なメカニズムです。

C++言語では「テンプレート」を使ってジェネリクスを実装しますが、C言語にはジェネリクスのメカニズムがなく、これがC言語で型が複雑なプロジェクトを構築することを難しくしています。

ジェネリクスのメカニズムは、プログラミング言語が型の抽象化を表現するための仕組みであり、一般的に機能が確定していてデータ型が未定のクラス(例:連結リスト、マップなど)に使用されます。

関数でジェネリクスを定義する

これは整数型の数値を選択ソートするメソッドです:

例

fn max(array: &[i32]) -> i32 {
    let mut max_index = 0;
    let mut i = 1;
    while i < array.len() {
        if array[i] > array[max_index] {
            max_index = i;
        }
        i += 1;
    }
    array[max_index]
}

fn main() {
    let a = [2, 4, 6, 3, 1];
    println!("max = {}", max(&a));
}

実行結果:

max = 6

これは単純な最大値を求めるプログラムで、i32型の数値データを処理できますが、f64型のデータには使用できません。ジェネリクスを使用することで、この関数を様々な型に利用できるようにできます。しかし実際には、すべてのデータ型が比較できるわけではないため、次のコードは実行用ではなく、関数のジェネリクスの構文形式を説明するためのものです:

例

fn max<T>(array: &[T]) -> T {
    let mut max_index = 0;
    let mut i = 1;
    while i < array.len() {
        if array[i] > array[max_index] {
            max_index = i;
        }
        i += 1;
    }
    array[max_index]
}

構造体と列挙型のジェネリクス

前に学習したOptionとResultの列挙型はジェネリックです。

Rustの構造体と列挙型はどちらもジェネリクスのメカニズムを実装できます。

struct Point<T> {
    x: T,
    y: T
}

これは点座標の構造体で、Tは点座標を表す数値型を示します。次のように使用できます:

let p1 = Point {x: 1, y: 2};
let p2 = Point {x: 1.0, y: 2.0};

使用時に型を宣言していませんが、ここでは自動型推論のメカニズムが使用されています。ただし、次のように型が一致しない場合は許可されません:

let p = Point {x: 1, y: 2.0};

xが1とバインドされた時点でTはi32に設定されるため、f64型が現れることは許可されません。xとyを異なるデータ型で表現したい場合は、2つのジェネリクス識別子を使用できます:

struct Point<T1, T2> {
    x: T1,
    y: T2
}

列挙型でジェネリクスを表現する方法は、OptionやResultのようなものです:

enum Option<T> {
    Some(T),
    None,
}

enum Result<T, E> {
    Ok(T),
    Err(E),
}

構造体と列挙型はどちらもメソッドを定義できるため、メソッドもジェネリクスのメカニズムを実装すべきです。そうでなければ、ジェネリック型のクラスは有効なメソッドで操作できません。

例

struct Point<T> {
    x: T,
    y: T,
}

impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

fn main() {
    let p = Point { x: 1, y: 2 };
    println!("p.x = {}", p.x());
}

実行結果:

p.x = 1

注意:implキーワードの後には<T>が必要です<T>なぜなら、その後のTはそれを手本としているからです。ただし、その中の1つのジェネリック型にメソッドを追加することもできます:

impl Point<f64> {
    fn x(&self) -> f64 {
        self.x
    }
}
implブロック自体のジェネリクスは、その内部のメソッドがジェネリクスを持つ能力を妨げません:
impl<T, U> Point<T, U> {
    fn mixup<V, W>(self, other: Point<V, W>) -> Point<T, W> {
        Point {
            x: self.x,
            y: other.y,
        }
    }
}

メソッドmixupは、Point<T, U>の点のxとPoint<V, W>の点のyを融合して、型がPoint<T, W>の新しい点を作成します。


トレイト

トレイト(trait)の概念はJavaのインターフェース(Interface)に近いですが、両者は完全に同じではありません。トレイトとインターフェースが同じ点は、どちらも行動規範であり、どのクラスがどのメソッドを持つかを識別するために使用できることです。

トレイトはRustではtraitで表します:

trait Descriptive {
    fn describe(&self) -> String;
}

Descriptiveは実装者に必須であることを規定しますdescribe(&self) -> Stringメソッド。

これを使って構造体を実装します:

例

struct Person {
    name: String,
    age: u8
}

impl Descriptive for Person {
    fn describe(&self) -> String {
        format!("{} {}", self.name, self.age)
    }
}

形式は次の通りです:

impl <特性名> for <所实现的类型名>

Rustでは、同じ型が複数のトレイトを実装できますが、各implブロックは1つのトレイトしか実装できません。

デフォルトのトレイト

これはトレイトとインターフェースの違いです:インターフェースはメソッドを規定するだけで定義はできませんが、トレイトはメソッドをデフォルトメソッドとして定義できます。「デフォルト」なので、オブジェクトはメソッドを再定義することもできますし、再定義せずにデフォルトのメソッドを使用することもできます:

例

trait Descriptive {
    fn describe(&self) -> String {
        String::from("[Object]")
    }
}

struct Person {
    name: String,
    age: u8
}

impl Descriptive for Person {
    fn describe(&self) -> String {
        format!("{} {}", self.name, self.age)
    }
}

fn main() {
    let cali = Person {
        name: String::from("Cali"),
        age: 24
    };
    println!("{}", cali.describe());
}

実行結果:

Cali 24

impl Descriptive for Personブロックの中身を取り除くと、実行結果は次のようになります:

[Object]

トレイトを引数にする

多くの場合、関数を引数として渡す必要があります。例えば、コールバック関数やボタンイベントの設定などです。Javaでは、関数はインターフェースを実装したクラスのインスタンスとして渡す必要がありますが、Rustではトレイトパラメータを渡すことで実現できます:

fn output(object: impl Descriptive) {
    println!("{}", object.describe());
}

Descriptiveトレイトを実装した任意のオブジェクトをこの関数の引数として渡せます。この関数は、渡されたオブジェクトに他のプロパティやメソッドがあるかを知る必要はなく、Descriptiveトレイトが規定するメソッドを必ず持っていることだけを知っていれば十分です。もちろん、この関数内では他のプロパティやメソッドを使用することもできません。

トレイトパラメータは、次のような同等の構文でも実装できます:

fn output<T: Descriptive>(object: T) {
    println!("{}", object.describe());
}

これはジェネリクスに似たスタイルの糖衣構文です。この糖衣構文は、複数のパラメータ型がすべてトレイトである場合に非常に便利です:

fn output_two<T: Descriptive>(arg1: T, arg2: T) {
    println!("{}", arg1.describe());
    println!("{}", arg2.describe());
}

トレイトを型として表す場合に複数のトレイトが関与するときは、+記号で表します。例えば:

fn notify(item: impl Summary + Display)
fn notify<T: Summary + Display>(item: T)

注意:これは型を表す場合にのみ使用され、implブロック内で使用できるという意味ではありません。

複雑な実装関係はwhereキーワードを使用して簡略化できます。例:

fn some_function<T: Display + Clone, U: Clone + Debug>(t: T, u: U)

次のように簡略化できます:

fn some_function<T, U>(t: T, u: U) -> i32
    where T: Display + Clone,
          U: Clone + Debug

この構文を理解した上で、ジェネリクスの章の「最大値を取る」ケースを実際に実装できます:

例

trait Comparable {
    fn compare(&self, object: &Self) -> i8;
}

fn max<T: Comparable>(array: &[T]) -> &T {
    let mut max_index = 0;
    let mut i = 1;
    while i < array.len() {
        if array[i].compare(&array[max_index]) > 0 {
            max_index = i;
        }
        i += 1;
    }
    &array[max_index]
}

impl Comparable for f64 {
    fn compare(&self, object: &f64) -> i8 {
        if &self > &object { 1 }
        else if &self == &object { 0 }
        else { -1 }
    }
}

fn main() {
    let arr = [1.0, 3.0, 5.0, 4.0, 2.0];
    println!("maximum of arr is {}", max(&arr));
}

実行結果:

maximum of arr is 5

Tip:compare関数の第2引数はそのトレイトを実装する型と同じでなければならないと宣言する必要があるため、Self(大文字小文字に注意)キーワードは現在の型自体(インスタンスではなく)を表します。

トレイトを戻り値にする

トレイトを戻り値にする形式は次の通りです:

例

fn person() -> impl Descriptive {
    Person {
        name: String::from("Cali"),
        age: 24
    }
}

ただし、一点注意があります。トレイトを戻り値にする場合、そのトレイトを実装したオブジェクトのみを戻り値として受け付けます。また、同じ関数内で考えられるすべての戻り値の型は完全に同じでなければなりません。例えば、構造体Aと構造体BがどちらもトレイトTraitを実装している場合、次の関数は誤りです:

例

fn some_function(bool bl) -> impl Descriptive {
    if bl {
        return A {};
    } else {
        return B {};
    }
}

条件付きのメソッド実装

implの機能は非常に強力で、これを使ってクラスのメソッドを実装できます。しかし、ジェネリック型の場合、その型がすでに実装しているメソッドを区別して、次に実装すべきメソッドを決定する必要があることがあります:

struct A<T> {}

impl<T: B + C> A<T> {
    fn d(&self) {}
}

このコードは、A<T>型がこのimplブロックを有効に実装するには、TがBとCのトレイトをすでに実装している必要があることを宣言しています。

その他の拡張