Struct Then

pub struct Then<P, F, E>(/* private fields */);

A pattern for the then combinator, chaining a pattern on the end of another pattern regardless of its evaluation result.

This pattern is created by calling Pattern::then method.

Implementations

impl<P, F, E> Then<P, F, E>

pub fn unwrap(self) -> (P, F)

Trait Implementations

impl<M: Matcher, P0, P1, F> AsyncMatch<M> for Then<P0, F, M::Error>

where P0: AsyncMatch<M>, P1: AsyncMatch<M>, F: FnOnce(Result<P0::Value, M::Error>) -> P1,

type Future = MatchThen<M, P0, P1, F>

The future type which will produce a value Self::Value by matching this pattern and a matcher M.

fn async_match(self, matcher: M) -> Self::Future

Creates a future which will produce a Self::Value by matching this pattern and the matcher.

impl<P: Debug, F: Debug, E: Debug> Debug for Then<P, F, E>

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

Formats the value using the given formatter.

impl<P0, P1, F, E> Pattern for Then<P0, F, E>

where P0: Pattern, P1: Pattern, F: FnOnce(Result<P0::Value, E>) -> P1,

type Value = <P1 as Pattern>::Value

The value type associated to the pattern.

fn then<F, P, E>(self, f: F) -> Then<Self, F, E>

where F: FnOnce(Result<Self::Value, E>) -> P,

Takes a closure which maps a Result<Self::Value> to a pattern, and creates a pattern which calls that closure on the evaluation result of self.

fn and_then<F, P>(self, f: F) -> AndThen<Self, F>

where F: FnOnce(Self::Value) -> P,

Takes a closure which maps a value to a pattern, and creates a pattern which calls that closure if the evaluation of self was succeeded.

fn or_else<F, P, E>(self, f: F) -> OrElse<Self, F, E>

where F: FnOnce(E) -> P,

Takes a closure which maps an error to a pattern, and creates a pattern which calls that closure if the evaluation of self failed.

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

where P: Pattern<Value = Self::Value>,

Takes a pattern other which will be used if the evaluation of self is failed.

fn map<F, T>(self, f: F) -> Map<Self, F>

where F: FnOnce(Self::Value) -> T,

Takes a closure which maps a value to another value, and creates a pattern which calls that closure on the evaluated value of self.

fn chain<P>(self, other: P) -> Chain<Self, P>

where P: Pattern,

Takes two patterns and creates a new pattern over both in sequence.

fn expect_eq(self, expected_value: Self::Value) -> Expect<Self>

where Self::Value: PartialEq,

Takes an expected value and creates a pattern which performs a pattern matching and validates that the matched value is equal to the expected one.

fn boxed<M: Matcher>(self) -> BoxPattern<M, Self::Value>

where Self: AsyncMatch<M> + 'static, Self::Future: Send + 'static,

Returnes a boxed pattern to match with a matcher M.