Trait Pattern

pub trait Pattern<T>: Clone + Copy {
    // Required method
    fn eval(&self, input: &[T]) -> Option<usize>;

    // Provided methods
    fn then<P>(self, other: P) -> Sequence<Self, P>
       where Self: Sized,
             P: Pattern<T> { ... }
    fn or<P>(self, other: P) -> Choice<Self, P>
       where Self: Sized,
             P: Pattern<T> { ... }
}

Expresses that the implementing type may be used to match a slice with elements of type T.

Required Methods

fn eval(&self, input: &[T]) -> Option<usize>

Evaluates the pattern against a slice of Ts. If the pattern matches, the length of matching slice should be returned. Otherwise, None should be returned.

It is assumed that the pattern begins matching from the start of the slice.

Provided Methods

fn then<P>(self, other: P) -> Sequence<Self, P>

where Self: Sized, P: Pattern<T>,

Returns a new pattern that will match if self and other match in sequence.

use bparse::Pattern;

let pattern = "a".then("b");
assert_eq!(pattern.eval(b"abc"), Some(2));

fn or<P>(self, other: P) -> Choice<Self, P>

where Self: Sized, P: Pattern<T>,

Returns a new pattern that will match if either self or other match.

use bparse::Pattern;

let pattern = "a".or("b");
assert_eq!(pattern.eval(b"ba"), Some(1));

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl Pattern<u8> for &str

fn eval(&self, input: &[u8]) -> Option<usize>

impl<P, T> Pattern<T> for &P

where P: Pattern<T>,

fn eval(&self, input: &[T]) -> Option<usize>

Implementors

impl Pattern<u8> for ByteLookupTable

impl<I, P> Pattern<I> for Not<P>

where P: Pattern<I>,

impl<P1, P2, T> Pattern<T> for Choice<P1, P2>

where P1: Pattern<T>, P2: Pattern<T>,

impl<P1, P2, T> Pattern<T> for Sequence<P1, P2>

where P1: Pattern<T>, P2: Pattern<T>,

impl<T> Pattern<T> for ElementRange<T>

where T: PartialOrd + Copy,

impl<T> Pattern<T> for One

impl<T> Pattern<T> for Prefix<'_, T>

where T: PartialEq + Copy,

impl<T, P> Pattern<T> for Repetition<P>

where P: Pattern<T>,