Rust: Implement trait “From” for associated type (Error)

Question

This is a follow-up question on my previous question: Rust: Read and map lines from stdin and handling different error types

I have created the following struct and function to read lines from stdin and parse them into integers and it works:

use std::io::BufRead;
use std::{io, num, str};

#[derive(Debug)]
enum InputError {
    IOError(io::Error),
    ParseIntError(num::ParseIntError),
}

impl From<io::Error> for InputError {
    fn from(e: io::Error) -> InputError {
        return InputError::IOError(e);
    }
}

impl From<num::ParseIntError> for InputError {
    fn from(e: num::ParseIntError) -> InputError {
        return InputError::ParseIntError(e);
    }
}

pub fn get_integer_lines<T>() -> Result<Vec<T>, InputError>
where
    T: str::FromStr,
{
    let stdin = io::stdin();
    let my_values: Result<Vec<_>, InputError> = stdin
        .lock()
        .lines()
        .map(|line| -> Result<T, InputError> { Ok(line?.parse::<T>()?) })
        .collect();
    my_values
}

Now, I thought that I would replace u32 for a type parameter T to allow for any kind of numeric type. To do this I assume that I need to restrict T to types implementing the FromStr trait and then somehow implement the From trait to allow conversion from FromStr::Err into my "InputError".

Following the error I first got

error[E0277]: `?` couldn't convert the error to `InputError`
  --> src/lib.rs:30:69
   |
30 |         .map(|line| -> Result<T, InputError> { Ok(line?.parse::<T>()?) })
   |                                                                     ^ the trait `std::convert::From<<T as std::str::FromStr>::Err>` is not implemented for `InputError`
   |
   = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
   = help: consider adding a `where InputError: std::convert::From<<T as std::str::FromStr>::Err>` bound
   = note: required by `std::convert::From::from`

I tried something like this:

impl std::convert::From<<T as std::str::FromStr>::Err> for InputError {
    fn from(e: <T as std::str::FromStr>::Err) -> InputError {
        return InputError::ParseIntError(e)
    }
}

But that instead results in:

error[E0412]: cannot find type `T` in this scope
  --> src/lib.rs:22:26
   |
22 | impl std::convert::From<<T as std::str::FromStr>::Err> for InputError {
   |                          ^ not found in this scope

So basically what I want to express is something along the lines of: "I want to implement the trait From<T::Err> for my InputError for every T which also implements FromStr. Is this even possible and if so, how?

Peter Hall Peter Hall · Accepted Answer · 2019-12-06T19:57:36

So basically what I want to express is something along the lines of: "I want to implement the trait From<T::Err> for my InputError for every T which also implements FromStr. Is this even possible and if so, how?

This isn't what the error is saying.

The trait FromStr has an associated type, Err. The error is saying that this associated error type cannot be converted to InputError.

First, let's simplify by getting rid of the type parameters:

fn get_integer_lines() -> Result<Vec<u32>, InputError> {
    let stdin = io::stdin();
    let my_values = stdin
        .lock()
        .lines()
        .map(|line| Ok(line?.parse()?))
        .collect();
    my_values
}

This works!

The associated Err type for u32's FromStr implementation is ParseIntError and you have correctly implemented From<ParseIntError> for InputError.

The reason this doesn't work for T is because T's FromStr::Err type could be anything. By using a type parameter, you are telling the compiler that you expect this function to work for any possible type T, but it only works for types where FromStr::Err can be converted to your InputError type.

The error message gives you a hint:

= help: consider adding a `where InputError: std::convert::From<<T as std::str::FromStr>::Err>` bound

So let's do that:

fn get_integer_lines<T>() -> Result<Vec<T>, InputError>
where
    T: str::FromStr,
    InputError: From<<T as str::FromStr>::Err>,
{
    let stdin = io::stdin();
    let my_values = stdin
        .lock()
        .lines()
        .map(|line| Ok(line?.parse()?))
        .collect();
    my_values
}

This tells the compiler that you expect the function to work for all possible T provided that:

T implements FromStr and,
the associated Err type from T's FromStr implementation can be converted into an InputError

Rust: Implement trait “From” for associated type (Error)

1 Answers