#![allow(unused)]
use std::convert::From;

#[derive(Debug)]
struct LeafOne {
    arg0: usize,
}

#[derive(Debug)]
struct LeafTwo {
    arg0: usize,
    arg1: usize,
}

#[derive(Debug)]
struct LeafThree {
    arg0: usize,
    arg1: usize,
    arg2: usize,
}

#[derive(Debug)]
struct LeafFour {
    arg0: String,
}

#[derive(Debug)]
struct LeafFive {
    arg0: bool,
}

#[derive(Debug)]
enum InnerChoice {
    One(LeafOne),
    Two(LeafTwo),
    Three(LeafThree),
}

#[derive(Debug)]
enum MiddleChoice {
    Inner(InnerChoice),
    Four(LeafFour),
}

#[derive(Debug)]
enum OuterChoice {
    Middle(MiddleChoice),
    Five(LeafFive),
}

impl From<LeafOne> for InnerChoice {
    fn from(leaf: LeafOne) -> Self {
        InnerChoice::One(leaf)
    }
}

impl From<LeafTwo> for InnerChoice {
    fn from(leaf: LeafTwo) -> Self {
        InnerChoice::Two(leaf)
    }
}

impl From<LeafThree> for InnerChoice {
    fn from(leaf: LeafThree) -> Self {
        InnerChoice::Three(leaf)
    }
}

impl From<InnerChoice> for MiddleChoice {
    fn from(inner: InnerChoice) -> Self {
        MiddleChoice::Inner(inner)
    }
}

impl From<LeafFour> for MiddleChoice {
    fn from(four: LeafFour) -> Self {
        MiddleChoice::Four(four)
    }
}

impl From<MiddleChoice> for OuterChoice {
    fn from(mid: MiddleChoice) -> Self {
        OuterChoice::Middle(mid)
    }
}

impl From<LeafFive> for OuterChoice {
    fn from(five: LeafFive) -> Self {
        OuterChoice::Five(five)
    }
}

fn main() {
    let leaf_one = LeafOne { arg0: 42 };

    println!("{:#?}\n", leaf_one);

    let out = OuterChoice::from(MiddleChoice::from(InnerChoice::from(LeafTwo {
        arg0: 13,
        arg1: 2,
    })));

    println!("{:#?}\n", out);
}