为什么我的Trait实现不匹配？

Question

如何使此代码编译？

trait Pair<'a, A, B> {
    fn first_ref(&'a self) -> &'a A;
    fn second_ref(&'a self) -> &'a B;
};

struct PairOwned<A, B> {
    first: A,
    second: B,
}

// Only implemented for the cases we are interested in ...
impl<'a, A, B> Pair<'a, A, B> for &'a PairOwned<&'a A,&'a B> {
    fn first_ref(&'a self) -> &'a A {
        self.first
    }
    fn second_ref(&'a self) -> &'a B {
        self.second
    }
}

impl<'a, A, B> Pair<'a, A, B> for &'a(&'a A, &'a B) {
    fn first_ref(&'a self) -> &'a A {
        self.0
    }
    fn second_ref(&'a self) -> &'a B {
        self.1
    }
}

fn pair_transformer<'a, I, T>(pairs: I) -> String
    where   T: Pair<'a, &'a Str, &'a Str> + 'a,
            I: Iterator<Item=T> {
    let mut s = String::new();
    for pair in pairs {
        s = s
            + pair.first_ref().as_slice()
            + pair.second_ref().as_slice();
    }
    s
}

pair_transformer([PairOwned { first: "a", second: "b" }].iter());
pair_transformer([("a", "b")].iter());

编译器说：

tests/lang.rs:902:5: 902:21 error: the trait `pair_trait_for_iteration::Pair<'_, &core::str::Str, &core::str::Str>` is not implemented for the type `&pair_trait_for_iteration::PairOwned<&str, &str>` [E0277]
 tests/lang.rs:902     pair_transformer([PairOwned { first: "a", second: "b" }].iter());
                      ^~~~~~~~~~~~~~~~
tests/lang.rs:903:5: 903:21 error: the trait `pair_trait_for_iteration::Pair<'_, &core::str::Str, &core::str::Str>` is not implemented for the type `&(&str, &str)` [E0277]
tests/lang.rs:903     pair_transformer([("a", "b")].iter());

笔记

我觉得这与指定应针对某个特性实施的各种方式有某种联系，而我对此尚未完全理解。

// As stated in the answer at 
// http://stackoverflow.com/questions/28283641/what-is-the-preferred-way-to-implement-the-add-trait-efficiently-for-vector-type
impl Add<YourType> for YourType { ... }
impl<'r> Add<YourType> for &'r YourType { ... }
impl<'a> Add<&'a YourType> for YourType { ... }
impl<'r, 'a> Add<&'a YourType> for &'r YourType { ... }

rustc 1.0.0-nightly (522d09dfe 2015-02-19) (built 2015-02-19)使用rustc 1.0.0-nightly (522d09dfe 2015-02-19) (built 2015-02-19)

Answer 1

您的代码中有几个错误：

• 您可能想直接为您的类型实现特征，因为特征定义的方法通过引用来获取特征（在链接的其他帖子中不是“ Add特征”的情况）
• 您实际上并未拥有对OwnedPair { first: "a", second: "b"}使用权OwnedPair { first: "a", second: "b"} ：您的类型将为OwnedPair<&'static str, &'static str>因此我在String包含了示例（已拥有）我以为那就是你想要的
• 迭代器返回的项实际上是引用，因此您可能希望将I绑定到Iterator<Item=&'a T>

当我尝试尽可能通用时（例如，使用OwnedPair<&str,&str>和OwnedPair<String,String>进行编译的示例），我使用了特性std :: OwnedPair<String,String> :: Borrow，这基本上意味着它是可以从实现此特征的类型中借用对类型T的引用。

我还需要使用?Sized作为大多数类型参数的绑定。 这允许使用大小在编译时未知的类型，并将在“胖指针”后面使用。 此博客文章中的更多信息（有点旧）

这是完整的更正代码（可在playpen中运行）

use std::borrow::Borrow;

trait Pair<'a, A: ?Sized, B: ?Sized> {
    fn first_ref(&'a self) -> &'a A;
    fn second_ref(&'a self) -> &'a B;
}

struct PairOwned<A, B> {
    first: A,
    second: B,
}

// Only implemented for the cases we are interested in ...
impl<'a, ARef: ?Sized, BRef: ?Sized, A: Borrow<ARef>, B: Borrow<BRef>> Pair<'a, ARef, BRef> for PairOwned<A,B> {
    fn first_ref(&'a self) -> &'a ARef {
        self.first.borrow()
    }
    fn second_ref(&'a self) -> &'a BRef {
        self.second.borrow()
    }
}

// It should also be possible to be more generic here with Borrow
// But I wanted to leave your original implementation
impl<'a, A: ?Sized, B: ?Sized> Pair<'a, A, B> for (&'a A, &'a B) {
    fn first_ref(&'a self) -> &'a A {
        self.0
    }
    fn second_ref(&'a self) -> &'a B {
        self.1
    }
}

fn pair_transformer<'a, I, T>(pairs: I) -> String
    where   T: Pair<'a, str, str> + 'a,
            I: Iterator<Item=&'a T> {
    let mut s = String::new();
    for pair in pairs {
        s = s
            + pair.first_ref().as_slice()
            + pair.second_ref().as_slice();
    }
    s
}

fn main() {
    pair_transformer([PairOwned { first: "a".to_string(), second: "b".to_string() }].iter());
    pair_transformer([PairOwned { first: "a".to_string(), second: "b" }].iter()); // It is even possible to mix String and &str
    pair_transformer([PairOwned { first: "a", second: "b" }].iter());
    pair_transformer([("a", "b")].iter());
}