Support custom `FromStr` error types

[rossmacarthur]

It would be cool to if it was possible to specify a custom error type for the FromStr implementation.
I think it could either be of the form struct Error; or struct Error(String); where in the latter it would be passed a copy of the string that we attempted to parse.

use thiserror::Error;
use parse_display::FromStr;

#[derive(Debug, Error)]
#[error("expected one of `var_a` or `var_b`, got `{}`", self.0)]
pub struct ParseMyEnumError(String);

#[derive(Display, FromStr, PartialEq, Debug)]
#[display(style = "snake_case", error = ParseMyEnumError)]
enum MyEnum {
  VarA,
  VarB,
}

[frozenlib]

Sure, it's nice to be able to specify a custom error type.

I'm hoping to be able to pass not only the input string but also field names that fail to be parsed and source errors to custom error.
But I haven't come up with a good API design yet, so I will implement it once I have it.

[elpiel]

I actually prefer to have information on what failed (instead just, e.g. field ... parse failed.), if you need a custom message, you can always impl From<parse_display::EnumError> for ParseMyEnumError { .. }.

If all the ParseError kinds (e.g. EnumError) provide all the necessary information then, this approach looks appealing to me:

use thiserror::Error;
use parse_display::{FromStr, EnumError, Display};

#[derive(Debug, Error)]
#[error("expected one of `var_a` or `var_b`, got `{0.actual}`")]
pub struct ParseMyEnumError(#[from] EnumError);

#[derive(Display, FromStr, PartialEq, Debug)]
#[display(style = "snake_case", error = ParseMyEnumError)]
enum MyEnum {
  VarA,
  VarB,
}

Should be enough right?

[frozenlib]

I think it's a good idea to use From trait.

Just think there are a number of choices for the definition of the source type.

For example, if you want to use it with thiserror, as in the example above, it would be better to have the input string as owned string, as in the following

pub struct EnumError {
    pub actual: String,
}

However, the use of references is also an option, assuming performance and no_std support in the future.

pub struct EnumError<'a> {
    pub actual: &'a str,
}

Source error is similar, there is an option to use Box and an option to use generics.

[just-be-dev]

Is there some stopgap way of overriding the error message? Even if there wasn't fine grained control right now, being able to override it per derive would be a step in the right direction.