Implementing a simple Stack within Rust

Stack.rs

use std::boxed::Box;
use std::mem;

enum CellarState<S>{
    Empty,
    Value (S,Box<CellarState<S>>),
}

pub struct Cellar<S>{
    // The Cellar of the Automaton
    cellar: CellarState<S>,
}

impl <S> Cellar<S>{
    fn push(&mut self, next_state: S) -> (){
        let tmp_cellar = mem::replace(&mut self.cellar,CellarState::Empty);
        self.cellar = CellarState::Value(next_state,Box::new(tmp_cellar));
    }
    fn pop(&mut self)->Option<S>{
        match mem::replace(&mut self.cellar,CellarState::Empty){
            CellarState::Empty => None,
            CellarState::Value(state,tmp_cellar) => {
                self.cellar = *tmp_cellar;
                Some(state)
            },
        }
    }
    fn top(&self)->Option<&S>{
        match self.cellar{
            CellarState::Empty => None,
            CellarState::Value(ref state,_) => {
                Some(state)
            },
        }
    }
}

impl <S> Default for Cellar<S>{
    fn default() -> Cellar<S>{
        return Cellar{
            cellar: CellarState::Empty,
        }
    }
}

#[test]
fn validate() {
    
    let mut pda : Cellar<i32> = Cellar::default();
    
    // New cellar.
    assert!(pda.top().is_none());
    
    // Fill empty cellar.
    pda.push(10);
    
    assert!(pda.top().is_some());
    
    // Fill full cellar a bit more.
    pda.push(22);
    pda.push(15);
    pda.push(39);
    
    assert!(pda.top().is_some());
    
    // Assure correct top.
    assert_eq!(39,*pda.top().unwrap());
    
    // Remove from filled cellar.
    pda.pop();
    
    assert!(pda.top().is_some());
    assert_eq!(15,*pda.top().unwrap());
    
    // Empty out cellar.
    pda.pop();
    pda.pop();
    pda.pop();
    
    assert!(pda.top().is_none());
    
    // Remove from already empty cellar.
    pda.pop();
    
    assert!(pda.top().is_none());
    
}