Struct Concat 

pub struct Concat<A, B>(pub A, pub B);

A Writeable that efficiently concatenates two other Writeables.

See the concat_writeable! macro for a convenient way to make one of these.

Examples

use writeable::adapters::Concat;
use writeable::assert_writeable_eq;

assert_writeable_eq!(Concat("Number: ", 25), "Number: 25");

With TryWriteable:

use writeable::adapters::Concat;
use writeable::assert_try_writeable_eq;
use writeable::TryWriteable;

struct AlwaysPanic;

impl TryWriteable for AlwaysPanic {
    type Error = &'static str;
    fn try_write_to_parts<W: writeable::PartsWrite + ?Sized>(
        &self,
        _sink: &mut W,
    ) -> Result<Result<(), Self::Error>, core::fmt::Error> {
        // Unreachable panic: the first Writeable errors,
        // so the second Writeable is not evaluated.
        panic!("this is a test to demonstrate unreachable code")
    }
}

let writeable0: Result<&str, &str> = Err("error message");
let writeable1 = AlwaysPanic;

assert_try_writeable_eq!(
    Concat(writeable0, writeable1),
    "error message",
    Err("error message"),
)

Tuple Fields

0: A

1: B

Trait Implementations

impl<A: Debug, B: Debug> Debug for Concat<A, B>

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

Formats the value using the given formatter.

impl<A, B> Display for Concat<A, B>

where A: Writeable, B: Writeable,

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

Formats the value using the given formatter.

impl<A, B, E> TryWriteable for Concat<A, B>

where A: TryWriteable<Error = E>, B: TryWriteable<Error = E>,

type Error = E

The error type

fn try_write_to<W: Write + ?Sized>( &self, sink: &mut W, ) -> Result<Result<(), Self::Error>, Error>

Writes the content of this writeable to a sink.

fn try_write_to_parts<S: PartsWrite + ?Sized>( &self, sink: &mut S, ) -> Result<Result<(), Self::Error>, Error>

Writes the content of this writeable to a sink with parts (annotations).

fn writeable_length_hint(&self) -> LengthHint

Returns a hint for the number of UTF-8 bytes that will be written to the sink.

impl<A, B> Writeable for Concat<A, B>

where A: Writeable, B: Writeable,

fn write_to<W: Write + ?Sized>(&self, sink: &mut W) -> Result

Writes a string to the given sink. Errors from the sink are bubbled up. The default implementation delegates to write_to_parts, and discards any Part annotations.

fn write_to_parts<S: PartsWrite + ?Sized>(&self, sink: &mut S) -> Result

Write bytes and Part annotations to the given sink. Errors from the sink are bubbled up. The default implementation delegates to write_to, and doesn’t produce any Part annotations.

fn writeable_length_hint(&self) -> LengthHint

Returns a hint for the number of UTF-8 bytes that will be written to the sink.

fn writeable_borrow(&self) -> Option<&str>

Returns a &str that matches the output of write_to, if possible.