an attempt at making a tree which leaves out leaf nodes when printing. it uses the box keyword for pattern matching on boxes

conditional-tree-formatting.rs

#![feature(box_patterns)]
use std::fmt;

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Clone)]
enum Tree<T: fmt::Display> {
    Leaf,
    Node { data: T, left: Box<Tree<T>>, right: Box<Tree<T>> },
}

impl<T: fmt::Display> fmt::Display for Tree<T> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            Tree::Node {data: ref d, left: box Tree::Leaf, right: box Tree::Leaf} =>
                write!(f, "(Data: {})", d),
            Tree::Node {data: ref d, left: ref l, right: box Tree::Leaf} =>
                write!(f, "(Data: {}, Left: {})", d, *l),
            Tree::Node {data: ref d, left: box Tree::Leaf, right: ref r} =>
                write!(f, "(Data: {}, Right: {})", d, *r),
            Tree::Node {data: ref d, left: ref l, right: ref r} => 
                write!(f, "(Data: {}, Left: {}, Right: {}", d, *l, *r),
            Tree::Leaf => write!(f, ""),
        }
    }
}

fn node<T: fmt::Display>(d: T, l: Tree<T>, r: Tree<T>) -> Tree<T> {
    Tree::Node {
        data: d,
        left: Box::new(l),
        right: Box::new(r),
    }
}

fn lnode<T: fmt::Display>(d: T, l: Tree<T>) -> Tree<T> {
    node(d, l, leaf())
}

fn rnode<T: fmt::Display>(d: T, r: Tree<T>) -> Tree<T> {
    node(d, leaf(), r)
}

fn dnode<T: fmt::Display>(d: T) -> Tree<T> {
    node(d, leaf(), leaf())
}

fn leaf<T: fmt::Display>() -> Tree<T> {
    Tree::Leaf   
}

fn main() {
    let t = node(12, rnode(13, lnode(42, dnode(23))), dnode(14));
    println!("{}", t);
}