Time：2021-7-30

# Details

In this section, we implement peek of double linked list.

# Implement peek

According to our previous experience in implementing single linked list, we can easily think of how to implement our peek function, as follows:

``````    pub fn peek_front(&self) -> Option<&T> {
&node.borrow().elem
})
}``````

Solution: we can check the borrow function of refcell in the manual and find that the definition is as follows:

``````pub fn borrow(&self) -> Ref<'_, T>

pub fn borrow_mut(&self) -> RefMut<'_, T>``````

Let’s change the code as follows:

``````    pub fn peek_front(&self) -> Option<Ref<T>> {
node.borrow()
})
}``````

After compilation, if the error is still reported and ref is not found, add the following to the code:

``use std::cell::Ref;``

``````= note: expected enum `std::option::Option<std::cell::Ref<'_, T>>`
found enum `std::option::Option<std::cell::Ref<'_, Node<T>>>```````

The expectation is

``std::option::Option<std::cell::Ref<'_, T>>``

But what you get here is

``std::option::Option<std::cell::Ref<'_, Node<T>>>``

It’s easy to see that we need to

``Node<T>``

Take out the T in the.

How to solve this problem?

Here we use it

``std::cell::ref ``

The map in is as follows:

``````pub fn map<U, F>(orig: Ref<'b, T>, f: F) -> Ref<'b, U>
where
F: FnOnce(&T) -> &U,
U: ?Sized, ``````

Finally, our peek code is as follows:

``````    pub fn peek_front(&self) -> Option<Ref<T>> {
Ref::map(node.borrow(), |node| &node.elem)
})
}``````

# Test code

``````#[test]
fn peek() {
let mut list = List::new();
assert!(list.peek_front().is_none());
list.push_front(1); list.push_front(2); list.push_front(3);

assert_eq!(&*list.peek_front().unwrap(), &3);
}``````

# Complete code

``````use std::rc::Rc;
use std::cell::{Ref, RefCell};

pub struct List<T> {
}

struct Node<T> {
elem: T,
}

impl<T> Node<T> {
fn new(elem: T) -> Rc<RefCell<Self>> {
Rc::new(RefCell::new(Node {
elem: elem,
prev: None,
next: None,
}))
}
}

impl<T> List<T> {
pub fn new() -> Self {
List { head: None, tail: None }
}

pub fn push_front(&mut self, elem: T) {
let node = Node::new(elem);
//Take the variable reference and use the arrow_ mut
}
None => {
self.tail = Some(node.clone());
}
}
}

pub fn pop_front(&mut self) -> Option<T> {
match node.borrow_mut().next.take() {
Some(next) => {
next.borrow_mut().prev.take();
}
None => {
self.tail.take();
}
}
//Value using into_ inner
Rc::try_unwrap(node).ok().unwrap().into_inner().elem
})
}

//pub fn peek_front(&self) -> Option<&T> {
pub fn peek_front(&self) -> Option<Ref<T>> {
//node.borrow()
Ref::map(node.borrow(), |node| &node.elem)
})
}
}

#[cfg(test)]
mod tests {
use super::List;

#[test]
fn basics() {
let mut list = List::new();

assert_eq!(list.pop_front(), None);

list.push_front(1);
list.push_front(2);
list.push_front(3);

assert_eq!(list.pop_front(), Some(3));
assert_eq!(list.pop_front(), Some(2));

list.push_front(4);
list.push_front(5);

assert_eq!(list.pop_front(), Some(5));
assert_eq!(list.pop_front(), Some(4));

assert_eq!(list.pop_front(), Some(1));
assert_eq!(list.pop_front(), None);
}
}``````