catalan 0.3.3

binary tree of n variables where the parent node represents a function and the child node represents a value.
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

pub struct OperatorPermutation<O>
where
    O: Clone,
{
    order: usize,
    length: usize,
    operators: Vec<O>,
}

impl<O> OperatorPermutation<O>
where
    O: Clone,
{
    pub fn new(operators: &[O], length: usize) -> Self
    where
        O: PartialEq,
    {
        let mut operators = operators.to_vec();
        operators.dedup();
        Self { order: 0, length, operators }
    }
    pub fn with_order(mut self, order: usize) -> Self {
        self.order = order;
        self
    }
}

impl<O> Iterator for OperatorPermutation<O>
where
    O: Clone,
{
    type Item = Vec<O>;

    fn next(&mut self) -> Option<Self::Item> {
        if self.order >= self.operators.len().pow(self.length as u32) {
            return None;
        }
        let mut digits = vec![self.operators[0].clone(); self.length];
        let mut rest = self.order;
        // convert ot base self.length
        for i in 0..digits.len() {
            digits[i] = self.operators[rest % self.operators.len()].clone();
            rest /= self.operators.len();
        }
        self.order += 1;
        Some(digits)
    }
}