// 填空,让代码运行
use crate::List::*;
enum List {
 // Cons: 链表中包含有值的节点,节点是元组类型,第一个元素是节点的值,第二个元素是指向下一个节点的指针
 Cons(u32, Box<List>),
 // Nil: 链表中的最后一个节点,用于说明链表的结束
 Nil,
}
// 为枚举实现一些方法
impl List {
 // 创建空的链表
 fn new() -> List {
 // 因为没有节点,所以直接返回 Nil 节点
 // 枚举成员 Nil 的类型是 List
 Nil
 }
 // 在老的链表前面新增一个节点,并返回新的链表
 fn prepend(self, elem: u32) -> List {
 Cons(elem, Box::new(self))
 }
 // 返回链表的长度
 fn len(&self) -> u32 {
 match self {
 // 这里我们不能拿走 tail 的所有权,因此需要获取它的引用
 Cons(_, tail) => 1 + tail.len(),
 // 空链表的长度为 0
 Nil => 0
 }
 }
 // 返回链表的字符串表现形式,用于打印输出
 fn stringify(&self) -> String {
 match self {
 Cons(head, ref tail) => {
 // 递归生成字符串
 format!("{}, {}", head, tail.stringify())
 },
 Nil => {
 format!("Nil")
 },
 }
 }
}
fn main() {
 // 创建一个新的链表(也是空的)
 let mut list = List::new();
 // 添加一些元素
 list = list.prepend(1);
 list = list.prepend(2);
 list = list.prepend(3);
 // 打印列表的当前状态
 println!("链表的长度是: {}", list.len());
 println!("{}", list.stringify());
}

// C语言风格的枚举定义
enum Number2 {
 Zero = 0,
 One = 1,
}
enum Number{
 Zero(u8),
 One(u8),
}

use std::fmt::Debug;
use crate::List::*;
enum List<T> {
 Cons(T, Box<List<T>>),
 Nil,
}
impl<T> List<T> where T: Debug + Copy {
 fn new() -> Self {
 Nil
 }
 
 fn prepend(self, elem: T) -> Self {
 Cons(elem, Box::new(self)) 
 }
 
 fn append(&mut self, elem: T) {
 match *self {
 Cons(_, ref mut tail) => tail.append(elem),
 Nil => *self = Cons(elem, Box::new(Nil))
 }
 }
 fn is_empty(&self) -> bool {
 if let Nil = *self {
 return true
 }
 return false
 }
 fn pop(&mut self) -> Option<T> {
 if let Cons(elem, ref mut tail) = *self {
 if tail.is_empty() {
 *self = Nil;
 return Some(elem)
 } else {
 tail.pop()
 }
 } else {
 return None
 }
 }
 
 fn front_pop(self) -> (Self, Option<T>) {
 if let Cons(elem, tail) = self { 
 return (*tail, Some(elem))
 } else {
 return (self, None)
 }
 }
 
 fn len(&self) -> usize {
 match *self {
 Cons(_, ref tail) => 1 + tail.len(),
 Nil => 0
 }
 }
 
 fn stringify(&self) -> String {
 match *self {
 Cons(ref head, ref tail) => {
 format!("{:?}->{}", head, tail.stringify()) 
 },
 Nil => {
 format!("Nil")
 },
 }
 }
}
fn main() {
 let mut list: List<u8> = List::new();
 list.append(0_u8);
 list = list.prepend(1_u8);
 list = list.prepend(2_u8);
 list = list.prepend(3_u8);
 println!("{} Len: {}", list.stringify(), list.len());
 list.append(10_u8);
 println!("{} Len: {}", list.stringify(), list.len());
 println!("{} pop out!", list.pop().unwrap());
 println!("{} Len: {}", list.stringify(), list.len());
 
 let (list, opt) = list.front_pop();
 if let Some(elem) = opt {
 println!("{} pop out from front!", elem);
 }
 println!("{} Len: {}", list.stringify(), list.len());
}

enum MyList {
 Node(i32, Box<MyList>),
 Null,
}
impl MyList {
 fn new() -> MyList {
 MyList::Null
 }
 fn size(&self) -> u32 {
 match self {
 Self::Null => 0,
 Self::Node(_, ref next) => next.size() + 1,
 }
 }
 fn stringify(&self) -> String {
 match self {
 Self::Null => String::from("Null"),
 Self::Node(n, next) => format!("{}->{}", n, next.stringify()),
 }
 }
 fn print(&self) {
 match self {
 Self::Null => println!("len={}, list={}", self.size(), self.stringify()),
 Self::Node(_, _) => println!(
 "len={}, front={}, back={}, list={}",
 self.size(),
 self.front().unwrap(),
 self.back().unwrap(),
 self.stringify()
 ),
 }
 }
 fn front(&self) -> Option<i32> {
 match self {
 Self::Null => None,
 Self::Node(num, _) => Some(*num),
 }
 }
 fn back(&self) -> Option<i32> {
 match self {
 Self::Null => None,
 Self::Node(num, next) => match **next {
 Self::Null => Some(*num),
 Self::Node(_, _) => next.back(),
 },
 }
 }
 fn preppend(self, num: i32) -> MyList {
 Self::Node(num, Box::new(self))
 }
 fn pop_front(self) -> MyList {
 match self {
 Self::Null => self,
 Self::Node(_, next) => *next,
 }
 }
 fn append(&mut self, num: i32) {
 match self {
 Self::Null => *self = Self::Node(num, Box::new(Self::Null)),
 Self::Node(_, next) => next.append(num),
 }
 }
 fn pop_back(&mut self) {
 if let Self::Node(_, next) = self {
 match **next {
 Self::Null => *self = Self::Null,
 Self::Node(_, _) => next.pop_back(),
 }
 }
 }
}
fn main() {
 let mut list = MyList::new();
 list.print();
 list = list.preppend(1);
 list = list.preppend(2);
 list = list.preppend(3);
 list.print();
 list.append(4);
 list.append(5);
 list.append(6);
 list.print();
 list = list.pop_front();
 list = list.pop_front();
 list.print();
 list.pop_back();
 list.pop_back();
 list.print();
}

if let Message::Quit = msg {
 assert_eq!(1, 1);
}

 // expand 的一个比较低效的实现
 // 老的链表被整体拷贝一份并在末尾添加新节点
 // fn expend(self, elem: u32) -> List {
 // match self {
 // Cons(data, head) => {
 // Cons(data, Box::new(head.expend(elem)))
 // }
 // Nil => Cons(elem, Box::new(self))
 // }
 // }
 // expand似乎高效一些的实现,不再需要对整个链表的节点进行拷贝
 fn expend(&mut self, elem: u32) {
 match self {
 Cons(data, next) => {
 next.expend(elem)
 },
 Nil => {
 *self = Cons(elem, Box::new(Nil))
 }
 }
 }

{
 let x: List = List::new();
 x = prepend(x, 1);
}

{
 let x: List = List::new();
 let length = len(&x);
}

{
 let x: List = List::new();
 expand(&mut x, 1);
}