literator 0.3.0

Efficient conversion of iterators to human-readable strings
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

#![doc = include_str!("../README.md")]
#![no_std]
#![forbid(unsafe_code, missing_docs)]

use core::fmt::{Display, Formatter};

#[cfg(test)]
extern crate alloc;

pub mod block;
pub mod decorate;
pub mod fmt;
pub mod join;
mod literate;
mod literator;

use block::*;
use decorate::*;
use fmt::*;
use join::*;
pub use literate::*;
pub use literator::*;

macro_rules! impl_fmt_trait {
    ($trait:ident) => {
        impl<D, I> core::fmt::$trait for Join<I, D>
        where
            I: Iterator<Item: core::fmt::$trait>,
            D: Display,
        {
            fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
                self.do_fmt(f, core::fmt::$trait::fmt)
            }
        }

        impl<I, D, L> core::fmt::$trait for ConjunctiveJoin<I, D, L>
        where
            I: Iterator<Item: core::fmt::$trait>,
            D: Display,
            L: Display,
        {
            fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
                self.do_fmt(f, core::fmt::$trait::fmt)
            }
        }

        impl<I, D1, D2, D3> core::fmt::$trait for OxfordJoin<I, D1, D2, D3>
        where
            I: Iterator<Item: core::fmt::$trait>,
            D1: Display,
            D2: Display,
            D3: Display,
        {
            fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
                self.do_fmt(f, core::fmt::$trait::fmt)
            }
        }

        impl<I, Open, Delim, Close> core::fmt::$trait for InlineBlock<I, Open, Delim, Close>
        where
            I: Iterator<Item: core::fmt::$trait>,
            Open: Display,
            Delim: Display,
            Close: Display,
        {
            fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
                self.do_fmt(f, core::fmt::$trait::fmt)
            }
        }

        impl<I, Open, Close, Indentation, Newline> core::fmt::$trait
            for IndentedBlock<I, Open, Close, Indentation, Newline>
        where
            I: Iterator<Item: core::fmt::$trait>,
            Open: Display,
            Close: Display,
            Indentation: Display,
            Newline: Display,
        {
            fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
                self.do_fmt(f, core::fmt::$trait::fmt)
            }
        }

        impl<T: core::fmt::$trait, P: Display> core::fmt::$trait for Prefix<T, P> {
            fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
                write!(f, "{}", self.prefix)?;
                self.item.fmt(f)
            }
        }

        impl<T: core::fmt::$trait, S: Display> core::fmt::$trait for Suffix<T, S> {
            fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
                self.item.fmt(f)?;
                write!(f, "{}", self.suffix)
            }
        }

        impl<T: core::fmt::$trait, Prefix: Display, Suffix: Display> core::fmt::$trait
            for Surround<T, Prefix, Suffix>
        {
            fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
                write!(f, "{}", self.prefix)?;
                self.item.fmt(f)?;
                write!(f, "{}", self.suffix)
            }
        }

        impl<T, F> core::fmt::$trait for PrefixWith<T, F>
        where
            T: core::fmt::$trait,
            F: Fn(&T, &mut Formatter) -> core::fmt::Result,
        {
            fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
                (self.with)(&self.item, f)?;
                self.item.fmt(f)
            }
        }

        impl<T, F> core::fmt::$trait for SuffixWith<T, F>
        where
            T: core::fmt::$trait,
            F: Fn(&T, &mut Formatter) -> core::fmt::Result,
        {
            fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
                self.item.fmt(f)?;
                (self.with)(&self.item, f)
            }
        }
    };
}

impl_fmt_trait!(Display);
impl_fmt_trait!(Debug);
impl_fmt_trait!(LowerHex);
impl_fmt_trait!(LowerExp);
impl_fmt_trait!(UpperHex);
impl_fmt_trait!(UpperExp);
impl_fmt_trait!(Octal);
impl_fmt_trait!(Pointer);
impl_fmt_trait!(Binary);