structをnewする時にannotationsを要求されるが指定方法がわからない

Question

構造体生成時にFが要求されますが指定方法がわかりません。

下記に問題を単純化したコードを載せています。

fn func_a<T: AsRef<[u8]>>(input: T) -> Vec<u8> {
   unimplemented!()
}

struct Worker<F: Fn(&[u8]) -> Vec<u8>> {
    func: F,
}

impl<F: Fn(&[u8]) -> Vec<u8>> Worker<F> {
    fn new() -> Self {
        Worker {
            func: |x| func_a(x),
        }
    }
}

fn main() {
    // let worker = Worker::<F>::new();
    let worker = Worker::new();
}

Playground1
Playground2 -duck typing=
Playground3

恐らくWorker::<F>::new()のような形で指定すると思われますがどのように書けばいいのかわかりません。何かわかる方は回答の方をよろしくお願いします。

追記 6/24

元のコードPlayground1ではmain()を除いてもコンパイルできませんでした。そこでDuck typingを用いたオリジナルのコードにさらに近づけて修正しました。

さらに追記

Duck typingが問題に絡んでいると思っていましたが関係なかったので修正を戻しました。

Comments

[tatsuya6502]

new() 関連関数の本体に Main という構造体が出てきますが、Self の間違いでしょうか？　コードの修正をお願いします。

[namuyan]

簡単な型ミスを直したところコンパイル通らず、上手くいかない原因はDuck typingを除いたことにあると思ってしまったのですが余計な修正をしてしまいましたね。

Answer 1

こんにちは。提示されたコードはジェネリクスパラメータの指定以外にもコンパイルが通らない箇所があるので、それを直したコードがこちらになります。

fn func_a<T: AsRef<[u8]>>(input: T) -> Vec<u8> {
    unimplemented!()
}

struct Worker<F: Fn(&[u8]) -> Vec<u8>> {
    func: F,
}

impl<F: Fn(&[u8]) -> Vec<u8>> Worker<F> {
    fn new() -> Self {
        Self {
            func: |x| func_a(x),
        }
    }
}

fn main() {
    // let worker = Worker::<F>::new();
    let worker = Worker::new();
}

これをベースに回答します。
Worker::new は内部でクロージャを生成しているので、それに対応する型はただ1つです。
一方、 impl Worker では F を型パラメータで受け取っているので、外部から渡されるあらゆる型への対応が求められます。この2点が矛盾しているのでコンパイルエラーになっています。
これを解決する一般的方法が2つ、そして今回提示されたサンプルコードのみで使えるテクニックが1つあります。

1. ジェネリクスパラメータをやめる

Worker をジェネリクスにするのをやめて、トレイトオブジェクトを作れば問題は起きなくなります。そのときのコードはこちら

fn func_a<T: AsRef<[u8]>>(input: T) -> Vec<u8> {
    unimplemented!()
}

// ジェネリクスでない
struct Worker {
    // トレイトオブジェクトにする
    func: Box<dyn Fn(&[u8]) -> Vec<u8>>,
}

impl Worker {
    fn new() -> Self {
        Self {
            func: Box::new(|x| func_a(x)),
        }
    }
}

fn main() {
    // let worker = Worker::<F>::new();
    let worker = Worker::new();
}

トレイトオブジェクトについて分からなかったら公式ドキュメントがありますが、いささか分かりづらいかもしれません

2. impl Worker をやめる

「返り値の型が唯一決まっている」場合には impl Trait 構文が使えます。ただし、ジェネリクス構造体の impl には使えないので、 Worker::new を独立した関数として定義してあげます。

fn func_a<T: AsRef<[u8]>>(input: T) -> Vec<u8> {
    unimplemented!()
}

struct Worker<F: Fn(&[u8]) -> Vec<u8>> {
    func: F,
}

// 独立した関数として定義すると `Worker` のパラメータに `impl Fn` と書ける
fn new_worker() -> Worker<impl Fn(&[u8]) -> Vec<u8>> {
    Worker {
        func: |x| func_a(x),
    }
}

fn main() {
    // let worker = Worker::<F>::new();
    let worker = new_worker();
}

3. fn() 型を使う

今回の例に限って言えば Worker::new の中で作っているクロージャは、環境にある変数をキャプチャしていません。そのような場合にはクロージャを fn() （プリミティブの関数）にキャストできます。
その機能を用いてこう書けます。

fn func_a<T: AsRef<[u8]>>(input: T) -> Vec<u8> {
    unimplemented!()
}

