internal_iterator_rec 0.1.1

Recursive extension for the `internal_iterator` crate
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

use internal_iterator_rec::{
  InternalIterator, InternalIteratorRec, adhoc_internal_iterator_rec,
};

pub enum Statement {
  Plain,
  Number(i32),
  Loop(Loop),
  IfElse(Vec<Statement>, Vec<Statement>),
}

impl Statement {
  pub fn iter_all_loops_by_ref(
    &self,
  ) -> impl '_ + InternalIteratorRec<Item = &'_ Loop> {
    adhoc_internal_iterator_rec!(
      'r, self, |this: &'r Statement, yield_| -> &'r Loop {
        match this {
          Statement::Plain => (),
          Statement::Number(_) => (),
          Statement::Loop(loop_) => {
            loop_.iter_all_loops_by_ref().try_for_each_rec(yield_)?;
          }
          Statement::IfElse(if_body, else_body) => {
            for stmt in if_body.iter() {
              stmt.iter_all_loops_by_ref().try_for_each_rec(yield_)?;
            }
            for stmt in else_body.iter() {
              stmt.iter_all_loops_by_ref().try_for_each_rec(yield_)?;
            }
          }
        }
      }
    )
  }

  pub fn iter_all_numbers_by_mut(
    &mut self,
  ) -> impl '_ + InternalIteratorRec<Item = &'_ mut i32> {
    adhoc_internal_iterator_rec!(
      'r, self, |this: &'r mut Statement, yield_| -> &'r mut i32 {
        match this {
          Statement::Plain => (),
          Statement::Number(i) => {
            yield_(i)?;
          }
          Statement::Loop(loop_) => {
            loop_.iter_all_numbers_by_mut().try_for_each_rec(yield_)?;
          }
          Statement::IfElse(if_body, else_body) => {
            for stmt in if_body.iter_mut() {
              stmt.iter_all_numbers_by_mut().try_for_each_rec(yield_)?;
            }
            for stmt in else_body.iter_mut() {
              stmt.iter_all_numbers_by_mut().try_for_each_rec(yield_)?;
            }
          }
        }
      }
    )
  }
}

pub struct Loop {
  name: String,
  body: Vec<Statement>,
}

impl Loop {
  // A type can even pass *itself* in when it's iterating by reference
  pub fn iter_all_loops_by_ref(
    &self,
  ) -> impl '_ + InternalIteratorRec<Item = &'_ Loop> {
    adhoc_internal_iterator_rec!(
      'r, self, |this: &'r Loop, yield_| -> &'r Loop {
        yield_(this)?;
        for stmt in this.body.iter() {
          stmt.iter_all_loops_by_ref().try_for_each_rec(yield_)?;
        }
      }
    )
  }

  // Types cannot pass themselves into the iteration by mutable reference
  // because of lifetime issues, but they can iterate mutably over other data
  // they might hold.
  pub fn iter_all_numbers_by_mut(
    &mut self,
  ) -> impl '_ + InternalIteratorRec<Item = &'_ mut i32> {
    adhoc_internal_iterator_rec!(
      'r, self, |this: &'r mut Loop, yield_| -> &'r mut i32 {
        for stmt in this.body.iter_mut() {
          stmt.iter_all_numbers_by_mut().try_for_each_rec(yield_)?;
        }
      }
    )
  }
}

#[test]
fn run_the_sample_code() {
  let mut s = Statement::Loop(Loop {
    name: String::from("one"),
    body: vec![
      Statement::Number(5),
      Statement::Loop(Loop {
        name: String::from("two"),
        body: vec![
          //
        ],
      }),
      Statement::Plain,
      Statement::Number(7),
      Statement::Loop(Loop {
        name: String::from("three"),
        body: vec![
          //
        ],
      }),
    ],
  });

  let mut names = Vec::new();
  s.iter_all_loops_by_ref().for_each(|loop_ref| {
    names.push(loop_ref.name.clone());
  });
  assert_eq!(vec!["one", "two", "three"], names);

  let mut numbers = Vec::new();
  s.iter_all_numbers_by_mut().for_each(|i32_mut| {
    numbers.push(*i32_mut);
  });
  assert_eq!(vec![5, 7], numbers);
}