Untitled

#![allow(dead_code)]
use std::cell::RefCell;
use std::rc::Rc;

fn main() {
    let input = vec![1, 2, 3, 4, 5];
    let head = Node::from_vec(input);
    let cur = head.as_ref().unwrap().clone();
    let mut cur = Some(cur);

    while cur.is_some() {
        println!("{}", cur.as_ref().unwrap().borrow().val);
        let cur_temp = cur.as_ref().unwrap().borrow().next.clone();
        cur = cur_temp;
    }

    let output = reverse_linked_list(head);
    let cur = output.as_ref().unwrap().clone();
    let mut cur = Some(cur);

    while cur.is_some() {
        println!("{}", cur.as_ref().unwrap().borrow().val);
        let cur_temp = cur.as_ref().unwrap().borrow().next.clone();
        cur = cur_temp;
    }
}

fn reverse_linked_list<T>(head: WrappedNode<T>) -> WrappedNode<T>
where
    T: Default,
{
    let mut prev: WrappedNode<T> = None;
    let cur = head.as_ref().unwrap().clone();
    let mut cur = Some(cur);

    while cur.is_some() {
        let temp = cur.as_ref().unwrap().borrow().next.clone();
        cur.as_ref().unwrap().borrow_mut().next = prev;
        prev = cur.clone();
        cur = temp;
    }

    prev
}

type WrappedNode<T> = Option<Rc<RefCell<Node<T>>>>;

#[derive(Default)]
struct Node<T>
where
    T: Default,
{
    pub val: T,
    pub next: WrappedNode<T>,
}

impl<T> Node<T>
where
    T: Default,
{
    pub fn new(val: T) -> Self {
        Node { val, next: None }
    }
    pub fn append(&mut self, node: WrappedNode<T>) -> Result<(), &'static str> {
        if self.next.is_some() {
            return Err("This node already has a next");
        }

        self.next = node;
        Ok(())
    }

    pub fn from_vec(arr: Vec<T>) -> WrappedNode<T> {
        let parking = Node::<T>::default();
        let parking = Rc::new(RefCell::new(parking));
        let mut cur = parking.clone();

        for item in arr {
            let next = Some(Rc::new(RefCell::new(Node::new(item))));
            cur.borrow_mut().next = next;
            let temp_next = cur.borrow().next.as_ref().unwrap().clone();
            cur = temp_next;
        }

        let next = parking.borrow().next.as_ref().unwrap().clone();
        Some(next)
    }
}