struct Worker<F: Fn(&[u8]) -> Vec<u8>> {
    func: F,
}

// Workerのパラメータを Fn （トレイト） ではなく fn （プリミティブの型）にする
impl Worker<fn(&[u8]) -> Vec<u8>> {
    fn new() -> Self {
        Worker {
            func: |x| func_a(x),
        }
    }
}

fn main() {
    // let worker = Worker::<F>::new();
    let worker = Worker::new();
}

以上のどれかで解決するのではないかと思われます。
適切に問題を解決すると思われる順に並べたつもりです。

1は一番汎用性が高いですが、トレイトオブジェクトを作っているので若干のオーバーヘッドが乗ります。
2はオーバーヘッドは乗りませんが、 new に関する問題だけをアドホックに解決したので他の箇所でも同様の問題が起きる可能性があります。私見ですが Worker という名前からして他の箇所でも同様の問題が起きる確率は多そうに見えます。
3はオーバーヘッドなく実現できていますが、今回の例に限った解決策です。クロージャの定義を変えただけで動かなくなる可能性があります。

以上のどれかで解決すれば幸いです。

Comments

[namuyan]

申し訳ありません、ちょうど修正作業と回答が重なってしまったようです。もちろんこちらの回答も読ませていただきます。

[tatsuya6502]

2. のようにすると impl Trait 構文が使えるんですね。勉強になりました！

[YufanLou]

3のようにも具体的な型を使えますね。勉強になりました！

Answer 2

MainをSelfに修正すれば、こういうエラーが出ます：

error[E0308]: mismatched types
  --> src/main.rs:12:19
   |
