wtx 0.43.0

A collection of different transport implementations and related tools focused primarily on web technologies.
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

// FIXME(STABLE): iter_intersperse

use core::iter::{Fuse, FusedIterator};

/// An iterator adapter that places a separator between all elements.
#[derive(Clone, Debug)]
pub struct Intersperse<I, S>
where
  I: Iterator,
{
  started: bool,
  separator: S,
  next_item: Option<I::Item>,
  iter: Fuse<I>,
}

impl<I, S> Intersperse<I, S>
where
  I: Iterator,
  I::Item: Clone,
{
  /// Creates a new iterator which places a copy of separator between adjacent items of
  /// the original iterator.
  #[inline]
  pub fn new(iter: impl IntoIterator<IntoIter = I>, separator: S) -> Self {
    Self { started: false, separator, next_item: None, iter: iter.into_iter().fuse() }
  }
}

impl<I, S> FusedIterator for Intersperse<I, S>
where
  I: FusedIterator,
  S: FnMut() -> I::Item,
{
}

impl<I, S> Iterator for Intersperse<I, S>
where
  I: Iterator,
  S: FnMut() -> I::Item,
{
  type Item = I::Item;

  #[inline]
  fn fold<B, F>(self, init: B, f: F) -> B
  where
    Self: Sized,
    F: FnMut(B, Self::Item) -> B,
  {
    intersperse_fold(self.iter, init, f, self.separator, self.started, self.next_item)
  }

  #[inline]
  fn next(&mut self) -> Option<Self::Item> {
    if self.started {
      if let Some(v) = self.next_item.take() {
        Some(v)
      } else {
        let next_item = self.iter.next();
        next_item.is_some().then(|| {
          self.next_item = next_item;
          (self.separator)()
        })
      }
    } else {
      self.started = true;
      self.iter.next()
    }
  }

  #[inline]
  fn size_hint(&self) -> (usize, Option<usize>) {
    intersperse_size_hint(&self.iter, self.started, self.next_item.is_some())
  }
}

fn intersperse_fold<I, B, F, S>(
  mut iter: I,
  init: B,
  mut f: F,
  mut separator: S,
  started: bool,
  mut next_item: Option<I::Item>,
) -> B
where
  I: Iterator,
  F: FnMut(B, I::Item) -> B,
  S: FnMut() -> I::Item,
{
  let mut accum = init;

  let first = if started { next_item.take() } else { iter.next() };
  if let Some(x) = first {
    accum = f(accum, x);
  }

  iter.fold(accum, |mut elem, x| {
    elem = f(elem, separator());
    elem = f(elem, x);
    elem
  })
}

fn intersperse_size_hint<I>(iter: &I, started: bool, next_is_some: bool) -> (usize, Option<usize>)
where
  I: Iterator,
{
  let (lo, hi) = iter.size_hint();
  (
    lo.saturating_sub((!started).into()).saturating_add(next_is_some.into()).saturating_add(lo),
    hi.and_then(|elem| {
      elem.saturating_sub((!started).into()).saturating_add(next_is_some.into()).checked_add(elem)
    }),
  )
}

#[cfg(test)]
mod tests {
  use crate::{collection::Vector, misc::Intersperse};

  #[test]
  fn interspace() {
    assert_eq!(
      Vector::from_iterator(Intersperse::new(['0', '1', '2'], || ',')).unwrap().as_slice(),
      &['0', ',', '1', ',', '2']
    );
  }
}