unsafe fn steal_rightward(&mut self) {
        // Take the biggest stuff off left
        let (mut key, mut val, edge) = {
            let mut left_handle = self.left_edge();
            let left = left_handle.edge_mut();
            let (key, val) = left.pop_kv();
            let edge = if left.is_leaf() {
                None
            } else {
                Some(left.pop_edge())
            };

            (key, val, edge)
        };

        // Swap the parent's separating key-value pair with left's
        mem::swap(&mut key, self.key_mut());
        mem::swap(&mut val, self.val_mut());

        // Put them at the start of right
        let mut right_handle = self.right_edge();
        let right = right_handle.edge_mut();
        right.insert_kv(0, key, val);
        match edge {
            Some(edge) => right.insert_edge(0, edge),
            None => {}
        }
    }
/// Steal! Stealing is roughly analogous to a binary tree rotation.
/// In this case, we're "rotating" right.
Steal. Stealing is roughly analogous to a binary tree rotation.
In this case, we're "rotating" right.
Steal . Stealing is roughly analogous to a binary tree rotation . In this case we ' re " rotating " right .
unsafe fn steal_rightward(&mut self) {
        // Take the biggest stuff off left
        let (mut key, mut val, edge) = {
            let mut left_handle = self.left_edge();
            let left = left_handle.edge_mut();
            let (key, val) = left.pop_kv();
            let edge = if left.is_leaf() {
                None
            } else {
                Some(left.pop_edge())
            };
            (key, val, edge)
        };
        // Swap the parent's separating key-value pair with left's
        mem::swap(&mut key, self.key_mut());
        mem::swap(&mut val, self.val_mut());
        // Put them at the start of right
        let mut right_handle = self.right_edge();
        let right = right_handle.edge_mut();
        right.insert_kv(0, key, val);
        match edge {
            Some(edge) => right.insert_edge(0, edge),
            None => {}
        }
    }
unsafe fn steal_rightward ( & mut self ) { // Take the biggest stuff off left let ( mut key , mut val , edge ) = { let mut left_handle = self . left_edge ( ) ; let left = left_handle . edge_mut ( ) ; let ( key , val ) = left . pop_kv ( ) ; let edge = if left . is_leaf ( ) { None } else { Some ( left . pop_edge ( ) ) } ; ( key , val , edge ) } ; // Swap the parent's separating key-value pair with left's mem :: swap ( & mut key , self . key_mut ( ) ) ; mem :: swap ( & mut val , self . val_mut ( ) ) ; // Put them at the start of right let mut right_handle = self . right_edge ( ) ; let right = right_handle . edge_mut ( ) ; right . insert_kv ( 0 , key , val ) ; match edge { Some ( edge ) => right . insert_edge ( 0 , edge ) , None => { } } }
Steal!
Steal!
&mut self