Struct Literate 

pub struct Literate<I> { /* private fields */ }

Adds Display/Debug formatting to any iterator whose items implement Display and/or Debug.

All formatting arguments are passed through to each item’s Display/Debug implementation.

Implementations

impl<I: Sized> Literate<I>

pub const fn new(iter: I) -> Self

Wrap an iterator in a Literate struct.

pub const fn new_cell(iter: Option<I>) -> Self

Wrap an optional iterator in a Literate struct.

pub fn into_inner(self) -> Option<I>

Consumes the Literate and returns the inner iterator. Returns None if the object has been formatted already.

pub fn map_iterator<F, O>(self, f: F) -> Literate<O>

where F: FnOnce(I) -> O,

Convert the inner iterator to another inner iterator.

Trait Implementations

impl<I: Clone> Clone for Literate<I>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I> Debug for Literate<I>

where I: Iterator<Item: Debug>,

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

Formats the value using the given formatter.

impl<I> Display for Literate<I>

where I: Iterator<Item: Display>,

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

Formats the value using the given formatter.

impl<I> Literator for Literate<I>

where I: Iterator + Sized,

type Item = <I as Iterator>::Item

The item that this literator is displaying.

type Iter = I

The iterator type that this literator wraps.

fn into_option_iter(self) -> Option<Self::Iter>

Convert this literator into an Option of its iterator.

fn join<D>(self, delim: D) -> Join<Self::Iter, D>

where Self: Sized, D: Display,

Wrap the iterator in an object implementing Display/Debug that prints each item separated by a delimiter.

fn concat(self) -> Literate<Self::Iter>

where Self: Sized,

Concatenate all items into a single string, using each item’s Display or Debug implementation.

fn conjunctive_join_custom<Delim, LastDelim>( self, delim: Delim, last_delim: LastDelim, ) -> ConjunctiveJoin<Self::Iter, Delim, LastDelim>

where Self: Sized, Delim: Display, LastDelim: Display,

Join the items using delim between the first N-1 elements, and last_delim between the next-to-last and last items.

fn join_and(self) -> ConjunctiveJoin<Self::Iter>

where Self: Sized,

Join the items separated by ", " between each item, except " and " (no comma) between the next-to-last and last items.

fn join_or(self) -> ConjunctiveJoin<Self::Iter>

where Self: Sized,

Join the items separated by ", " between each item, except " or " (no comma) between the next-to-last and last items.

fn join_comma_and(self) -> ConjunctiveJoin<Self::Iter>

where Self: Sized,

Join the items separated by ", " between each item, except ", and " (with comma) between the next-to-last and last items.

fn join_comma_or(self) -> ConjunctiveJoin<Self::Iter>

where Self: Sized,

Join the items separated by ", " between each item, except ", or " (with comma) between the next-to-last and last items.

fn oxford_join_custom<Delim, ExactlyTwo, Final>( self, first_n: Delim, exactly_two_conjunction: ExactlyTwo, final_delim_conjunction: Final, ) -> OxfordJoin<Self::Iter, Delim, ExactlyTwo, Final>

where Self: Sized, Delim: Display, ExactlyTwo: Display, Final: Display,

Join items using serial comma (“Oxford comma”, “Harvard comma”).

fn oxford_join_and(self) -> OxfordJoin<Self::Iter>

where Self: Sized,

Oxford join with commas and English “and”.

fn oxford_join_or(self) -> OxfordJoin<Self::Iter>

where Self: Sized,

Oxford join with commas and English “or”.

fn oxford_join_semicolon_and(self) -> OxfordJoin<Self::Iter>

where Self: Sized,

Oxford join with semicolons and English “and”.

fn oxford_join_semicolon_or(self) -> OxfordJoin<Self::Iter>

where Self: Sized,

Oxford join with semicolons and English “or”.

fn format_each_with<F>( self, with: F, ) -> Literate<impl Iterator<Item = FormatWith<Self::Item, F>>>

where Self: Sized, F: Fn(&Self::Item, &mut Formatter<'_>) -> Result + Clone,

Produce an iterator where each item’s Display/Debug implementation is overridden by the function with.

fn capitalize_first(self) -> Literate<impl Iterator<Item: Display>>

where Self: Sized, Self::Item: Display,

Capitalize the first item in the list.

fn prefix_each_with<F>( self, with: F, ) -> Literate<impl Iterator<Item = PrefixWith<Self::Item, F>>>

where F: Fn(&Self::Item, &mut Formatter<'_>) -> Result + Clone, Self: Sized,

Produce an iterator where each item’s Display/Debug implementation writes a custom prefix before the item.

fn suffix_each_with<F>( self, with: F, ) -> Literate<impl Iterator<Item = SuffixWith<Self::Item, F>>>

where F: Fn(&Self::Item, &mut Formatter<'_>) -> Result + Clone, Self: Sized,

Produce an iterator where each item’s Display/Debug implementation writes a custom suffix after the item.

fn prefix_each<P>( self, prefix: P, ) -> Literate<impl Iterator<Item = Prefix<Self::Item, P>>>

where P: Display + Clone, Self: Sized,

Produce an iterator where each item’s Display/Debug implementation writes prefix before the item.

fn suffix_each<S>( self, suffix: S, ) -> Literate<impl Iterator<Item = Suffix<Self::Item, S>>>

where S: Display + Clone, Self: Sized,

Produce an iterator where each item’s Display/Debug implementation writes suffix after the item.

fn surround_each<P, S>( self, prefix: P, suffix: S, ) -> Literate<impl Iterator<Item = Surround<Self::Item, P, S>>>

where P: Display + Clone, S: Display + Clone, Self: Sized,

Produce an iterator where each item’s Display/Debug implementation writes prefix before and suffix after the item.

fn indent_each( self, level: usize, ) -> Literate<impl Iterator<Item = Surround<Self::Item, Repeat<&'static str>, char>>>

where Self: Sized,

Print each item prefixed by indentation, where each level of indentation is 4 spaces, and suffix each item with a newline.

fn indent_each_custom<P, S>( self, level: usize, indentation: P, newline: S, ) -> Literate<impl Iterator<Item = Surround<Self::Item, Repeat<P>, S>>>

where P: Display + Clone, S: Display + Clone, Self: Sized,

Print each item with custom indentation. The indentation string is repeated level times before each item, and newline is appended after each item.

fn indented_block<Open, Close>( self, open: Open, close: Close, inner_level: usize, ) -> IndentedBlock<Self::Iter, Open, Close, &'static str, char>

where Self: Sized, Open: Display, Close: Display,

Print items in a block surrounded by open and close, indented by inner_level.

fn indented_block_custom<Open, Close, Indentation, Newline>( self, open: Open, close: Close, inner_level: usize, indentation: Indentation, newline: Newline, ) -> IndentedBlock<Self::Iter, Open, Close, Indentation, Newline>

where Self: Sized, Open: Display, Close: Display, Indentation: Display, Newline: Display,

Same as indented_block(), but with custom indentation and newline tokens.

fn inline_block<P, D, S>( self, open: P, delim: D, close: S, ) -> InlineBlock<Self::Iter, P, D, S>

where Self: Sized, P: Display, D: Display, S: Display,

Print items in a block surrounded by open and close, where items are delimited by delim.