闭包参数上未使用的类型参数

Question

这行得通：

struct Foo<T, F>
where
    F: Fn() -> Option<T>,
{
    f: F,
}

但这给了我编译错误：

struct Bar<I, T, F>
where
    F: Fn(I) -> Option<T>,
{
    f: F,
}

error[E0392]: parameter `I` is never used
 --> src/lib.rs:1:12
  |
1 | struct Bar<I, T, F>
  |            ^ unused parameter
  |
  = help: consider removing `I`, referring to it in a field, or using a marker such as `std::marker::PhantomData`

error[E0392]: parameter `T` is never used
 --> src/lib.rs:1:15
  |
1 | struct Bar<I, T, F>
  |               ^ unused parameter
  |
  = help: consider removing `T`, referring to it in a field, or using a marker such as `std::marker::PhantomData`

为什么在闭包的返回类型中使用类型参数可以，但在其参数中却不行？

我可以通过将闭包存储为特征对象来解决它：

struct Bar<I, T> {
    f: Box<Fn(I) -> Option<T>>,
}

但如果可能的话，我想避免这种情况。

Answer 1

作为@VladimirMatveev says，闭包的返回类型是关联类型。

关联类型与类型参数不同，因为它的值是在您实现一个特征时确定的，而不是在您在调用中使用它时确定的。
在Fn(I) -> Option<T> 中，一旦你有了输入（I 类型）和实现（在你传递的闭包中定义的特定操作），Option<T> 输出就确定了。

但对于I，情况有所不同。您需要使用结构中的类型，或者通过PhantomData 字段向编译器显示理论上如何使用。

use std::marker::PhantomData;

struct Bar<I, T, F>
where
    F: Fn(I) -> Option<T>,
{
    f: F,
    _marker: PhantomData<I>,
}

PhantomData 仅用于检查类型，但在生成的代码中会被擦除，因此它不会占用结构中的任何内存（这就是它是幻像的原因）。

需要它的原因在RFC 738 on variance中有详细解释。我会尝试在这里给你一个更短的（希望是正确的）版本。

在 Rust 中，您可以在大多数情况下（但并非总是如此！）在预期较短的情况下使用较长的生命周期。

fn foo<'short, 'long>(_a: &'short i32, b: &'long i32)
where
    'long: 'short,
{
    let _shortened: &'short i32 = b; // we're binding b to a shorter lifetime
}

fn foo2<'short, 'long>(_a: &'short i32, b: &'long Cell<&'long i32>)
where
    'long: 'short,
{
    let _shortened: &Cell<&'short i32> = b;
}

(playground)

RFC 解释了为什么 Cell 期望完全相同（而不是更长）的生命周期，但现在我建议您相信编译器，允许 foo2 编译是不安全的。

现在假装你有一个

struct Foo<T> { t: T }

T 可以是任何东西，包括保存引用的类型。
特别是，T 可以是 & i32 之类的类型，也可以是 &Cell<&i32> 之类的类型。
与我们上面的 foo 函数一样，Rust 可以通过检查 T (playground) 的类型来推断它可以或不能允许我们分配更短的生命周期。

但是，当您有一个未使用的类型参数时，推理没有任何需要检查的字段来了解它应该如何允许该类型在生命周期内表现。

如果你有

struct Foo<T>; // unused type parameter!

Rust 要求您使用 PhantomType 指定您是否希望您的 T 表现得像 & i32 或 Cell。你会写：

struct Foo<T> {
    marker: PhantomData<T>, // this is what you usually want
                            // unless you're working with unsafe code and
                            // raw pointers
}

或者你可以写：

struct Foo<T> {
    marker: PhantomData<Cell<T>>
}

Answer 2

通过 trait 对象使用动态调度的另一种方法是为此使用 std::marker::PhantomData：

use std::marker::PhantomData;

struct Bar<I, T, F>
where
    F: Fn(I) -> Option<T>,
{
    f: F,
    _i: PhantomData<I>,
    _t: PhantomData<T>,
}

(playground)

您只需使用PhantomData“实例化”PhantomData，例如

let phantom: PhantomData<T> = PhantomData;