Rust Error: Size of Type `(dyn std::error::Error + 'static)` cannot be known at compilation time

I am aware that there are countless of similar questions regarding this error message. However I haven't found an answer to my error. First of all, allow me to explain my issue. This is the compiler error

error[E0277]: the size for values of type `(dyn std::error::Error + 'static)` cannot be known at compilation time
   --> src/category.rs:117:47
    |
117 |         "Time" => get_input::<Time>(help_msg, get_value::<Time>(default_value))?.to_string(),
    |                   -----------------           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
    |                   |
    |                   required by a bound introduced by this call
    |
    = help: the trait `Sized` is not implemented for `(dyn std::error::Error + 'static)`
    = help: the trait `std::error::Error` is implemented for `Box<T>`
    = note: required for `Box<(dyn std::error::Error + 'static)>` to implement `std::error::Error`

The important function signatures are the following two.

pub fn get_input<T: FromStr>(msg: &str, default_value: Option<T>) -> Result<T, Box<dyn Error>>
where
    T::Err: Error + 'static,
    T: std::fmt::Display,

and

fn get_value<T: FromStr>(value_str: &str) -> Option<T>
where
    T::Err: Error + 'static,

From what I understand, the error stems from the fact that the error type cannot be known at compile time,
I presume because it is using a String type as the error message?
Either way, the reason this is so confusing is because the code errors only for the custom struct Time,
but not for other built-ins

let value: String = match type_str {
    "u32" => get_input::<u32>(help_msg, get_value::<u32>(default_value))?.to_string(),
    "i32" => get_input::<i32>(help_msg, get_value::<i32>(default_value))?.to_string(),
    "f32" => get_input::<f32>(help_msg, get_value::<f32>(default_value))?.to_string(),
    "bool" => get_input::<bool>(help_msg, get_value::<bool>(default_value))?.to_string(),
    "String" => get_input::<String>(help_msg, get_value::<String>(default_value))?.to_string(),
    // This is the line that gives the compiler error
    "Time" => get_input::<Time>(help_msg, get_value::<Time>(default_value))?.to_string(),
    _ => "None".to_string(),
};

For completions sake, here is the struct I definied,
I presume that I have to change the error type but
I have no clue to what.

use std::error::Error;

pub struct Time {
    hour: u8,
    minute: u8,
}

impl Time {
    pub fn new(hour: u8, minute: u8) -> Time {
        Time { hour, minute }
    }
}

impl std::str::FromStr for Time {
    type Err = Box<dyn Error + 'static>;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let parts: Vec<&str> = s.split(':').collect();
        if parts.len() == 2 {
            let hour: u8 = parts[0].parse()?;
            let minute: u8 = parts[1].parse()?;
            Ok(Time::new(hour, minute))
        } else {
            Err("Invalid time format".into())
        }
    }
}

impl std::fmt::Display for Time {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:02}:{:02}", self.hour, self.minute)
    }
}

I am aware that I am code dumping here, but I really don't know how to fix this
issue at all. There are work arounds of course, but by this point, I really
want to know why this code is not working and how to fix the issue.

Any help is greatly appreciated.

The problem

pub fn get_input<T: FromStr>(msg: &str, default_value: Option<T>) -> Result<T, Box<dyn Error>>
where
    T::Err: Error + 'static,
    T: std::fmt::Display,

Here, T::Err: Error requires Box<dyn Error> to implement Error which makes intuitive sense. As this answer explains, though, for a Boxed Error to implement Error, it needs to be Sized, which trait objects (i.e. dyn Error) aren't.

Why is returning Box<dyn Error> so convenient in the first place? Because it allows you to use the ? operator to bubble up almost any kind of error.

let hour: u8 = parts[0].parse?;

desugars to

let hour: u8 = match parts[0] {
    Ok(v) => v,
    Err(e) => return Err(e.into()),
};

Note the e.into(). ? tries to convert the error you get into the error you'd like to return and there's a blanket impl that looks roughly like

impl<E: Error> From<E> for Box<dyn Error> { // ...

that makes this possible for any type that implements Error.

The manual solution

@alagner's answer certainly goes in the right direction but inherits some cruft from C++ you don't really need in Rust and omits some niceties that Rust provides. You can define a much simpler wrapper using a single new type:

#[derive(Debug)]
pub struct TimeError(Box<dyn Error>);

impl fmt::Display for TimeError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        // delegate formatting to the underlying error
        self.0.fmt(f)
    }
}

impl Error for TimeError {
    // the methods on the `Error` trait are deprecated and need not be implemented
}

Now you can make a new error like this: TimeError("Wrong length".into()) and it'll just work.

The problem with this is that now we can't use the ? operator anymore, because Into<TimeError> isn't implemented for any of the other errors we might like to bubble up. It would be nice if we could simply write

