Question

我正在为C库编写一个Rust绑定。它实现了一个可以从不同源实体构造的实体，可能在内部保存了一些引用。我希望Rust类型强制执行安全的所有权策略，因此包装器结构是通用的，由存储的引用类型参数化。

struct Foobar<T> {
    origin: T,
}

然后我为Foobar类型实现了一些构造函数。

impl<T> Foobar<T> {
    fn from_nowhere() -> Foobar<()> {
        Foobar { origin: () }
    }

    fn from_orange<F>(orange: &mut F) -> Foobar<&mut F>
        where F: Orange
    {
        Foobar { origin: orange }
    }

    fn from_callback<F>(callback: F) -> Foobar<F>
        where F: FnMut(u64) -> u64
    {
        Foobar { origin: callback }
    }
}

问题出现了：结构和构造函数都是独立参数化的。虽然可以从其参数推断构造函数类型参数，但构造函数中不使用struct type参数，也无法推断它。因此，调用构造函数的天真方式

let a = Foobar::from_nowhere();
let b = Foobar::from_orange(&mut fruit);
let c = Foobar::from_callback(|x| x*x);

混淆rustc：

    rustgen.rs:43:13: 43:33 error: unable to infer enough type information about `_`; type annotations required [E0282]
    rustgen.rs:43     let a = Foobar::from_nowhere();

可以通过提供一些任意类型参数来修复：

let a = Foobar::<()>::from_nowhere();
let b = Foobar::<()>::from_orange(&mut fruit);
let c = Foobar::<()>::from_callback(|x| x*x);

......这是各种丑陋的。解决问题的另一种方法是将构造函数转换为自由函数，尽管它（有点）是非惯用函数。

问题是，我错过了什么吗？设计似乎在某种程度上存在缺陷。设计这种类型的唯一方法是什么才能逃脱只有一个级别的泛型？

Minimal reproducible example on Rust playpen

作为参考，我的编译器版本是：

$ rustc --version
rustc 1.1.0-dev (built 2015-04-26)

Answer 1

据我了解，您的原始代码是在T上参数化的，但您有方法需要指定参数。诀窍是没有针对这些情况的通用。相反，尝试为每个有趣的类型创建专门的实现：

// this is just an example. suppress unrelated warnings
#![allow(dead_code, unused_variables)]

struct Foobar<T> {
    origin: T,
}

trait Orange {}

struct Grapefruit;

impl Orange for Grapefruit {}

impl Foobar<()> {
    fn from_nowhere() -> Foobar<()> {
        Foobar { origin: () }
    }
}

impl<'a, F> Foobar<&'a mut F>
    where F: Orange
{
    fn from_orange(orange: &'a mut F) -> Foobar<&'a mut F> {
        Foobar { origin: orange }
    }
}

impl<F> Foobar<F>
    where F: FnMut(u64) -> u64
{
    fn from_callback(callback: F) -> Foobar<F> {
        Foobar { origin: callback }
    }
}

fn main() {
    let mut fruit = Grapefruit;

    // What I actually wanted to do
    let a1 = Foobar::from_nowhere();
    let b1 = Foobar::from_orange(&mut fruit);
    let c1 = Foobar::from_callback(|x| x*x);
}

泛型类型的泛型构造函数的显式类型注释

1 个答案: