Struct Chain

pub struct Chain<P0, P1>(/* private fields */);

A pattern for the chain combinator, chaining values of the two pattern P0 and P1 as a tuple value.

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

Implementations

impl<P0, P1> Chain<P0, P1>

pub fn unwrap(self) -> (P0, P1)

Trait Implementations

impl<P0: Clone, P1: Clone> Clone for Chain<P0, P1>

fn clone(&self) -> Chain<P0, P1>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<P0: Debug, P1: Debug> Debug for Chain<P0, P1>

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

Formats the value using the given formatter.

impl<P0, P1> Pattern for Chain<P0, P1>

where P0: Pattern, P1: Pattern,

type Value = (<P0 as Pattern>::Value, <P1 as Pattern>::Value)

The value type associated to the pattern.

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

where F: FnOnce(Result<Self::Value>) -> 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>(self, f: F) -> OrElse<Self, F>

where F: FnOnce(Error) -> 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 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 repeat(self) -> Repeat<Self>

where Self: Clone,

Creates Repeat pattern to represent an infinite stream of this pattern.

impl<R: Read, P0, P1> ReadFrom<R> for Chain<P0, P1>

where P0: ReadFrom<R>, P1: ReadFrom<R>,

type Future = ReadChain<R, P0, P1>

The future to read a value of the pattern from R.

fn lossless_read_from(self, reader: R) -> Self::Future

Creates a future instance to read a value of the pattern from reader.

fn read_from(self, reader: R) -> LossyReadFrom<R, Self::Future>

Creates a future instance to read a value of the pattern from reader.

fn sync_read_from(self, reader: R) -> Result<Self::Value>

Scynchronously reading a value of the pattern from reader.

fn boxed(self) -> BoxReadFrom<R, Self::Value>

where Self: Send + 'static, Self::Future: Send + 'static,

Returns the boxed version of this pattern.

impl<W: Write, P0, P1> WriteTo<W> for Chain<P0, P1>

where P0: WriteTo<W>, P1: WriteTo<W>,

type Future = WriteChain<W, P0, P1>

The future to write a value of the pattern to W.

fn lossless_write_to(self, writer: W) -> Self::Future

Creates a future instance to write a value of the pattern to writer.

fn write_to(self, writer: W) -> LossyWriteTo<W, Self::Future>

Creates a future instance to write a value of the pattern to writer.

fn sync_write_to(self, writer: W) -> Result<Self::Value>

Scynchronously writing a value of the pattern to writer.

fn boxed(self) -> BoxWriteTo<W, Self::Value>

where Self: Send + 'static, Self::Future: Send + 'static,

Returns the boxed version of this pattern.