mut-str 1.0.2

A toolkit for working with mutable string slices (&mut str).
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

extern crate alloc;
// `String` and `Box` are in the std prelude, so ignore unused import
#[allow(unused_imports)]
use alloc::{boxed::Box, string::String};

use crate::{Char, OwnedChar};

impl<'a> Extend<&'a Char> for String {
    fn extend<T: IntoIterator<Item = &'a Char>>(&mut self, iter: T) {
        let iterator = iter.into_iter();
        let (lower_bound, _) = iterator.size_hint();
        self.reserve(lower_bound);
        iterator.for_each(move |c| self.push_str(c.as_str()));
    }
}

impl<'a> Extend<&'a mut Char> for String {
    fn extend<T: IntoIterator<Item = &'a mut Char>>(&mut self, iter: T) {
        self.extend(iter.into_iter().map(|x| &*x));
    }
}

impl Extend<OwnedChar> for String {
    fn extend<T: IntoIterator<Item = OwnedChar>>(&mut self, iter: T) {
        let iterator = iter.into_iter();
        let (lower_bound, _) = iterator.size_hint();
        self.reserve(lower_bound);
        iterator.for_each(move |c| self.push_str(c.as_str()));
    }
}

impl<'a> Extend<&'a OwnedChar> for String {
    fn extend<T: IntoIterator<Item = &'a OwnedChar>>(&mut self, iter: T) {
        self.extend(iter.into_iter().map(AsRef::as_ref));
    }
}

impl<'a> Extend<&'a mut OwnedChar> for String {
    fn extend<T: IntoIterator<Item = &'a mut OwnedChar>>(&mut self, iter: T) {
        let iterator = iter.into_iter();
        let (lower_bound, _) = iterator.size_hint();
        self.reserve(lower_bound);
        iterator.for_each(move |c| self.push_str(c.as_str()));
    }
}

impl<'a> FromIterator<&'a Char> for String {
    #[inline]
    fn from_iter<T: IntoIterator<Item = &'a Char>>(iter: T) -> Self {
        let mut s = Self::new();
        s.extend(iter);
        s
    }
}

impl<'a> FromIterator<&'a mut Char> for String {
    #[inline]
    fn from_iter<T: IntoIterator<Item = &'a mut Char>>(iter: T) -> Self {
        let mut s = Self::new();
        s.extend(iter);
        s
    }
}

impl FromIterator<OwnedChar> for String {
    #[inline]
    fn from_iter<T: IntoIterator<Item = OwnedChar>>(iter: T) -> Self {
        let mut s = Self::new();
        s.extend(iter);
        s
    }
}

impl<'a> FromIterator<&'a OwnedChar> for String {
    #[inline]
    fn from_iter<T: IntoIterator<Item = &'a OwnedChar>>(iter: T) -> Self {
        let mut s = Self::new();
        s.extend(iter);
        s
    }
}

impl<'a> FromIterator<&'a mut OwnedChar> for String {
    #[inline]
    fn from_iter<T: IntoIterator<Item = &'a mut OwnedChar>>(iter: T) -> Self {
        let mut s = Self::new();
        s.extend(iter);
        s
    }
}

impl<'a> FromIterator<&'a Char> for Box<str> {
    #[inline]
    fn from_iter<T: IntoIterator<Item = &'a Char>>(iter: T) -> Self {
        String::from_iter(iter).into_boxed_str()
    }
}

impl<'a> FromIterator<&'a mut Char> for Box<str> {
    #[inline]
    fn from_iter<T: IntoIterator<Item = &'a mut Char>>(iter: T) -> Self {
        String::from_iter(iter).into_boxed_str()
    }
}

impl FromIterator<OwnedChar> for Box<str> {
    #[inline]
    fn from_iter<T: IntoIterator<Item = OwnedChar>>(iter: T) -> Self {
        String::from_iter(iter).into_boxed_str()
    }
}

impl<'a> FromIterator<&'a OwnedChar> for Box<str> {
    #[inline]
    fn from_iter<T: IntoIterator<Item = &'a OwnedChar>>(iter: T) -> Self {
        String::from_iter(iter).into_boxed_str()
    }
}

impl<'a> FromIterator<&'a mut OwnedChar> for Box<str> {
    #[inline]
    fn from_iter<T: IntoIterator<Item = &'a mut OwnedChar>>(iter: T) -> Self {
        String::from_iter(iter).into_boxed_str()
    }
}