Реализация BST в ржавчине

Я ищу отзывы о моей реализации двоичного дерева поиска в ржавчине, и я был бы признателен, если бы кто-то нашел время, чтобы изучить его и предложить любые улучшения или исправления по своему усмотрению. В частности, меня беспокоит, должен ли я Clone происходит из BST а также Node структуры, так как я их здесь не использую.

#![allow(unused)]

use std::fmt::Debug;
fn main() {
    let mut bst = BST::new(3_i32);
    bst.append(4);
    bst.append(1);
    bst.append(12);
    bst.display();
}
#[derive(Debug)]
pub struct BST<T> {
    root: Box<Node<T>>,
}
#[derive(Clone, Debug)]
pub struct Node<T> {
    val: T,
    left: Option<Box<Node<T>>>,
    right: Option<Box<Node<T>>>,
}

impl<T> BST<T>
where
    T: PartialOrd + Debug + Clone,
{
    pub fn new(val: T) -> Self {
        let root = Box::new(Node {
            val,
            left: None,
            right: None,
        });
        Self { root }
    }
    pub fn append(&mut self, new_val: T) {
        let new_node = Box::new(Node {
            val: new_val,
            left: None,
            right: None,
        });
        Self::push_node(new_node, &mut self.root);
    }
    // Private and recursive method
    // recursively search through every node until the value is inserted
    fn push_node(new_node: Box<Node<T>>, current_node: &mut Box<Node<T>>) {
        let ref new_val = new_node.val;
        let ref current_val = current_node.val;
        if *current_val <= *new_val {
            if let Some(ref mut left) = current_node.left {
                Self::push_node(new_node, left);
            } else {
                current_node.left = Some(new_node);
            }
        } else if *current_val > *new_val {
            if let Some(ref mut right) = current_node.right {
                Self::push_node(new_node, right);
            } else {
                current_node.right = Some(new_node);
            }
        }
    }

    fn display(&self) {
        println!("{:#?}", self);
    }
}