Enum StrOrDoc 

pub enum StrOrDoc<'p> {
    S(Cow<'p, str>),
    D(DocPtr<'p>),
}

A tagged union of either a Cow string, or a DocPtr. By using this type in conjuction with the Doclike trait, we get a pretty large amount of code reuse while cutting down on syntax noise since in many cases we can treat string slices, owned strings, and DocPtr items in the exact same way with the only overhead being that of dealing with the enum (IE there are no extra allocations or clones).

Variants

S(Cow<'p, str>)

D(DocPtr<'p>)

Trait Implementations

impl<'p> Clone for StrOrDoc<'p>

fn clone(&self) -> StrOrDoc<'p>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'p> Debug for StrOrDoc<'p>

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

Formats the value using the given formatter.

impl<'p, P: HasPrinter<'p>> Doclike<'p, P> for StrOrDoc<'p>

StrOrDoc is doclike; in the case of a doc, you just get the doc back. In the case of a Cow string, we allocate defer to the implementation that’s generic over any A such that A can become a Cow string

fn alloc(self, pr: &mut P) -> DocPtr<'p>

Generic over any Doclike, so you can use this for text as well.

fn concat(self, other: impl Doclike<'p, P>, pr: &mut P) -> DocPtr<'p>

fn nest(self, amt: u32, pr: &mut P) -> DocPtr<'p>

fn nest_line( self, other: impl Doclike<'p, P>, amt: u32, pr: &mut P, ) -> DocPtr<'p>

fn nest_doc( self, other: impl Doclike<'p, P>, amt: u32, pr: &mut P, ) -> DocPtr<'p>

fn nest_doc_zero( self, other: impl Doclike<'p, P>, amt: u32, pr: &mut P, ) -> DocPtr<'p>

fn group(self, pr: &mut P) -> DocPtr<'p>

impl<'p, A> From<A> for StrOrDoc<'p>

where Cow<'p, str>: From<A>,

Can create a StrOrDoc from anything that can become a Cow string (so a CowStr, a string slice, or an owned string)

fn from(a: A) -> StrOrDoc<'p>

Converts to this type from the input type.

impl<'p> From<DocPtr<'p>> for StrOrDoc<'p>

Can create a StrOrDoc from a DocPtr

fn from(d: DocPtr<'p>) -> StrOrDoc<'p>

Converts to this type from the input type.

impl<'p> Hash for StrOrDoc<'p>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'p> PartialEq for StrOrDoc<'p>

fn eq(&self, other: &StrOrDoc<'p>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'p> Eq for StrOrDoc<'p>

impl<'p> StructuralPartialEq for StrOrDoc<'p>