pub struct Node<T> {
        value: T,
        left: Option<Box<Node<T>>>,
        right: Option<Box<Node<T>>>,
}

pub struct Tree<T> {
        root: Option<Box<Node<T>>>,
}

impl<T: Ord> Tree<T> {
    /// Creates an empty tree
    pub fn new() -> Self {
        Tree {root: None }

    }

    // search the tree
    pub fn find(&self, key: &T) -> bool {
          let root_node = &self.root; // root is Option

          match *root_node {
            Some(ref node) => {

                if node.value == *key {
                    return true;
                }

                let target_node = if *key < node.value {&node.left} else {&node.right};

                match *target_node {
                    Some(sub_node)  =>  sub_node.find(key),
                    None   => {return false;}
                }
            },
            None            => return false
        }
    }
}

fn main() {

    let mut mytree: Tree<i32> = Tree::new();

    let node1 = Node {
        value: 100,
        left: None,
        right: None,
    };
    let boxed_node1 = Some(Box::new(node1));

    let root = Node {
        value: 200,
        left: boxed_node1,
        right: None,
    };
    let boxed_root = Some(Box::new(root));
    let mytree = Tree { root: boxed_root};

    let res = mytree.find(&100);
}

error: no method named `find` found for type `Box<Node<T>>` in the current scope