Enum Span 

pub enum Span<T, A> {
    Text(T),
    Expr(A),
}

A component of a template, either text or an expression.

A μfmt template is internally represented as a list of Spans. Spans are parsed deterministically according to precise breaking rules.

There are two ways to access the spans associated with a template:

• From a Template using the Template::spans method
• As an iterator over the spans of a template string using TemplateSpans.

See the TemplateSpans documentation for more detail and examples.

Variants

Text(T)

Text, with braces unescaped.

Expr(A)

An interpreted expression.

Implementations

impl<T, A> Span<T, A>

pub fn is_text(&self) -> bool

Returns if this is a Text.

pub fn is_expr(&self) -> bool

Returns if this is a Expr.

pub fn map_text<F, U>(self, f: F) -> Span<U, A>

where F: FnOnce(T) -> U,

Apply a closure to the text, converting it to a new type.

pub fn map_expr<F, B>(self, f: F) -> Span<T, B>

where F: FnOnce(A) -> B,

Apply a closure to the expression, converting it to a new type.

Trait Implementations

impl<T: Clone, A: Clone> Clone for Span<T, A>

fn clone(&self) -> Span<T, A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, A: Debug> Debug for Span<T, A>

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

Formats the value using the given formatter.

impl<T, A> Extend<Span<T, A>> for Template<T, A>

fn extend<I: IntoIterator<Item = Span<T, A>>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

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

Reserves capacity in a collection for the given number of additional elements.

impl<T, A> FromIterator<Span<T, A>> for Template<T, A>

fn from_iter<I: IntoIterator<Item = Span<T, A>>>(iter: I) -> Self

Creates a value from an iterator.

impl<T: PartialEq, A: PartialEq> PartialEq for Span<T, A>

fn eq(&self, other: &Span<T, A>) -> 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<T, A> StructuralPartialEq for Span<T, A>