Struct Action 

pub struct Action<O, F: FnMut() -> O>(/* private fields */);

Runs a function when parsed. Parses nothing, and returns the function’s output.

The inner function must not recursively parse this rule! Doing so will cause a runtime panic.

thread_local! {
    static ACTION: Action<(), fn()> = Action::new(adversarial);
}
 
fn adversarial() {
    ACTION.with(|a| { let _res = a.parse(""); });
}
 
adversarial();

Implementations

impl<O, F: FnMut() -> O> Action<O, F>

pub fn new(func: F) -> Self

Creates a new Action using a specified function.

Trait Implementations

impl<O, F: FnMut() -> O> NamedRule for Action<O, F>

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

Defines the name printed in errors including this rule.

impl<'i, S: 'i + ?Sized, O, F: FnMut() -> O> Rule<'i, S> for Action<O, F>

type Output = O

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

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

where 'i: '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 take_sep<R: Rule<'input, SliceType>>( self, separator: R, at_most: usize, ) -> Separated<'input, SliceType, Self, R>

where Self: Sized,

Repeats this rule at most a set amount of times, separated by another rule.

fn hoard_sep<R: Rule<'input, SliceType>>( self, separator: R, ) -> Separated<'input, SliceType, Self, R>

where Self: Sized,

Repeats this rule forever until it fails, separated by another rule.

fn consume_all(self) -> Consume<'input, SliceType, Self>

where Self: Sized, Consume<'input, SliceType, Self>: Rule<'input, SliceType, Output = Vec<Self::Output>>,

Repeats this rule until the end of input, failing if it ever does.

fn spanned(self) -> Spanned<'input, SliceType, Self>

where Self: Sized, SliceType: Index<RangeTo<usize>, Output = SliceType>,

Captures the output and span of this rule, returning them along with the output in a Span.

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

where Self: Sized,

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