Rust中为何仅为T添加PhantomData时，含未用类型参数的代码可编译？

以下代码无法编译：

struct Mapper<T, U, F>
where
    F: Fn(T) -> U,
{
    mapper: F,
    // _t: PhantomData<T>,
    // _u: PhantomData<U>,
}

impl<T, U, F> Mapper<T, U, F>
where
    F: Fn(T) -> U,
{
    fn new(mapper: F) -> Self {
        Self {
            mapper,
            // _t: PhantomData,
            // _u: PhantomData,
        }
    }

    fn call(&self, t: T) -> U {
        (self.mapper)(t)
    }
}

编译器报错：

error[E0392]: parameter `T` is never used
 --> src/main.rs:3:15
  |
3 | struct Mapper<T, U, F>
  |               ^ unused parameter
  |
  = help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`
  = help: if you intended `T` to be a const parameter, use `const T: usize` instead

error[E0392]: parameter `U` is never used
 --> src/main.rs:3:18
  |
3 | struct Mapper<T, U, F>
  |                  ^ unused parameter
  |
  = help: consider removing `U`, referring to it in a field, or using a marker such as `PhantomData`
  = help: if you intended `U` to be a const parameter, use `const U: usize` instead

仅为T添加PhantomData标记时，代码可正常编译：

use std::marker::PhantomData;

struct Mapper<T, U, F>
where
    F: Fn(T) -> U,
{
    mapper: F,
    _t: PhantomData<T>,
    // _u: PhantomData<U>,
}

impl<T, U, F> Mapper<T, U, F>
where
    F: Fn(T) -> U,
{
    fn new(mapper: F) -> Self {
        Self {
            mapper,
            _t: PhantomData,
            // _u: PhantomData,
        }
    }

    fn call(&self, t: T) -> U {
        (self.mapper)(t)
    }
}

但若仅为U添加PhantomData标记，代码仍无法编译：

use std::marker::PhantomData;

struct Mapper<T, U, F>
where
    F: Fn(T) -> U,
{
    mapper: F,
    // _t: PhantomData<T>,
    _u: PhantomData<U>,
}

impl<T, U, F> Mapper<T, U, F>
where
    F: Fn(T) -> U,
{
    fn new(mapper: F) -> Self {
        Self {
            mapper,
            // _t: PhantomData,
            _u: PhantomData,
        }
    }

    fn call(&self, t: T) -> U {
        (self.mapper)(t)
    }
}

fn main() {
    let mapper = Mapper::new(|a: usize| -> isize { -(a as isize) });
    println!("{}", mapper.call(3));
}

请问出现这种编译结果差异的原因是什么？

Rust编译器要求结构体的所有类型参数必须被“使用”——要么直接出现在字段类型中，要么能通过已使用的参数和 trait 约束唯一确定。

1. 仅添加PhantomData<T>时能编译的原因 #

• T被PhantomData<T>直接使用，满足编译器对类型参数的使用要求，T的报错消失。
• 对于U，结构体有约束F: Fn(T) -> U：当T和F的类型确定后，U的类型是唯一固定的（因为Fn(T) -> U是F的 trait 实现，输入类型T确定时，输出类型U不会有歧义）。编译器会认为U是通过T和F间接被使用的，因此不会再报错U未被使用。

2. 仅添加PhantomData<U>时无法编译的原因 #

• U被PhantomData<U>直接使用，但T没有直接被使用。
• 此时约束F: Fn(T) -> U无法反向推导T的唯一性：同一个F和U可能对应多个不同的T（比如某个闭包可能被强制转换为多个不同的Fn(T) -> U类型，只要输出都是U）。编译器无法确定T是被间接使用的，因此仍然会报错T未被使用。

内容的提问来源于stack exchange，提问作者ynn