rust - ps4 - ¿Cómo puedo usar std:: convert:: into para convertir algo que podría fallar?

rust traduccion

Question

Me gustaría una función que acepte una variedad de tipos que se pueden convertir a mi tipo específico. En casos similares, usaría std::convert::Into (o std::convert::From ):

pub struct MyThing;
impl<''a> Into<MyThing> for &''a str {
fn into(self) -> MyThing {
MyThing
}
}
fn main() {}

Como una arruga adicional, en mi caso específico, la conversión puede fallar. Normalmente, usaría Result para representar una operación que puede fallar. Combinando los dos conceptos juntos:

pub struct MyThing;
pub struct Error;
impl<''a> Into<Result<MyThing, Error>> for &''a str {
fn into(self) -> Result<MyThing, Error> {
if self.len() % 2 == 0 {
Ok(MyThing)
} else {
Err(Error)
}
}
}
fn main() {}

Desafortunadamente, esto parece estar en conflicto con las reglas de coherencia:

error: the impl does not reference any types defined in this crate;
only traits defined in the current crate can be implemented for
arbitrary types [E0117]

Veo que podría crear mi propio rasgo específico:

struct MyThing;
struct Error;
trait IntoMyThing {
fn into(self) -> Result<MyThing, Error>;
}
impl<''a> IntoMyThing for &''a str {
fn into(self) -> Result<MyThing, Error> {
if self.len() % 2 == 0 {
Ok(MyThing)
} else {
Err(Error)
}
}
}
fn main() {}

O incluso un rasgo más genérico:

struct MyThing;
struct Error;
trait MaybeInto<T, E> {
fn into(self) -> Result<T, E>;
}
impl<''a> MaybeInto<MyThing, Error> for &''a str {
fn into(self) -> Result<MyThing, Error> {
if self.len() % 2 == 0 {
Ok(MyThing)
} else {
Err(Error)
}
}
}
fn main() {}

Pero, ¿hay alguna forma de reutilizar componentes de la biblioteca estándar para lograr mi objetivo?

Answer 1

Esto no es posible debido a las reglas de coherencia, lo que hace que esto sea bastante incómodo, ya que no puede hacerlo a menos que cree un nuevo tipo para uno de los tipos, ya sea el Result o la &str . Ver RFC # 1023 para más información.

En resumen, de acuerdo con las nuevas reglas estipuladas por ese RFC, no puede implementar un rasgo que no sea local en el cajón para un tipo que no sea local para el cajón.

1. Modifique las reglas huérfanas para que las impls de rasgos remotos requieran un tipo local que sea una estructura / enum / rasgo definido en la caja actual LT = LocalTypeConstructor<...> o una referencia a un tipo local LT = ... | &LT | &mut LT LT = ... | &LT | &mut LT LT = ... | &LT | &mut LT .

Entonces, como no creó el rasgo Into en su cajón ni el tipo Result , obtiene este error. Crear un nuevo tipo corrige esto porque básicamente ajusta un tipo no local en un tipo local.