impl Trait | Progrust Library

impl Traitは、具体的な型名の代わりに「このトレイトを実装した型」とだけ書く記法です。書けるのは関数の引数と戻り値の型の位置だけです¹。externブロック内で宣言する外部関数には書けません²。

戻り値の位置に書くと、「そのトレイトを実装した具体的な型を1つ返す」という意味になります³。どの型を返すかを決めるのは関数側で、呼び出し側には型名が伏せられ、指定したトレイトが宣言するメソッドだけが使えます³。特に役立つのはクロージャとイテレータです。クロージャの型は書き表せる名前を持たず、イテレータはメソッドを重ねるほど型名が長く複雑になるためです⁴。

// 割引率から「価格に割引を適用するクロージャ」を作って返す
// クロージャの型には名前がないので、impl Fn で「呼び出せる何か」として返す
fn make_discount(rate: u32) -> impl Fn(u32) -> u32 {
    move |price| price * (100 - rate) / 100
}

// メソッドを重ねたイテレータの型は長くなる
// impl Iterator と書けば「u32を順に返すもの」とだけ公開できる
fn half_prices(prices: Vec<u32>) -> impl Iterator<Item = u32> {
    prices.into_iter().map(|price| price / 2)
}

fn main() {
    let apply_20off = make_discount(20);
    println!("1500円の2割引きは{}円", apply_20off(1500));

    for price in half_prices(vec![100, 150, 200]) {
        println!("半額は{}円", price);
    }
}

Playgroundで開く

引数位置との意味の違い

引数の位置のimpl Traitは、名前のない型引数を1つ宣言する糖衣構文で、実際の型を選ぶのは呼び出し側です⁵。戻り値の位置では逆に、型を選ぶのは関数側で、呼び出し側は型を指定できません⁶。同じ記法ですが、位置によって役割が入れ替わります。

観点	引数位置 `fn f(x: impl Trait)`	戻り値位置 `fn f() -> impl Trait`
具体的な型を決めるのは	呼び出し側⁵	関数側⁶
意味	名前のない型引数（トレイト境界付きの`<T: Trait>`の糖衣構文）⁵	具体的な型を伏せた抽象型³
呼び出しごとの型	渡した型ごとに変わる⁵	関数（とそのジェネリック引数）ごとに1つに固定される³

なお、ジェネリクスの型引数を戻り値に使ったfn f<T: Trait>() -> Tは、戻り値位置のimpl Traitとは別物です。前者は呼び出し側がTを決めて関数はその型を返すのに対し、後者は関数が型を決め「トレイトを実装していること」だけを約束します⁶。

返せる型は1つだけ

impl Traitの裏側には隠された具体的な型が1つあり、関数のどの経路を通っても同じ具体的な型に解決される必要があります³。そのため分岐で違う型を返すことはできず、エラー: E0308になります⁷⁸。

trait Payment {
    fn pay(&self, amount: u32) -> String;
}

struct Cash;
struct CreditCard;

impl Payment for Cash {
    fn pay(&self, amount: u32) -> String {
        format!("現金で{}円を支払いました", amount)
    }
}

impl Payment for CreditCard {
    fn pay(&self, amount: u32) -> String {
        format!("カードで{}円を支払いました", amount)
    }
}

fn pick(use_card: bool) -> impl Payment {
    // エラー: E0308（ifとelseで返す型が違う）
    if use_card { CreditCard } else { Cash }
}

実行時に型を切り替えたい場合は、トレイトオブジェクトを使ってBox<dyn Payment>を返します⁷。

観点	`-> impl Trait`	`-> Box<dyn Trait>`
返せる型	常に同じ1つの型³	実装した型のどれでもよい⁷
ヒープ確保	なし⁴	あり⁴
メソッド呼び出し	静的ディスパッチ⁴	動的ディスパッチ⁴
使えるトレイト	任意	dyn互換なトレイトのみ⁹

補足

呼び出し側にはトレイトのメソッドしか見えない

戻り値がimpl Traitだと、呼び出し側からは具体的な型が見えないため、そのトレイト（とスーパートレイト）が宣言するメソッド以外は呼べません³。下の例では範囲式1..=3が作るRangeInclusive<u16>を返していますが、impl Iteratorとしか宣言していないので、ExactSizeIteratorのlenは呼べずエラー: E0599になります。

fn steps() -> impl Iterator<Item = u16> {
    1..=3
}

fn main() {
    // エラー: E0599（不透明型にlenというメソッドはない）
    println!("{}", steps().len());
}

具体的な型を返すと決めているなら、-> std::ops::RangeInclusive<u16>のように書けば呼び出し側はlenも使えます。impl Traitは「公開する能力をトレイトの範囲に絞る」記法でもあります。

トレイトのメソッドの戻り値にも書ける（RPITIT）

トレイト宣言の中のメソッドの戻り値にもimpl Traitを書けます。これは匿名の関連型への糖衣構文として扱われ、実装側のシグネチャに書いた型がその関連型の中身になります¹⁰。

trait Shop {
    // 「名前を順に返すもの」とだけ決めて、実際の型は実装側に任せる
    fn items(&self) -> impl Iterator<Item = String>;
}

struct Bakery;

impl Shop for Bakery {
    fn items(&self) -> impl Iterator<Item = String> {
        ["食パン", "クロワッサン"].into_iter().map(String::from)
    }
}

