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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

use core::fmt;

use crate::{FusedLender, IntoLender, Lender, Lending, Map};
#[must_use = "lenders are lazy and do nothing unless consumed"]
pub struct Flatten<'this, L: Lender>
where
    for<'all> <L as Lending<'all>>::Lend: IntoLender,
{
    inner: FlattenCompat<'this, L>,
}
impl<'this, L: Lender> Flatten<'this, L>
where
    for<'all> <L as Lending<'all>>::Lend: IntoLender,
{
    pub(crate) fn new(lender: L) -> Self { Self { inner: FlattenCompat::new(lender) } }
}
impl<'this, L: Lender + Clone> Clone for Flatten<'this, L>
where
    for<'all> <L as Lending<'all>>::Lend: IntoLender,
    for<'all> <<L as Lending<'all>>::Lend as IntoLender>::Lender: Clone,
{
    fn clone(&self) -> Self { Flatten { inner: self.inner.clone() } }
}
impl<'this, L: Lender + fmt::Debug> fmt::Debug for Flatten<'this, L>
where
    for<'all> <L as Lending<'all>>::Lend: IntoLender,
    for<'all> <<L as Lending<'all>>::Lend as IntoLender>::Lender: fmt::Debug,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Flatten").field("inner", &self.inner).finish()
    }
}
impl<'lend, 'this, L: Lender> Lending<'lend> for Flatten<'this, L>
where
    for<'all> <L as Lending<'all>>::Lend: IntoLender,
{
    type Lend = <<L as Lending<'this>>::Lend as Lending<'lend>>::Lend;
}
impl<'this, L: Lender> Lender for Flatten<'this, L>
where
    for<'all> <L as Lending<'all>>::Lend: IntoLender,
{
    #[inline]
    fn next(&mut self) -> Option<<Self as Lending<'_>>::Lend> { self.inner.next() }
    #[inline]
    fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
}
impl<'this, L: FusedLender> FusedLender for Flatten<'this, L> where for<'all> <L as Lending<'all>>::Lend: IntoLender {}

#[must_use = "lenders are lazy and do nothing unless consumed"]
pub struct FlatMap<'this, L: Lender, F>
where
    Map<L, F>: Lender,
    for<'all> <Map<L, F> as Lending<'all>>::Lend: IntoLender,
{
    inner: FlattenCompat<'this, Map<L, F>>,
}
impl<'this, L: Lender, F> FlatMap<'this, L, F>
where
    Map<L, F>: Lender,
    for<'all> <Map<L, F> as Lending<'all>>::Lend: IntoLender,
{
    pub(crate) fn new(lender: L, f: F) -> Self { Self { inner: FlattenCompat::new(Map::new(lender, f)) } }
}
impl<'this, L: Lender + Clone, F: Clone> Clone for FlatMap<'this, L, F>
where
    Map<L, F>: Lender + Clone,
    for<'all> <Map<L, F> as Lending<'all>>::Lend: IntoLender,
    for<'all> <<Map<L, F> as Lending<'all>>::Lend as IntoLender>::Lender: Clone,
{
    fn clone(&self) -> Self { FlatMap { inner: self.inner.clone() } }
}
impl<'this, L: Lender + fmt::Debug, F> fmt::Debug for FlatMap<'this, L, F>
where
    Map<L, F>: Lender + Clone,
    for<'all> <Map<L, F> as Lending<'all>>::Lend: IntoLender,
    for<'all> <<Map<L, F> as Lending<'all>>::Lend as IntoLender>::Lender: fmt::Debug,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("FlatMap").field("inner", &self.inner).finish()
    }
}
impl<'lend, 'this, L: Lender, F> Lending<'lend> for FlatMap<'this, L, F>
where
    Map<L, F>: Lender,
    for<'all> <Map<L, F> as Lending<'all>>::Lend: IntoLender,
{
    type Lend = <<Map<L, F> as Lending<'this>>::Lend as Lending<'lend>>::Lend;
}
impl<'this, L: Lender, F> Lender for FlatMap<'this, L, F>
where
    Map<L, F>: Lender,
    for<'all> <Map<L, F> as Lending<'all>>::Lend: IntoLender,
{
    #[inline]
    fn next(&mut self) -> Option<<Self as Lending<'_>>::Lend> { self.inner.next() }
    #[inline]
    fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
}
impl<'this, L: FusedLender, F> FusedLender for FlatMap<'this, L, F>
where
    Map<L, F>: Lender,
    for<'all> <Map<L, F> as Lending<'all>>::Lend: IntoLender,
{
}
pub struct FlattenCompat<'this, L: Lender>
where
    for<'all> <L as Lending<'all>>::Lend: IntoLender,
{
    lender: L,
    inner: Option<<<L as Lending<'this>>::Lend as IntoLender>::Lender>,
}
impl<'this, L: Lender> FlattenCompat<'this, L>
where
    for<'all> <L as Lending<'all>>::Lend: IntoLender,
{
    pub(crate) fn new(lender: L) -> Self { Self { lender, inner: None } }
}
impl<'this, L: Lender + Clone> Clone for FlattenCompat<'this, L>
where
    for<'all> <L as Lending<'all>>::Lend: IntoLender,
    for<'all> <<L as Lending<'all>>::Lend as IntoLender>::Lender: Clone,
{
    fn clone(&self) -> Self { Self { lender: self.lender.clone(), inner: self.inner.clone() } }
}
impl<'this, L: Lender + fmt::Debug> fmt::Debug for FlattenCompat<'this, L>
where
    for<'all> <L as Lending<'all>>::Lend: IntoLender,
    for<'all> <<L as Lending<'all>>::Lend as IntoLender>::Lender: fmt::Debug,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("FlattenCompat").field("lender", &self.lender).field("inner", &self.inner).finish()
    }
}
impl<'lend, 'this, L: Lender> Lending<'lend> for FlattenCompat<'this, L>
where
    for<'all> <L as Lending<'all>>::Lend: IntoLender,
{
    type Lend = <<L as Lending<'this>>::Lend as Lending<'lend>>::Lend;
}
impl<'this, L: Lender> Lender for FlattenCompat<'this, L>
where
    for<'all> <L as Lending<'all>>::Lend: IntoLender,
{
    fn next(&mut self) -> Option<<Self as Lending<'_>>::Lend> {
        let reborrow =
            unsafe { &mut *(&mut self.inner as *mut Option<<<L as Lending<'this>>::Lend as IntoLender>::Lender>) };
        if let Some(inner) = reborrow {
            if let Some(x) = inner.next() {
                return Some(x);
            }
        }
        self.inner = self.lender.next().map(|l| unsafe { core::mem::transmute(l.into_lender()) });
        self.inner.as_mut()?.next()
    }
    fn size_hint(&self) -> (usize, Option<usize>) {
        (
            match &self.inner {
                Some(inner) => inner.size_hint().0,
                None => self.lender.size_hint().0,
            },
            None,
        )
    }
}
impl<'this, L: FusedLender> FusedLender for FlattenCompat<'this, L> where for<'all> <L as Lending<'all>>::Lend: IntoLender {}