Struct FromStrParser 

pub struct FromStrParser<T> { /* private fields */ }

Generic parser implementation for any type that implements FromStr trait

This parser consumes exactly one token and parses it using the target type’s FromStr implementation for producing the parser’s result. Note, that on failure, the error value is discarded. FromStrParser does not recognize any attributes and does not yield any completion suggestions.

Note, that there is no blanket implementation of Parsable that uses this parser implementation. If you want to use this implementation for any custom type, you must either implement Parsable for it or specify this parser explicitly when performing parsing or completion.

The implementation is similar to IntegerParser with the only difference being more specific error handling by the IntegerParser.

Example

The following example demonstrates how to use FromStrParser for custom types that implement FromStr:

use cmdparse::parsers::FromStrParser;
use cmdparse::{parse, Parsable};
use std::str::FromStr;

#[derive(Debug, PartialEq, Eq, Copy, Clone)]
enum MyBool {
    Yes,
    No,
}

impl FromStr for MyBool {
    type Err = (); // the error type is discarded by the parser

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "yes" => Ok(MyBool::Yes),
            "no" => Ok(MyBool::No),
            _ => Err(()),
        }
    }
}

impl<Ctx> Parsable<Ctx> for MyBool {
    type Parser = FromStrParser<Self>;
}

assert_eq!(parse::<_, MyBool>("yes", ()), Ok(MyBool::Yes));
assert_eq!(parse::<_, MyBool>("no", ()), Ok(MyBool::No));

Trait Implementations

impl<T: Clone> Clone for FromStrParser<T>

fn clone(&self) -> FromStrParser<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for FromStrParser<T>

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

Formats the value using the given formatter.

impl<T> Default for FromStrParser<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: FromStr, Ctx> Parser<Ctx> for FromStrParser<T>

type Value = T

The type that this parser will parse the input stream into.

fn parse<'a>( &self, input: TokenStream<'a>, _ctx: Ctx, ) -> ParseResult<'a, Self::Value>

Parsers the beginning of the token stream into a Value.

fn complete<'a>( &self, input: TokenStream<'a>, _ctx: Ctx, ) -> CompletionResult<'a>

Constructs the completion suggestions for the last token of the input stream

impl<T: Copy> Copy for FromStrParser<T>