impl<E: Error> From<E> for TimeError {
    fn from(e: E) -> Self {
       Self(Box::new(e))
    }
}

but unfortunately, Rust's coherence rules won't let us. Error is implemented for TimeError so that blanket impl includes a impl From<TimeError> for TimeError but that impl already exists (because From<T> is implemented for every T). If you still want to use the ?, you'll have to manually implement From<E> for TimeError for every E that you want to propagate:

impl From<std::num::ParseIntError> for TimeError {
    fn from(e: std::num::ParseIntError) -> Self {
        Self(Box::new(e))
    }
}

If you end up needing to propagate a whole bunch of different errors (seems unlikely in this particular case, but anyways), you might want to generalize this using a little trait trick. You can define your own super trait of Error that TimeError doesn't implement, implement it for any E you want to be able to convert into a TimeError, then you can blanket impl From for any type that implements that trait:

trait ConvertibleError: Error {}

impl<E: ConvertibleError + 'static> From<E> for TimeError {
    fn from(e: E) -> Self {
        Self(Box::new(e))
    }
}


impl ConvertibleError for std::num::ParseIntError {}

Now, if you need to be able to propagate another kind of error E, you just need to add impl ConvertibleError for E {} and ? will work again, no need to explicitly write impl From<E> for TimeError.

Alternatively you can write a simple macro to write the From impl for you:

macro_rules! impl_from_err {
    ($($ty:ty),*) => {
        $(
            impl From<$ty> for TimeError {
                fn from(e: $ty) -> Self {
                    Self(Box::new(e))
                }
            }
        )*
    }
}

And call it like

impl_from_err!(std::num::ParseIntError/*, OtherError, DifferentError, etc */);

The convenient solution

The anyhow crate (other error handling libraries are available) provides its own Error type that works much like Box<dyn Error>. It allows you to bubble up pretty much any error you might encounter and it provides a convenient anyhow::anyhow! macro to create ad-hoc errors.

An aside

Your get_value function does basically nothing but turn a Result into an Option, which the standard library already has a method for: Result::ok:

fn get_value<T: FromStr>(value_str: &str) -> Option<T>
where
    T::Err: std::error::Error
{
    T::from_str(value_str).map_err(|e| eprintln!("{e:?}")).ok()
}

I'm by no means sure this is idiomatic (it's probably not), but what you can do is create custom Error type containing a Box of error types, say sth like a "private implementation" known from C++. Both inner and out have to implement Error trait. This way you can delegate the outer calls to the inner one:

use std::error::Error;
use std::fmt;
use std::str::FromStr;

pub struct Time {
    hour: u8,
    minute: u8,
}

#[derive(Debug)]
pub struct TimeError {
    err_impl : Box<dyn Error>
}


#[derive(Debug)]
struct TimeErrorImpl {
    what : String
}

impl fmt::Display for TimeErrorImpl {
    fn fmt(&self, f : &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.what)
    }
}

impl fmt::Display for TimeError {
    fn fmt(&self, f : &mut fmt::Formatter<'_>) -> fmt::Result {
        self.err_impl.fmt(f)
    }
}


impl Error for TimeErrorImpl {
    fn source(&self) -> Option<&(dyn Error + 'static)> { None }
    fn description(&self) -> &str { return &self.what; } 
}

impl Error for TimeError {
    fn source(&self) -> Option<&(dyn Error + 'static)> { None }
    fn description(&self) -> &str { return self.err_impl.description(); } 
}


impl Time {
    pub fn new(hour: u8, minute: u8) -> Time {
        Time { hour, minute }
    }
}

impl std::str::FromStr for Time {
    type Err = TimeError;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let parts: Vec<&str> = s.split(':').collect();
        if parts.len() == 2 {
            let hour: u8;
            match   parts[0].parse() {
                Ok(h) => hour = h,
                Err(er) => return Err(TimeError{err_impl:Box::new(er)})
            };
            let minute: u8;

            match   parts[1].parse() {
                Ok(m) => minute = m,
                Err(er) => return Err(TimeError{err_impl:Box::new(er)})
            };
            Ok(Time::new(hour, minute))
        } else {
            Err(TimeError{err_impl:Box::new(TimeErrorImpl{what : "Wrong length".to_string()})})
        }
    }
}

impl std::fmt::Display for Time {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:02}:{:02}", self.hour, self.minute)
    }
}

fn get_value<T: FromStr>(value_str: &str) -> Option<T>
where
    T::Err: Error + 'static
{
    match T::from_str(value_str) {
        Ok(x) => return Some(x),
        Err(e) => println!("{}", e)
    };
    return None;
}


fn main() {
    let _ : Option<i32> = get_value("32");
    let t : Option<Time> = get_value("ux:23:32"); //observe the message
    t.unwrap(); //crash here
}