Struct Or 

pub struct Or<F, S> {
    pub first: F,
    pub second: S,
}

Matches at least one of the provided atoms, trying first before second.

Fields

first: F

The first atom to be checked

second: S

The second atom to be checked.

If first matches then second would not be tested.

Implementations

impl<F, S> Or<F, S>

pub fn new(first: F, second: S) -> Self

Creates a new Or.

Trait Implementations

impl<F, S> AlwaysAtom for Or<F, S>

where F: AlwaysAtom, S: Atom,

fn parse_always(&self, st: &str) -> Match

Returns the length of the match

impl<F, S> Atom for Or<F, S>

where F: Atom, S: Atom,

fn parse(&self, st: &str) -> Option<Match>

The main parsing algorithm.

fn as_dyn(&self) -> &dyn Atom

where Self: Sized,

Coerce to dyn trait

fn into_tool(self) -> AtomTool<Self>

where Self: Sized,

Converts this atom into a ParseTool.

impl<'a, FF, F, S, D> ParseTool<'a, FF> for Or<F, S>

where F: ParseTool<'a, FF, Data = D>, S: ParseTool<'a, FF, Data = D>, FF: Clone, D: 'a,

type Error = <S as ParseTool<'a, FF>>::Error

Error type

type Data = D

Associated data

fn parse( &self, st: View<'a, FF>, ) -> Result<(Self::Data, View<'a, FF>), Self::Error>

The main parsing algorithm.