splutter 0.1.0

A library to create/generate text efficiently.
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

use crate::output::Output;

pub struct SeparatedBy<V, B> {
    values: V,
    by: B,
}

impl<V, B> SeparatedBy<V, B>
where
    Self: Output,
{
    pub fn new(values: V, by: B) -> Self {
        Self { values, by }
    }
}

impl<V1, V2, B> Output for SeparatedBy<(V1, V2), B>
where
    V1: Output,
    V2: Output,
    B: Output,
{
    fn output(self, output: &mut String) {
        self.values.0.output(output);
        self.by.output(output);
        self.values.1.output(output);
    }
}

impl<V1, V2, V3, B> Output for SeparatedBy<(V1, V2, V3), B>
where
    V1: Output,
    V2: Output,
    V3: Output,
    B: Copy,
    B: Output,
{
    fn output(self, output: &mut String) {
        self.values.0.output(output);
        self.by.output(output);
        self.values.1.output(output);
        self.by.output(output);
        self.values.2.output(output);
    }
}

impl<V1, V2, V3, V4, B> Output for SeparatedBy<(V1, V2, V3, V4), B>
where
    V1: Output,
    V2: Output,
    V3: Output,
    V4: Output,
    B: Copy,
    B: Output,
{
    fn output(self, output: &mut String) {
        self.values.0.output(output);
        self.by.output(output);
        self.values.1.output(output);
        self.by.output(output);
        self.values.2.output(output);
        self.by.output(output);
        self.values.3.output(output);
    }
}

pub trait Separated<B> {
    fn separated(self, by: B) -> impl Output;
}

impl<O1, O2, By> Separated<By> for (O1, O2)
where
    O1: Output,
    O2: Output,
    By: Copy,
    By: Output,
{
    fn separated(self, by: By) -> impl Output {
        (self.0, by, self.1)
    }
}

impl<O1, O2, O3, By> Separated<By> for (O1, O2, O3)
where
    O1: Output,
    O2: Output,
    O3: Output,
    By: Copy,
    By: Output,
{
    fn separated(self, by: By) -> impl Output {
        SeparatedBy::new(self, by)
    }
}

impl<O1, O2, O3, O4, By> Separated<By> for (O1, O2, O3, O4)
where
    O1: Output,
    O2: Output,
    O3: Output,
    O4: Output,
    By: Copy,
    By: Output,
{
    fn separated(self, by: By) -> impl Output {
        SeparatedBy::new(self, by)
    }
}