Proof of concept for Yew required props

yew_required_props.rs

use std::marker::PhantomData;
use yew::Properties;

struct Alpha;

#[derive(Properties)]
struct Props {
    #[props(required)]
    alpha: Alpha,
    beta: Option<bool>,
    charlie: String,
    #[props(required)]
    delta: Option<String>,
}

fn proof_of_concept() {
    // `yew_html` GENERATED CODE
    // -------------------------
    let props: Props = PropsBuilder::<Start>::new()
        .alpha(Alpha {})
        .charlie(String::from("yo"))
        .delta(None)
        .build();
    // ----------------------------
}

// `yew_props_derive` GENERATED CODE
// ---------------------------------

struct Start;
struct AfterAlpha;
struct AfterDelta;

trait NextProp {}
impl NextProp for Start {}
impl NextProp for AfterAlpha {}
impl NextProp for AfterDelta {}

struct WrappedProps {
    alpha_wrapper: Option<Alpha>,
    beta: Option<bool>,
    charlie: String,
    delta_wrapper: Option<Option<String>>,
}

struct PropsBuilder<P: NextProp> {
    wrapped: Box<WrappedProps>,
    _marker: PhantomData<P>,
}

impl PropsBuilder<Start> {
    fn new() -> Self {
        PropsBuilder {
            wrapped: Box::new(WrappedProps {
                alpha_wrapper: Default::default(),
                beta: Default::default(),
                charlie: Default::default(),
                delta_wrapper: Default::default(),
            }),
            _marker: PhantomData,
        }
    }

    fn alpha(mut self, alpha: Alpha) -> PropsBuilder<AfterAlpha> {
        self.wrapped.alpha_wrapper = Some(alpha);
        PropsBuilder {
            wrapped: self.wrapped,
            _marker: PhantomData,
        }
    }
}

impl PropsBuilder<AfterAlpha> {
    fn beta(mut self, beta: Option<bool>) -> PropsBuilder<AfterAlpha> {
        self.wrapped.beta = beta;
        self
    }

    fn charlie(mut self, charlie: String) -> PropsBuilder<AfterAlpha> {
        self.wrapped.charlie = charlie;
        self
    }

    fn delta(mut self, delta: Option<String>) -> PropsBuilder<AfterDelta> {
        self.wrapped.delta_wrapper = Some(delta);
        PropsBuilder {
            wrapped: self.wrapped,
            _marker: PhantomData,
        }
    }
}

impl PropsBuilder<AfterDelta> {
    fn build(self) -> Props {
        Props {
            alpha: self.wrapped.alpha_wrapper.unwrap(),
            beta: self.wrapped.beta,
            charlie: self.wrapped.charlie,
            delta: self.wrapped.delta_wrapper.unwrap(),
        }
    }
}