gistfile1.txt

use std::fmt::Display;
use std::cell::RefCell;
use std::cell::RefMut;



pub struct ProviderData<T, I> {
    items: Vec<Option<T>>,
    iterator: I,
}

pub struct Provider<T, I> {
    data: RefCell<ProviderData<T, I>>,
}

impl<T, I: Iterator<Item=T>> Provider<T, I> {
    // Create an object that provides iterators which lazily compute values
    // that have not been requested yet
    pub fn new(a: I) -> Provider<T, I> {
        Provider {
        data: RefCell::new(ProviderData {
                items: Vec::new(),
                iterator: a,
            }),
        }
    }

    fn iter(&self) -> Marcher<T, I> {
        Marcher {
            index: 0,
            provider: self.data.borrow_mut(),
        }
    }
}

struct Marcher<'a, T: 'a, I: 'a> {
    index: usize,
    provider: RefMut<'a, ProviderData<T, I>>, // The error started to appear since I added this line
}

impl<'a, T, I: Iterator<Item=T>> Marcher<'a, T, I> {
    fn next(&'a mut self) -> Option<&'a T> {
        return None;
        // let result: Option<&'a T>;

        // if self.index >= self.provider.items.len() {
        //     let item = self.provider.iterator.next();

        //     if item.is_some() {
        //         self.provider.items.push(item);
        //         let index = self.provider.items.len() - 1;
        //         result = self.provider.items[index].as_ref();
        //     } else {
        //         self.provider.items.push(None);
        //         result = None;
        //     }
        // } else {
        //     result = self.provider.items[self.index].as_ref();
        // }

        // self.index += 1;

        // return result;
    }
}

fn main() {
    let iterator = 0..;
    let mut provider = Provider::new(iterator);
    do_stuff(&mut provider);
}

fn do_stuff<T, I: Iterator<Item=T>>(provider: &mut Provider<T, I>) {
    {
        let mut iter = provider.iter();

        {
            let first = iter.next();
        }
        {
            // let second = iter.next();
        }
    }
    {
        let mut iter = provider.iter();

        {
            let first = iter.next();
        }
        {
            // let second = iter.next();
        }
    }
}