Struct PatternWriter

pub struct PatternWriter<W>(/* private fields */);

A matcher to write patterns into the inner writer W.

This is mainly used to define your own writing patterns. See the example of the WriteInto trait.

Implementations

impl<W: Write> PatternWriter<W>

pub fn new(inner: W) -> Self

Makes new PatternWriter instance.

Trait Implementations

impl<W: Write> AsyncMatch<PatternWriter<W>> for BE<I24>

type Future = WriteFixnum<W, Buf<[u8; 3]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for BE<I40>

type Future = WriteFixnum<W, Buf<[u8; 5]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for BE<I48>

type Future = WriteFixnum<W, Buf<[u8; 6]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for BE<I56>

type Future = WriteFixnum<W, Buf<[u8; 7]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for BE<U24>

type Future = WriteFixnum<W, Buf<[u8; 3]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for BE<U40>

type Future = WriteFixnum<W, Buf<[u8; 5]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for BE<U48>

type Future = WriteFixnum<W, Buf<[u8; 6]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for BE<U56>

type Future = WriteFixnum<W, Buf<[u8; 7]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for BE<i16>

type Future = WriteFixnum<W, Buf<[u8; 2]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for BE<i32>

type Future = WriteFixnum<W, Buf<[u8; 4]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for BE<i64>

type Future = WriteFixnum<W, Buf<[u8; 8]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for BE<u16>

type Future = WriteFixnum<W, Buf<[u8; 2]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for BE<u32>

type Future = WriteFixnum<W, Buf<[u8; 4]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for BE<u64>

type Future = WriteFixnum<W, Buf<[u8; 8]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write, B: AsRef<[u8]>> AsyncMatch<PatternWriter<W>> for Buf<B>

type Future = WriteBuf<W, B>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for Flush

type Future = WriteFlush<W>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for I24

type Future = WriteFixnum<W, Buf<[u8; 3]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for I40

type Future = WriteFixnum<W, Buf<[u8; 5]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for I48

type Future = WriteFixnum<W, Buf<[u8; 6]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for I56

type Future = WriteFixnum<W, Buf<[u8; 7]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for LE<I24>

type Future = WriteFixnum<W, Buf<[u8; 3]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for LE<I40>

type Future = WriteFixnum<W, Buf<[u8; 5]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for LE<I48>

type Future = WriteFixnum<W, Buf<[u8; 6]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for LE<I56>

type Future = WriteFixnum<W, Buf<[u8; 7]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for LE<U24>

type Future = WriteFixnum<W, Buf<[u8; 3]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for LE<U40>

type Future = WriteFixnum<W, Buf<[u8; 5]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for LE<U48>

type Future = WriteFixnum<W, Buf<[u8; 6]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for LE<U56>

type Future = WriteFixnum<W, Buf<[u8; 7]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for LE<i16>

type Future = WriteFixnum<W, Buf<[u8; 2]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for LE<i32>

type Future = WriteFixnum<W, Buf<[u8; 4]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for LE<i64>

type Future = WriteFixnum<W, Buf<[u8; 8]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for LE<u16>

type Future = WriteFixnum<W, Buf<[u8; 2]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for LE<u32>

type Future = WriteFixnum<W, Buf<[u8; 4]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for LE<u64>

type Future = WriteFixnum<W, Buf<[u8; 8]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write, B: AsRef<[u8]>> AsyncMatch<PatternWriter<W>> for PartialBuf<B>

type Future = WritePartialBuf<W, B>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for String

type Future = WriteBuf<W, String>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for U24

type Future = WriteFixnum<W, Buf<[u8; 3]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for U40

type Future = WriteFixnum<W, Buf<[u8; 5]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for U48

type Future = WriteFixnum<W, Buf<[u8; 6]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for U56

type Future = WriteFixnum<W, Buf<[u8; 7]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for Vec<u8>

type Future = WriteBuf<W, Vec<u8>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write, B: AsRef<[u8]>> AsyncMatch<PatternWriter<W>> for Window<B>

type Future = WriteBuf<W, Window<B>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for i16

type Future = WriteFixnum<W, Buf<[u8; 2]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for i32

type Future = WriteFixnum<W, Buf<[u8; 4]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for i64

type Future = WriteFixnum<W, Buf<[u8; 8]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for i8

type Future = WriteFixnum<W, Buf<[u8; 1]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for u16

type Future = WriteFixnum<W, Buf<[u8; 2]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for u32

type Future = WriteFixnum<W, Buf<[u8; 4]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for u64

type Future = WriteFixnum<W, Buf<[u8; 8]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W: Write> AsyncMatch<PatternWriter<W>> for u8

type Future = WriteFixnum<W, Buf<[u8; 1]>>

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

fn async_match(self, matcher: PatternWriter<W>) -> Self::Future

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

fn into_stream(self, matcher: M) -> MatchStream<M, Self>

where Self: Clone,

Consumes this pattern and the matcher, returning a stream which will produce a sequence of matched values.

impl<W> Matcher for PatternWriter<W>

type Error = Error

The error type that may occur when matching using this matcher.

impl<W: Write> Write for PatternWriter<W>

fn write(&mut self, buf: &[u8]) -> Result<usize>

Writes a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flushes this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.