Rust练习：struct List<T>

 1：Box<Node<T>>

---

#![allow(warnings)]

use std::{boxed::Box, fmt::Debug};
use std::fmt::Write;


fn main() {

    let mut a = List::new();
    a.push(1).push(2).push(3);
    let mut a = a.prefix(100).suffix(200);

    a.concat(300);

    for i in a.iter() {
        print!("{} ",i);
    }
}


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

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

impl<T> List<T> {

    fn new() -> Self {
        List { head: None }
    }

    fn prefix(self, data: T) -> Self {
        List {
            head: Some(Box::new(Node { element: data, next: self.head })),
        }
    }

    fn suffix(mut self, data: T) -> Self {
        let mut cur = &mut self.head;
        while let Some(node) = cur {
            cur = &mut node.next;
        }
        *cur = Some(Box::new(Node { element: data, next: None }));
        self
    }

    /// 相比于上面的(mut self, data: T) -> Self 只需将输入参数和输出参数改为 &mut 就变成无消费型，
    /// 这得益于原始代码的设计：整个遍历过程只使用了 &mut 引用链（cur: &mut Option<Box<Node<T>>>），
    /// 从未移动过 self 或其内部节点的所有权。因此当 self 本身变成可变借用时，所有操作依然合法
    fn concat(&mut self,data:T) -> &mut Self {
        let mut cur = &mut self.head;
        while let Some(node) = cur {
            cur = &mut node.next;
        }
        *cur = Some(Box::new(Node { element: data, next: None }));
        self
    }


    fn push(&mut self, data: T) -> &mut Self {
        self.head = Some(Box::new(Node {
            element: data,
            next: self.head.take(),
        }));
        self
    }

    fn pop(&mut self) -> Option<T> {
        self.head.take().map(|head_node| {
            self.head = head_node.next;
            head_node.element
        })
    }

    fn peek(&self) -> Option<&T> {
        self.head.as_ref().map(|node| &node.element)
    }

    pub fn iter(&self) -> Iter<'_, T> {
        Iter {
            current: &self.head,
        }
    }

    fn to_vec2(&self) -> Vec<&T> {
        self.iter().collect()
    }

    fn to_vec(&self) -> Vec<&T> {
        let mut r: Vec<&T> = vec![];
        let mut cur = &self.head;
        while let Some(n) = cur {
            r.push(&n.element);
            cur = &n.next;
        }
        return r;
    }

}

fn to_string<T: Debug>(a: &List<T>) -> String {

    let mut cur = &a.head;
    let mut s = String::from("[");

    while let Some(n) = cur {
        write!(&mut s, "{:?}", n.element);
        cur = &n.next;

        if cur.is_none() {
            s.push(']');
        } else {
            s.push(',');
        }
    }
    s
}

pub struct Iter<'a, T> {
    current: &'a Option<Box<Node<T>>>,
}

impl<'a, T> Iterator for Iter<'a, T> {

    type Item = &'a T;
    fn next(&mut self) -> Option<Self::Item> {
        self.current.as_ref().map(|node| {
            self.current = &node.next;
            &node.element
        })
    }

}

2：Rc<Node<T>>

---

#![allow(warnings)]
#![allow(unused, dead_code)]
use std::rc::Rc;

fn main() {
    let mut list = List::<i32>::new().push(1).push(2);
    println!("{:?}", list);
    println!("{:?}", list.pop());
    println!("{:?}", list);
}

#[derive(Debug)]
struct List<T> {
    head: Option<Rc<Node<T>>>,
}

#[derive(Debug)]
struct Node<T> {
    element: T,
    next: Option<Rc<Node<T>>>,
}

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

    fn push(mut self, data: T) -> Self {
        List {
            head: Some(Rc::new(Node {
                element: data,
                next: self.head.take(),
            })),
        }
    }

    fn pop(&mut self) -> Option<T>  {
       self.head.take().map(|x|{
            self.head = x.next.clone();
            Rc::try_unwrap(x).ok().map(|x|x.element)
       }).and_then(|x|x) 
       //.and_then(|x|x) = .flatten()  and_then 返回容器内元素的处理结果，不做任何处理即剥掉一层容器等同于flatten
       //不使用组合子的普通语句如下：
/*
        if let Some(head) = self.head.take() {
            self.head = head.next.clone();
            Rc::try_unwrap(head).ok().map(|x| x.element) // 如果函数签名后加 where  T : Copy  简化为：Some(head.element)
        }
        else {
            None
        }
*/
    }
}

3：Rc<RefCell<Node<T>>>

---

#![allow(warnings)]
#![allow(unused, dead_code)]

use std::cell::Ref;
use std::cell::RefCell;
use std::rc::Rc;

fn main() {
    let mut list = List::<i32>::new().push(1).push(2).push(3).push(4);
    println!("{:?}", list.pop().map(|x| x.borrow().element));
    println!("{:?}", list);
}

#[derive(Debug)]
struct List<T> {
    head: Option<Rc<RefCell<Node<T>>>>,
}
#[derive(Debug)]
struct Node<T> {
    element: T,
    next: Option<Rc<RefCell<Node<T>>>>,
}
impl<T> List<T> {
    fn new() -> Self {
        List { head: None }
    }
    fn push(mut self, data: T) -> Self {
        List {
            head: Some(Rc::new(RefCell::new(Node {
                element: data,
                next: self.head,
            }))),
        }
    }
    fn pop(&mut self) -> Option<Rc<RefCell<Node<T>>>> {
        
        let mut head = self.head.take();

        if let Some(n) = &mut head {
            self.head = n.borrow_mut().next.take();
        }
        head
    }
}