Enum Answer 

pub enum Answer<'a, T>
where
    T: Eq + PartialEq + Hash + Display,
{
    Yes(Option<&'a str>),
    No(Option<&'a str>),
    Retry(Option<&'a str>),
    Next(Option<&'a str>),
    Cancel(Option<&'a str>),
    UserDefined(T),
}

Answer

For variants which have an optional representation string:

• If you don’t provide the representation strings, defaults will be used.
• Implementations of Eq, PartialEq, Hash do NOT work on the representation strings.

For UserDefined:

• Implementations of Eq, PartialEq, Hash work on data you provide.

For example, if you want 2 answers of Resume and Ignore, but there are no such variants, you can do this:

use core::fmt::{self, Display, Formatter};
use dia_args::Answer;

#[derive(Debug, Eq, PartialEq, Hash)]
enum CustomAnswer {
    Resume,
    Ignore,
}

impl Display for CustomAnswer {

    fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
        f.write_str(match self {
            CustomAnswer::Resume => "Resume",
            CustomAnswer::Ignore => "Ignore",
        })
    }

}

match dia_args::ask_user(
    "What's your desire?",
    &[
        Answer::UserDefined(CustomAnswer::Resume),
        Answer::UserDefined(CustomAnswer::Ignore),
        Answer::Cancel(None),
    ],
)? {
    Answer::UserDefined(answer) => match answer {
        CustomAnswer::Resume => {},
        CustomAnswer::Ignore => {},
    },
    Answer::Cancel(_) => {},
    _ => {},
};

See also

ask_user().

Variants

Yes(Option<&'a str>)

Yes

No(Option<&'a str>)

No

Retry(Option<&'a str>)

Retry

Next(Option<&'a str>)

Next

Cancel(Option<&'a str>)

Cancel

UserDefined(T)

User-defined

Trait Implementations

impl<'a, T> Debug for Answer<'a, T>

where T: Eq + PartialEq + Hash + Display + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Display for Answer<'_, T>

where T: Eq + PartialEq + Hash + Display,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T> Hash for Answer<'_, T>

where T: Eq + PartialEq + Hash + Display,

fn hash<H>(&self, h: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> PartialEq for Answer<'_, T>

where T: Eq + PartialEq + Hash + Display,

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, T> Eq for Answer<'a, T>

where T: Eq + PartialEq + Hash + Display + Eq,