AVL Tree implementation in Rust

I'm mainly looking for tips in how make my code more idiomatic and elegant, but any general reviews are welcome.

pub mod set {

    use ::std::cmp;
    use ::std::cmp::Ordering::{Less, Greater, Equal};
    use ::std::mem;

    pub struct AvlTree<T : Ord> {
        root : Option<Box<Node<T>>>
    }

    struct Node<T : Ord> {
        key    : T,
        height : i32,
        left   : AvlTree<T>,
        right  : AvlTree<T>,
    }

    impl<T> Node<T> where T : Ord{
        fn new(key: T) -> Option<Box<Node<T>>>{
            Some(Box::new(
                    Node { 
                        key    : key, 
                        height : 0, 
                        left   : AvlTree::new(), 
                        right  : AvlTree::new() 
                    }
            )) 
        }   
    }

    impl<T> AvlTree<T>  where T : Ord{  

        pub fn new() -> AvlTree<T> {
            AvlTree { root: None }
        }

        fn rotate<CA, CB>(&mut self, ch_a: &CA, ch_b: &CB) 
        where CA: Fn(&mut Box<Node<T>>) -> &mut AvlTree<T>,
              CB: Fn(&mut Box<Node<T>>) -> &mut AvlTree<T> {

            let mut root          = self.node_take();                              
            let mut child         = ch_a(&mut root).node_take();                                                    
            ch_a(&mut root).root  = ch_b(&mut child).root.take();
            ch_b(&mut child).root = Some(root);

            ch_b(&mut child).update_height();
            self.root = Some(child);
            self.update_height();
        }

        fn double_rotate<CA, CB>(&mut self, ch_a: &CA, ch_b: &CB) 
        where CA: Fn(&mut Box<Node<T>>) -> &mut AvlTree<T>,
              CB: Fn(&mut Box<Node<T>>) -> &mut AvlTree<T> {
            {
                let child = ch_b(self.m_box());
                if ch_b(child.m_box()).h() < ch_a(child.m_box()).h() {
                    child.rotate(ch_a, ch_b);
                }
            }                   
            self.rotate(ch_b, ch_a);    
        }

        fn restructure(& mut self) {                        
            self.update_height();
            let ord = self.root.as_ref()
                          .map(|_| self.degree())
                          .map(|d| (d, d.cmp(&0)));                           
            match ord {
                Some((d, Less))  if -1 > d  => {  
                    self.double_rotate(
                        &|x| &mut x.left, 
                        &|x| &mut x.right)
                },
                Some((d, Greater)) if d > 1 => {
                    self.double_rotate(
                        &|x| &mut x.right, 
                        &|x| &mut x.left)
                },
                _ => { },
            }
        }     

        fn update_height(&mut self) {
            self.root.as_mut()
                .map(|r| r.height = cmp::max(r.right.h(), r.left.h()) + 1);
        } 

        fn m_box(&mut self) -> &mut Box<Node<T>> {
            self.root.as_mut().expect("root can't be None")
        }

        fn r_box(&self) -> & Box<Node<T>> {
            self.root.as_ref().expect("root can't be None")
        }

        fn node_take(&mut self) -> Box<Node<T>> {
            self.root.take().expect("root can't be None")
        }

        fn h(&self) -> i32 {
            self.root.as_ref().map_or(-1, |x| x.height)
        }

        fn degree(&self) -> i32 {
            self.root
                .as_ref()
                .map(|x| x.left.h() - x.right.h())
                .unwrap_or(0)
        }

        pub fn insert(&mut self, key : T) { 
            match self.map_to_ord(&key) {
                Some(Less)    => self.m_box().left.insert(key),
                Some(Greater) => self.m_box().right.insert(key),
                None          => self.root = Node::new(key),
                _             => return,
            }
            self.restructure();     
        }

        pub fn remove(&mut self, key: &T) {     
            match self.map_to_ord(key) {
                Some(Less)    => self.m_box().left.remove(key),
                Some(Greater) => self.m_box().right.remove(key),
                Some(Equal)   => self.remove_self(key),
                None          => return,

            };
            self.restructure();         
        }

        fn min(&mut self) -> &mut Box<Node<T>> {
            let n = self.m_box();
            if n.left.root.is_none(){
                return n; 
            }
            n.left.min()    
        }

        fn map_to_ord(&self, key: &T) -> Option<cmp::Ordering> {
            self.root.as_ref()
                .map(|p| &p.key)
                .map(|k| key.cmp(k))
        }

        pub fn contains(& self, key: &T) -> bool {      
            match self.map_to_ord(key) {
                Some(Less)    => self.r_box().left.contains(key),
                Some(Greater) => self.r_box().right.contains(key),
                Some(Equal)   => true,
                None          => false,
            }               
        }

        fn remove_self(&mut self, key: &T) {            
            let mut c = self.node_take();
            self.root = match (c.left.root.take(), 
                               c.right.root.take()) {

                (None, right) => right,     
                (left, None)  =>  left,                     
                (l@ Some(_), r@ Some(_)) => {
                    let mut right = AvlTree{root: r};
                    mem::swap(
                        &mut right.min().key, 
                        &mut c.key);

                    c.right     = right;
                    c.left.root = l;
                    c.right.remove(key);
                    Some(c)
                }
            };
        }

        pub fn iter<'a>(&'a self) -> TreeIterator<'a, T> {
            TreeIterator { 
                current : self.root.as_ref(),
                path: Vec::new(),
            }   
        }
    }

    pub struct TreeIterator<'a, T: 'a> where T: Ord {
        current : Option<&'a Box<Node<T>>>,
        path: Vec<&'a Box<Node<T>>>,
    }

    impl<'a, T> IntoIterator for & 'a AvlTree<T> where T: Ord {
        type Item = &'a T;
        type IntoIter = TreeIterator<'a, T>;
        fn into_iter(self) -> Self::IntoIter {
            self.iter()
        }
    }

    impl<'a, T> Iterator for TreeIterator<'a, T> where T: Ord { 
        type Item = &'a T;   

        fn next<'b>(&'b mut self) -> Option<Self::Item> {                        
            let mut c = self.current;
            while let Some(n) = c {
                self.path.push(n);
                c = n.left.root.as_ref();
            }
            self.path.pop().map(|n|{
                self.current = n.right.root.as_ref();
                &n.key
            })                             
        }
    }
}