Il tipo di risultato non implementa il metodo nell'ambito denominato `unwrap`

Question

Per qualche motivo, il compilatore di Rust si lamenta che lo Result non implementa unwrap, anche se il tipo di errore I fornito implementa Debug. Il codice che genera errori è fornito di seguito.

use std::fmt::{Display, Debug}; 
use std::error::Error; 

trait MyError: Error + Display + Debug {} 
type MyResult<T> = Result<T, MyError>; 

trait Foo: Clone {} 

trait MyTrait { 
    fn my_function<T: Foo>(&self) -> MyResult<T>; 

    fn unwrap_function<T: Foo>(&self) -> T { 
     self.my_function().unwrap() 
    } 
} 

Answer 1

Quando si definisce il tipo di

type MyResult<T> = Result<T, MyError>; 

in effetti si definisce il tipo di essere un unsized type come MyError non è un tipo concreto, ma un tratto. Ma, l'attuazione di Result<T, E> afferma

impl<T, E> Result<T, E> where E: Debug { 
    /* ... */ 
} 

che richiede implicitamente E essere un tipo di dimensioni. Quindi, nel tuo caso, in quanto non lo è, l'implementazione non è valida e non è disponibile (in realtà, la maggior parte se non tutta l'implementazione di Result<T, E> richiede T e E da dimensionare, quindi un valore non aggiornato Result non è molto utile).

La correzione più semplice nel tuo caso è quello di mettere il vostro errore in un Box, come questo:

type MyResult<T> = Result<T, Box<MyError>>;