即使实现了Trait <＆str>，为什么仍无法满足特质绑定的Trait <＆String>？

Question

I have written the following code:

pub struct Serializer;

pub trait Serialize<T> {
    fn to_bert(&self, data: T) -> Vec<u8>;
}

pub trait Convert<T> {
    fn to_binary(&self, data: T) -> Vec<u8>;
}

impl<'a> Convert<&'a str> for Serializer {
    fn to_binary(&self, data: &'a str) -> Vec<u8> {
        let binary_string = data.as_bytes();
        let binary_length = binary_string.len() as i16;
        let mut binary = vec![];
        binary.write_i16::<BigEndian>(binary_length).unwrap();
        binary.extend(binary_string.iter().clone());
        binary
    }
}

impl Serialize<String> for Serializer {
    fn to_bert(&self, data: String) -> Vec<u8> {
        let binary_string = self.to_binary(&data);
        self.generate_term(BertTag::String, binary_string)
    }
}

impl<'a> Serialize<&'a str> for Serializer {
    fn to_bert(&self, data: &'a str) -> Vec<u8> {
        let binary_string = self.to_binary(data);
        self.generate_term(BertTag::String, binary_string)
    }
}

When compiling, I receive an error which says the compiler cannot find the right function for a call:

error: the trait bound `serializers::Serializer: serializers::Convert<&std::string::String>` is not satisfied [E0277]
let binary_string = self.to_binary(&data);
                         ^~~~~~~~~
help: run `rustc --explain E0277` to see a detailed explanation
help: the following implementations were found:
help:   <serializers::Serializer as serializers::Convert<&'a str>>
help:   <serializers::Serializer as serializers::Convert<types::BertType>>

Why can the compiler not find the right implementation when I've specified &str with a lifetime? How can I fix this?

Answer 1

How can I fix this?

By getting a &str from data :

let binary_string = self.to_binary(&*data);

Like the error says, Convert<&String> is not implemented for Serializer , but Convert<&str> is. &data is a &String , but you need a &str , writing &*data produces a &str .

---

Note that in general (when the string is not changed) it should not be necessary to implement the same functionality for both String and &str , only the &str version should be enough. In your example, you can remove the Serialize<String> implementation for Serializer and use Serialize<&str> instead.

fn main() {
    let mut s = Serializer;
    let a: String = "a".to_string();
    // autoderef &String to &str and call Serialize<&str>::to_bert()
    // I don't know why the autoderef does not work in your original example
    s.to_bert(&a);
}