pub fn push(&mut self, value: T) {
    let old_head = self.head.take();
    let new_head = Item {
        value,
        next: old_head,
    };
    self.head = Some(Box::new(new_head));
}

pub fn pop(&mut self) -> Option<T> {
    let old_head = self.head.take();
    match old_head {
        Some(item) => {
            self.head = item.next;
            Some(item.value)
        }
        None => None,
    }
}

pub fn peek(&self) -> Option<&T> {
    match &self.head {
        Some(item) => Some(&item.as_ref().value),
        None => None,
    }
}

fn get_node_ref<'a>(&self, cursor: &'a Link<T>, key: &T) -> &'a Link<T> {
    if let Some(node) = cursor.as_ref() {
        if let Some(next_node) = node.next.as_ref() {
            if next_node.value < *key {
                return self.get_node_ref(&node.next, key);
            }
        }   
    }
    cursor
}

fn recursive_insert(cursor: &mut Link<T>, value: T) {
    if let Some(node) = cursor {
        if let Some(next_node) = &mut node.next {
            if next_node.value < value {
                return LinkedList::recursive_insert(&mut node.next, value);
            } 
        } 
        let mut new_node = Node { value, next: None };
        let old_value = mem::take(&mut node.next);
        new_node.next = old_value;
        node.next = Some(Box::new(new_node));
    }
}

fn recursive_delete(cursor: &mut Link<T>, value: T) {
    if let Some(node) = cursor {
        if let Some(next_node) = &mut node.next {
            if next_node.value == value {
                let old_value = mem::take(&mut node.next);
                node.next = old_value.unwrap().next;
            }
            else if next_node.value < value {
                LinkedList::recursive_delete(&mut node.next, value);
            }
        }
    }
}