pub struct SimpleLinkedList<T> {
    head: Node<T>
}

pub enum Node<T> {
    Data{data: T, next: Box<Node<T>>},
    Nil,
}

impl<T> SimpleLinkedList<T> {
    pub fn new() -> Self {
        SimpleLinkedList{head: Node::Nil}
    }

    pub fn len(&self) -> usize {
        let mut len = 0;
        let mut cur = &self.head;
        while let Node::Data {data: _, next: n} = *cur {
            len += 1;
            cur = &n;
        }
        len
    }

    pub fn push(&mut self, element: T) {
        self.head =
            Node::Data{
                data: element,
                next: Box::new(self.head),
            }

    }

    pub fn pop(&mut self) -> Option<T> {
        let top = self.head;
        match top {
            Node::Data{data, next} => {
                self.head = *next;
                Some(data)
            }
            Node::Nil => None
        }
    }

    pub fn peek(&self) -> Option<&T> {
        unimplemented!()
    }
}