Struct Fail

pub struct Fail<E: Error + Clone + 'static>(pub E);

Always fails with a given error.

Example

uh_oh: u32 = Fail::new(Error::new("oh no!"))

Tuple Fields

0: E

Implementations

impl<E: Error + Clone + 'static> Fail<E>

pub fn new(err: E) -> Self

Creates a new instance of this type.

Trait Implementations

impl<E: Debug + Error + Clone + 'static> Debug for Fail<E>

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

Formats the value using the given formatter.

impl<E: Error + Clone + 'static> NamedRule for Fail<E>

fn name(&self) -> Option<&'static str>

Defines the name printed in errors including this rule.

impl<E: PartialEq + Error + Clone + 'static> PartialEq for Fail<E>

fn eq(&self, other: &Fail<E>) -> 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<'input, T: ?Sized + 'input, E: Error + Clone + 'static> Rule<'input, T> for Fail<E>

type Output = <fn() -> ! as FnOnce<()>>::Output

The type of the value of a successful parse of this rule.

fn parse_at<'cursor, 'this, 'index>( &'this self, _input: &'cursor mut &'input T, index: &'index mut usize, ) -> Result<Self::Output, ParseError>

where 'input: 'this,

Parses a rule at a given index with a given input.

fn parse<'this>( &'this self, input: &'input SliceType, ) -> Result<(&'input SliceType, Self::Output), ParseError>

where 'input: 'this,

Parses a given rule at the start of some input.

fn map_parsed<Output, F: Fn(Self::Output) -> Output>( self, function: F, ) -> Map<'input, SliceType, Self, Output, F>

where Self: Sized,

Maps an infallible function onto the output of a rule.

fn try_map_parsed<Output, E: Error + 'static, F: Fn(Self::Output) -> Result<Output, E>>( self, function: F, ) -> TryMap<'input, SliceType, Self, Output, E, F>

where Self: Sized,

Maps a function onto the output of a rule, passing the error back if it fails.

fn prevent(self) -> Not<Self>

where Self: Sized,

Matches when this fails, and vice versa.

fn repeat_for<const REPS: usize>( self, ) -> RepeatFor<'input, SliceType, Self, REPS>

where Self: Sized,

Repeats this rule a known amount of times.

fn repeat(self, reps: usize) -> Repeat<'input, SliceType, Self>

where Self: Sized,

Repeats this rule a set amount of times.

fn take(self, at_most: usize) -> Many<'input, SliceType, Self>

where Self: Sized,

Repeats this rule at most a set amount of times.

fn hoard(self) -> Many<'input, SliceType, Self>

where Self: Sized,

Repeats this rule forever until it fails.

fn attempt(self) -> Attempt<'input, SliceType, Self>

where Self: Sized,

Tries to capture this rule, returning None if it doesn’t match.

impl<E: Error + Clone + 'static> StructuralPartialEq for Fail<E>