use std::marker::PhantomData;

struct PA;
struct PB;
struct PC;

struct P; // Present Tag
struct NP; // Non Present Tag

struct Parts<A, B, C> {
    _a: PhantomData<A>,
    _b: PhantomData<B>,
    _c: PhantomData<C>,
}

pub fn new() -> Parts<P, P, P> {
    create()
}

fn create<A, B, C>() -> Parts<A, B, C> {
    Parts {
        _a: PhantomData,
        _b: PhantomData,
        _c: PhantomData,
    }
}

impl<B,C> Parts<P, B, C> {
    pub fn pa(self) -> (PA, Parts<NP, B, C>) {
        (PA, create())
    }
}

impl<A,C> Parts<A, P, C> {
    pub fn pb(self) -> (PB, Parts<A, NP, C>) {
        (PB, create())
    }
}

impl<A, B> Parts<A, B, P> {
    pub fn pc(self) -> (PC, Parts<A, B, NP>) {
        (PC, create())
    }
}

struct Led {
    p: PB,
}

impl Led {
    pub fn new<A, C>(parts: Parts<A, P, C>) -> (Self, Parts<A, NP, C>) {
        let (pb, parts) = parts.pb();
        (Led{ p: pb}, parts)
    }
}

fn main() {
    let parts = new();

    let (led, parts) = Led::new(parts);

    // Second one fails
    let (led, parts) = Led::new(parts);
}