Ich möchte mich spezialisieren&'static str von&'a str. Etwas wie das

use std::borrow::Cow;

struct MyString {
    inner: Cow<'static, str>,
}

impl From<&'static str> for MyString {
    fn from(x: &'static str) -> Self {
        MyString {
            inner: Cow::Borrowed(x),
        }
    }
}

impl<T: Into<String>> From<T> for MyString {
    fn from(x: T) -> Self {
        MyString {
            inner: Cow::Owned(x.into()),
        }
    }
}

fn main() {
    match MyString::from("foo").inner {
        Cow::Borrowed(..) => (),
        _ => {
            panic!();
        }
    }

    let s = String::from("bar");
    match MyString::from(s.as_ref()).inner {
        Cow::Owned(..) => (),
        _ => {
            panic!();
        }
    }

    match MyString::from(String::from("qux")).inner {
        Cow::Owned(..) => (),
        _ => {
            panic!();
        }
    }
}

as Wesentliche ist, dassMyString speichert ein statisch zugewiesenes Zeichenfolgenliteral als&'static str und alle anderen Zeichenfolgen alsString. Dies erlaubtMyString, um einen Lebensdauerkennwert zu vermeiden - d. h.MyString<'a>, das für meine API von entscheidender Bedeutung ist, während der Aufrufer jede Art von Zeichenfolge übergeben kann und @ hMyString automatisch das Richtige tun.

Das Problem ist, dass der Code nicht kompiliert wird:

error[E0119]: conflicting implementations of trait `std::convert::From<&'static str>` for type `MyString`:
  --> src/main.rs:15:1
   |
7  | impl From<&'static str> for MyString {
   | ------------------------------------ first implementation here
...
15 | impl<T: Into<String>> From<T> for MyString {
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `MyString`

Gibt es einen Trick, mit dem ich tun kann, was ich will? Wenn nicht, wird Rust die lebenslange Spezialisierung jemals unterstützen?