9  | impl<F: Fn(&[u8]) -> Vec<u8>> Worker<F> {
   |      - this type parameter
...
12 |             func: |x| func_a(x),
   |                   ^^^^^^^^^^^^^ expected type parameter `F`, found closure
   |
   = note: expected type parameter `F`
                     found closure `[closure@src/main.rs:12:19: 12:32]`

expected type parameter F, found closure

「型引数Fを期待しているが、closureを見つけた」と述べています。なぜなら、Fを型引数にして、funcをFにすれば、funcも引数にしなければなりません。例えば、このコードも同じエラーを出します：

use std::fmt::Debug;

struct S<T: Debug> {
    d: T
}

impl<T: Debug> S<T> {
    fn new() -> Self {
        S {
            d: 8
        }
    }
}

一番簡単な解決法は、newをimplの外で定義すれば良いです。

fn func_a<T: AsRef<[u8]>>(input: T) -> Vec<u8> {
   unimplemented!()
}

struct Worker<F: Fn(&[u8]) -> Vec<u8>> {
    func: F,
}

fn new_worker() -> Worker<impl Fn(&[u8]) -> Vec<u8>> {
    Worker { func: |x| func_a(x) }
}

fn main() {
    let worker = new_worker();
    (worker.func)(&[3]);
}

もしただfunc_aをWorkerに置きたいのなら、型引数を除いて、関数ポインタ型のfnを使えばいいと思います。

fn func_a<T: AsRef<[u8]>>(input: T) -> Vec<u8> {
   unimplemented!()
}

struct Worker {
    func: fn(&[u8]) -> Vec<u8>,
}

impl Worker {
    fn new() -> Self {
        Self {
            func: |x| func_a(x),
        }
    }
}

fn main() {
    let worker = Worker::new();
    let worker1 = Worker { func: |x| Vec::new() };
}

ご覧の通り、closureが外の変数を使わなければ、関数ポインタのように使えます。

もちろん、関数ポインタを直接に使うこともできます。

fn func_a<T: AsRef<[u8]>>(input: T) -> Vec<u8> {
   unimplemented!()
}

fn use_func(func: fn(&[u8]) -> Vec<u8>) {
    let v = func(&[3]);
}

fn main() {
    use_func(|x| func_a(x));
}

Workerをstructではなく、traitにする書き方もあります。そうすれば、Workerを trait object として使えます。そしてそれぞれのimplに違うデータを付けることが可能です。

fn func_a<T: AsRef<[u8]>>(input: T) -> Vec<u8> {
   unimplemented!()
}

trait Worker {
    fn func(&self, input: &[u8]) -> Vec<u8>;
}

struct WorkerImpl(u8);

impl Worker for WorkerImpl {
    fn func(&self, input: &[u8]) -> Vec<u8> {
        let data = self.0;
        func_a(input)
    }
}

fn use_worker(w: Box<dyn Worker>) {
    let v = w.func(&[3]);
}

fn main() {
    let worker = Box::new(WorkerImpl) as Box<dyn Worker>;
    use_worker(worker);
}

本気でclosureが必要だとしたら、Boxでclosureをヒープに置ければ大丈夫です。こちらもdynキーワードでclosureを trait object にしています。

fn func_a<T: AsRef<[u8]>>(input: T) -> Vec<u8> {
   unimplemented!()
}

struct Worker {
    func: Box<dyn Fn(&[u8]) -> Vec<u8>>,
}

impl Worker {
    fn new() -> Self {
        Self {
            func: Box::new(|x| func_a(x))
        }
    }
    fn with_func(func: Box<dyn Fn(&[u8]) -> Vec<u8>>) -> Self {
        Self {
            func
        }
    }
}

fn main() {
    let worker1 = Worker::with_func(Box::new(|x| Vec::new()));
    (worker1.func)(&[3]);
    let worker = Worker::new();
    (worker.func)(&[3]);
}

長いですが、お役に立てたら幸いです。

---

修正 2020-06-24：
用語：「関数指針」を「関数ポインタ」に修正しました。

Comments

[blackenedgold]

関数指針は関数ポインタのことでしょうか。

[YufanLou]

そうです。中国語で「pointer」を「指針」に訳して、そのまま使えてしまいました????。ご指摘ありがとうございます。

Answer 3

質問のコードに Main という構造体が出てきますが、Selfの間違いだと仮定して回答します。

質問のコードをコンパイルすると2つのエラーが出ます。

• 型の不一致のエラー（E0308）
• 型推論のエラー（E0284）

E0308を直すと、E0284は自然に解消します。

error[E0308]: mismatched types
  --> src/main.rs:12:19
   |
9  | impl<F: Fn(&[u8]) -> Vec<u8>> Worker<F> {
   |      - this type parameter
...
12 |             func: |x| func_a(x),
   |                   ^^^^^^^^^^^^^ expected type parameter `F`, found closure
   |
   = note: expected type parameter `F`
                     found closure `[closure@src/main.rs:12:19: 12:32]`
   = help: type parameters must be constrained to match other types
   = note: for more information, visit https://doc.rust-lang.org/book/ch10-02-traits.html#traits-as-parameters

関連関数new()の戻り値型はSelf（Worker<F>）ですので、ジェネリクスの型パラメータFを含んでます。そしてFの具体的な型はnew()を呼び出す側で決まります。つまり、new()は呼び出し側が求める、どんなWorker<何かの型>でも返せなければなりません。

一方、|x| func_a(x)は具体的な型を持ちます。もしこれがコンパイルできたとすると、new()の戻り値はWorker<具体的な一つの型>になり、Selfと矛盾してしまいます。そのため型不一致のエラーE0308になるわけです。

解決法としては2つあると思います。

1. クロージャをnew()の外側から与える
2. Worker.funcをジェネリクスの型パラメータではなく、具体的な型にする

1. クロージャをnew()の外側から与える

new()の中でクロージャを作るのではなく、F型の引数としてとるようにします。

impl<F: Fn(&[u8]) -> Vec<u8>> Worker<F> {
    fn new(func: F) -> Self {
        Self { func }
    }
}

fn main() {
    let worker = Worker::new(|x| func_a(x));
}

2. Worker.funcを具体的な型にする

Worker構造体のfuncフィールドの型を、ジェネリクスの型パラメータではなく、具体的な型にします。

|x| func_a(x)は具体的な型を持ちますが、コンパイラが内部的に作成する匿名型なので、ソースコードで型を指定することはできません。

しかし、このクロージャをよく見ると自由変数がありません（外側にある変数を環境にキャプチャしていません）　こういうクロージャは普通の関数と同じように扱えますので、関数ポインタ型fn(&[u8]) -> Vec<u8>へと型強制できます。

struct Worker {
    // ジェネリクス（Fnトレイトを実装した何かのクロージャ型）ではなく
    // 具体的な型（関数ポインタ型）にする
    func: fn(&[u8]) -> Vec<u8>,
}

impl Worker {
    fn new() -> Self {
        Self {
            // 自由変数を持たないクロージャは関数ポインタ型に型強制できる
            func: |x| func_a(x),
        }
    }
}

fn main() {
    let worker = Worker::new();
}

Comments

[namuyan]

申し訳ありません、ちょうど修正作業と回答が重なってしまったようです。もちろんこちらの回答も読ませていただきます。

[namuyan]

funcをより具体的な型に落とし込むこと(Worker.funcを具体的な型にする)で解決しました。ありがとうございました！