Enum IResult

pub enum IResult<I, O> {
    Done(I, O),
    Error,
}

The result of a parser.

Variants

Done(I, O)

Parsing succeeded. The first field contains the rest of the unparsed data and the second field contains the parse result.

Error

Parsing failed.

Implementations

impl<'a, O> IResult<ParseState<'a>, O>

pub fn expect(self, name: &str) -> O

Unwraps the result, asserting the the parse is complete. Panics with a message based on the given string if the parse failed or is incomplete.

extern crate syn;
#[macro_use] extern crate synom;

use syn::Ty;
use syn::parse::ty;

// One or more Rust types separated by commas.
named!(comma_separated_types -> Vec<Ty>,
    separated_nonempty_list!(punct!(","), ty)
);

fn main() {
    let input = "&str, Map<K, V>, String";

    let parsed = comma_separated_types(input).expect("comma-separated types");

    assert_eq!(parsed.len(), 3);
    println!("{:?}", parsed);
}

impl<'a, O: Eq> IResult<ParseState<'a>, O>

pub fn test_looks_like(&self, rest: &str, result: &O) -> bool

This function primarially exists for testing parsers. It returns true if the IResult “looks like” the passed in parameters. This means that the variant is IResult::Done, the ParseState::rest() of the input matches rest and the result matches.

Trait Implementations

impl<I: Clone, O: Clone> Clone for IResult<I, O>

fn clone(&self) -> IResult<I, O>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I: Debug, O: Debug> Debug for IResult<I, O>

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

Formats the value using the given formatter.

impl<I: PartialEq, O: PartialEq> PartialEq for IResult<I, O>

fn eq(&self, other: &IResult<I, O>) -> 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<I: Eq, O: Eq> Eq for IResult<I, O>

impl<I, O> StructuralPartialEq for IResult<I, O>