fn main() {
    for item in Bakery.items() {
        println!("{}", item);
    }
}

Playgroundで開く

ただし戻り値位置にimpl Traitを持つメソッドはdyn互換の条件を満たさないため、そのままではdyn Shopにできません⁹。

ジェネリック引数の捕捉とuse<..>

impl Traitが隠している具体的な型が、関数の型引数やライフタイムを含むことがあります。そのため戻り値位置のimpl Traitは、スコープにあるジェネリック引数（型・const・ライフタイム）をすべて自動的に捕捉します¹¹。

捕捉する対象はuse<..>境界で明示的に絞れます¹²。たとえばuse<>（何も捕捉しない）と書くと、引数の参照とは無関係な戻り値であることを表明できます。

// use<> により「引数の参照を捕捉しない」ことを明示する
fn to_prices(text: &str) -> impl Iterator<Item = u32> + use<> {
    let prices: Vec<u32> = text.split(',').filter_map(|s| s.parse().ok()).collect();
    prices.into_iter()
}

fn main() {
    let input = String::from("150,980,120");
    let prices = to_prices(&input);
    drop(input); // 捕捉していないので、元のStringを先に破棄してよい

    for price in prices {
        println!("{}円", price);
    }
}

Playgroundで開く

書けない場所

impl Traitは変数の型注釈や構造体のフィールドの型には書けず、書くとエラー: E0562になります¹²。型エイリアス（type Shown = impl Display;）も安定版では使えず、こちらはエラー: E0658（unstable）になります。

use std::fmt::Display;

fn main() {
    // エラー: E0562（変数束縛の型にimpl Traitは書けない）
    let price: impl Display = 1500;
    println!("{}", price);
}

The Rust Reference - Impl trait limitations “impl Trait can only appear as a parameter or return type of a non-extern function. It cannot be the type of a let binding, field type, or appear inside a type alias.” ↩ ↩²
Error code E0562 “impl Trait is only allowed as a function return and argument type.” ↩ ↩²
The Rust Reference - Abstract return types “Functions can use impl Trait to return an abstract return type. These types stand in for another concrete type where the caller may only use the methods declared by the specified Trait.” / “Each possible return value from the function must resolve to the same concrete type.” ↩ ↩² ↩³ ↩⁴ ↩⁵ ↩⁶ ↩⁷
The Rust Reference - Abstract return types “impl Trait in return position allows a function to return an unboxed abstract type. This is particularly useful with closures and iterators. For example, closures have a unique, un-writable type.” / “This could incur performance penalties from heap allocation and dynamic dispatch.” / “which also avoids the drawbacks of using a boxed trait object.” / “Similarly, the concrete types of iterators could become very complex, incorporating the types of all previous iterators in a chain.” ↩ ↩² ↩³ ↩⁴ ↩⁵
The Rust Reference - Anonymous type parameters “impl Trait in argument position is syntactic sugar for a generic type parameter like <T: Trait>, except that the type is anonymous and doesn’t appear in the GenericParams list.” / “The caller must provide a type that satisfies the bounds declared by the anonymous type parameter.” ↩ ↩² ↩³ ↩⁴
The Rust Reference - Differences between generics and impl Trait in return position “In argument position, impl Trait is very similar in semantics to a generic type parameter. However, there are significant differences between the two in return position. With impl Trait, unlike with a generic type parameter, the function chooses the return type, and the caller cannot choose the return type.” / “doesn’t allow the caller to determine the return type. Instead, the function chooses the return type, but only promises that it will implement Trait.” ↩ ↩² ↩³
The Rust Programming Language - Returning Types That Implement Traits “However, you can only use impl Trait if you’re returning a single type.” / “Returning either a NewsArticle or a SocialPost isn’t allowed due to restrictions around how the impl Trait syntax is implemented in the compiler.” / “We’ll cover how to write a function with this behavior in the "Using Trait Objects to Abstract over Shared Behavior" section of Chapter 18.” ↩ ↩² ↩³
Error code E0308 “Expected type did not match the received type.” ↩
The Rust Reference - Dyn compatibility “Dispatchable functions must: … Not have an opaque return type” ↩ ↩²
The Rust Reference - Return-position impl Trait in traits and trait implementations “Every impl Trait in the return type of an associated function in a trait is desugared to an anonymous associated type. The return type that appears in the implementation’s function signature is used to determine the value of the associated type.” ↩
The Rust Reference - Automatic capturing “Return-position impl Trait abstract types automatically capture all in-scope generic parameters, including generic type, const, and lifetime parameters (including higher-ranked ones).” / “2024 Edition differences: Before the 2024 edition, on free functions and on associated functions and methods of inherent impls, generic lifetime parameters that do not appear in the bounds of the abstract return type are not automatically captured.” ↩ ↩²
The Rust Reference - Precise capturing “The set of generic parameters captured by a return-position impl Trait abstract type may be explicitly controlled with a use<..> bound. If present, only the generic parameters listed in the use<..> bound will be captured.” ↩

impl Trait.

引数位置との意味の違い

返せる型は1つだけ

補足

この辞書が使われているページ

引数位置との意味の違い

返せる型は1つだけ

補足

Footnotes

この辞書が使われているページ