Shared via Rust Playground

playground.rs

fn main() {
    type One = Succ<Zero>;
    type Two = Succ<One>;
    type Three = Succ<Two>;
    type Five = <Two as Add<Three>>::Result;
    type Four = <One as Sub<Five>>::Result;
    
    println!("Zero: {}", Zero::fmt());
    println!("One: {}", One::fmt());
    println!("Two: {}", Two::fmt());
    println!("Three: {}", Three::fmt());
    println!("Four: {}", Four::fmt());
    println!("Five: {}", Five::fmt());
}

trait Peano {
    fn fmt() -> String;
}

struct Zero;

impl Peano for Zero {
    fn fmt() -> String {
        "Zero".to_string()
    }
}

struct Succ<T> {
    t: T,
}
impl<T: Peano> Peano for Succ<T> {
    fn fmt() -> String {
        format!("Succ<{}>", T::fmt())
    }
}

trait Add<T> {
    type Result: Peano;
}

impl<T: Peano> Add<T> for Zero {
    type Result = T;
}

impl<T, U> Add<T> for Succ<U>
    where U: Add<Succ<T>>,
{
    type Result = <U as Add<Succ<T>>>::Result;
}

trait Sub<T> {
    type Result: Peano;
}

impl<T: Peano> Sub<T> for Zero {
    type Result = T;
}

impl<T, U> Sub<Succ<T>> for Succ<U> 
    where T: Peano,
          U: Peano,
          U: Sub<T>,
{
    type Result = <U as Sub<T>>::Result;
}