1. use std::mem;
    3. struct Node{
    4.     elem : i32,
    5.     next : Link,
    6. }
    8. enum Link{
    9.     Empty,
    10.     More(Box<Node>),
    11.  }
    13.  pub struct List{
    14.     head: Link,
    15.  }
    17.  impl List{
    18.     pub fn new() -> List{
    19.         List { head: Link::Empty }
    20.     }
    22.     pub fn push(&mut self,val : i32){
    23.         let node = Node{
    24.              elem: val,
    25.              next: mem::replace(&mut self.head,Link::Empty),
    26.         };
    27.         self.head = Link::More(Box::new(node));
    28.     }
    31.     pub fn pop(&mut self) -> Option<i32>{
    32.         match mem::replace(&mut self.head,Link::Empty){
    33.             Link::Empty => None,
    34.             Link::More(ref mut node) => {
    35.                 mem::swap(&mut self.head,&mut node.next);
    36.                 Some(node.elem)
    37.             }
    38.         }
    39.     }
    40.  }
    42.  impl Drop for List {
    43.     fn drop(&mut self) {
    44.         let mut cur_link = mem::replace(&mut self.head, Link::Empty);
    45.         // `while let` == "do this thing until this pattern doesn't match"
    46.         while let Link::More(mut boxed_node) = cur_link {
    47.             cur_link = mem::replace(&mut boxed_node.next, Link::Empty);
    48.             // boxed_node goes out of scope and gets dropped here;
    49.             // but its Node's `next` field has been set to Link::Empty
    50.             // so no unbounded recursion occurs.
    51.         }
    52.     }
    53. }
    55. pub mod test {
    57.     use super::List;
    59.     #[test]
    60.     fn basic(){
    61.         base();
    62.     }
    64.     pub fn base() {
    65.         let mut list = List::new();
    67.         // Check empty list behaves right
    68.         assert_eq!(list.pop(), None);
    70.         // Populate list
    71.         list.push(1);
    72.         list.push(2);
    73.         list.push(3);
    75.         // Check normal removal
    76.         assert_eq!(list.pop(), Some(3));
    77.         assert_eq!(list.pop(), Some(2));
    79.         // Push some more just to make sure nothing's corrupted
    80.         list.push(4);
    81.         list.push(5);
    83.         // Check normal removal
    84.         assert_eq!(list.pop(), Some(5));
    85.         assert_eq!(list.pop(), Some(4));
    87.         // Check exhaustion
    88.         assert_eq!(list.pop(), Some(1));
    89.         assert_eq!(list.pop(), None);
    90.     }
    91. }
    1. mod first;
    3. fn main(){
    4.     first::test::base();
    5.     second::test::base();
    6. }