struct Tee<T>
where
    T: Iterator,
    T::Item: Clone,
{
    v: VecDeque<T::Item>,
    iter: T,
    i1: usize,
    i2: usize,
    none_encountered: bool,
}

pub fn tee<T>(into_iter: T) -> (impl Iterator<Item = T::Item>, impl Iterator<Item = T::Item>)
where
    T: IntoIterator,
    T::Item: Clone,
{
    let t = Rc::new(RefCell::new(Tee {
        v: VecDeque::new(),
        iter: into_iter.into_iter(),
        i1: 0,
        i2: 0,
        none_encountered: false,
    }));
    let first;
    let second;
    {
        let t1 = Rc::clone(&t);
        first = from_fn(move || {
            let mut s = t1.borrow_mut();
            if s.i2 != 0 {
                s.i2 -= 1;
                return Some(s.v.pop_front().unwrap());
            }

            if s.none_encountered {
                return None;
            }

            match s.iter.next() {
                None => {
                    s.none_encountered = true;
                    None
                }
                Some(a) => {
                    s.v.push_back(a.clone());
                    s.i1 += 1;
                    Some(a)
                }
            }
        });
    }

    {
        let t2 = Rc::clone(&t);
        second = from_fn(move || {
            let mut s = t2.borrow_mut();
            if s.i1 != 0 {
                s.i1 -= 1;
                return Some(s.v.pop_front().unwrap());
            }

            if s.none_encountered {
                return None;
            }

            match s.iter.next() {
                None => {
                    s.none_encountered = true;
                    None
                }
                Some(a) => {
                    s.v.push_back(a.clone());
                    s.i2 += 1;
                    Some(a)
                }
            }
        });
    }

    (first, second)
}