Struct cut::App

pub struct App<'a, F, A> {
    pub applied: Box<dyn HasTypeApp<'a, F, A> + 'a, Global>,
}

Fields

applied: Box<dyn HasTypeApp<'a, F, A> + 'a, Global>

Implementations

impl<'a, F, A> App<'a, F, A>

pub fn new(applied: <F as TypeApp<'a, A>>::Applied) -> App<'a, F, A> where
    F: TypeApp<'a, A>,
    <F as TypeApp<'a, A>>::Applied: 'a, 

pub fn get_applied(self) -> <F as TypeApp<'a, A>>::Applied where
    F: TypeApp<'a, A>, 

Trait Implementations

impl<'a, F, X, T> Deserialize<'a> for App<'a, F, X> where
    T: 'a + Serialize + for<'de> Deserialize<'de>,
    F: TypeApp<'a, X, Applied = T>, 

fn deserialize<D>(
    deserializer: D
) -> Result<App<'a, F, X>, <D as Deserializer<'a>>::Error> where
    D: Deserializer<'a>, 

Deserialize this value from the given Serde deserializer.

impl<F, X, T> ForwardChannel for App<'static, F, X> where
    X: 'static,
    F: 'static + TypeApp<'static, X, Applied = T>,
    T: ForwardChannel, 

fn forward_to(self, sender: OpaqueSender, receiver: OpaqueReceiver)

fn forward_from(
    sender: OpaqueSender,
    receiver: OpaqueReceiver
) -> App<'static, F, X>

impl<'a, F, X, T> Serialize for App<'a, F, X> where
    T: Send + Serialize + for<'de> Deserialize<'de>,
    F: TypeApp<'a, X, Applied = T>, 

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.