#[derive(Debug)]
struct List<T> {
    elem: T,
    next: Option<Box<List<T>>>,
}

#[derive(Debug)]
struct Queue<T> {
    tail: Option<Box<List<T>>>,
    head: *mut Option<Box<List<T>>>,
}

impl<T> Queue<T> {
    fn new() -> Queue<T> {
        let mut tail = None;
        let head = &mut tail as *mut Option<Box<List<T>>>;
        Queue{tail, head}
    }

    fn push(&mut self, elem: T) {
        let mut new_elem = None;
        let ptr = &mut new_elem as *mut Option<Box<List<T>>>;
        unsafe {
            (*(self.head)).replace(Box::new(List{elem, next: new_elem}));
        }
        self.head = ptr;
    }
}

impl<T> Iterator for Queue<T> {
    type Item = T;
    fn next(&mut self) -> Option<T> {
        match self.tail.take() {
            Some(l) => {
                self.tail = l.next;
                Some(l.elem)
            },
            None => None,
        }
    }
}

fn main() {
    let mut q = Queue::<i32>::new();
    let ptr : *mut Option<Box<List<i32>>> = &mut q.tail;
    assert_eq!(q.head, ptr);
    q.push(1);
    q.push(2);
    println!("{}", q.tail.unwrap().elem);
    //for i in q {
    //    println!("{}", i);
    //}
}