Trait freya::prelude::UseFutureDep

pub trait UseFutureDep: Sized + Clone {
    type Out;

    // Required methods
    fn out(&self) -> Self::Out;
    fn apply(self, state: &mut Vec<Box<dyn Any, Global>, Global>) -> bool;
}

Required Associated Types

type Out

Required Methods

fn out(&self) -> Self::Out

fn apply(self, state: &mut Vec<Box<dyn Any, Global>, Global>) -> bool

Implementations on Foreign Types

impl<A, B, C, D, E, F> UseFutureDep for (&A, &B, &C, &D, &E, &F)where A: Dep, B: Dep, C: Dep, D: Dep, E: Dep, F: Dep,

type Out = (A, B, C, D, E, F)

fn out(&self) -> <(&A, &B, &C, &D, &E, &F) as UseFutureDep>::Out

fn apply(self, state: &mut Vec<Box<dyn Any, Global>, Global>) -> bool

impl<A> UseFutureDep for &Awhere A: Dep,

type Out = A

fn out(&self) -> <&A as UseFutureDep>::Out

fn apply(self, state: &mut Vec<Box<dyn Any, Global>, Global>) -> bool

impl<A> UseFutureDep for (&A,)where A: Dep,

type Out = (A,)

fn out(&self) -> <(&A,) as UseFutureDep>::Out

fn apply(self, state: &mut Vec<Box<dyn Any, Global>, Global>) -> bool

impl<A, B, C, D, E, F, G, H> UseFutureDep for (&A, &B, &C, &D, &E, &F, &G, &H)where A: Dep, B: Dep, C: Dep, D: Dep, E: Dep, F: Dep, G: Dep, H: Dep,

type Out = (A, B, C, D, E, F, G, H)

fn out(&self) -> <(&A, &B, &C, &D, &E, &F, &G, &H) as UseFutureDep>::Out

fn apply(self, state: &mut Vec<Box<dyn Any, Global>, Global>) -> bool

impl<A, B, C> UseFutureDep for (&A, &B, &C)where A: Dep, B: Dep, C: Dep,

type Out = (A, B, C)

fn out(&self) -> <(&A, &B, &C) as UseFutureDep>::Out

fn apply(self, state: &mut Vec<Box<dyn Any, Global>, Global>) -> bool

impl<A, B, C, D, E, F, G> UseFutureDep for (&A, &B, &C, &D, &E, &F, &G)where A: Dep, B: Dep, C: Dep, D: Dep, E: Dep, F: Dep, G: Dep,

type Out = (A, B, C, D, E, F, G)

fn out(&self) -> <(&A, &B, &C, &D, &E, &F, &G) as UseFutureDep>::Out

fn apply(self, state: &mut Vec<Box<dyn Any, Global>, Global>) -> bool

impl<A, B> UseFutureDep for (&A, &B)where A: Dep, B: Dep,

type Out = (A, B)

fn out(&self) -> <(&A, &B) as UseFutureDep>::Out

fn apply(self, state: &mut Vec<Box<dyn Any, Global>, Global>) -> bool

impl<A, B, C, D, E> UseFutureDep for (&A, &B, &C, &D, &E)where A: Dep, B: Dep, C: Dep, D: Dep, E: Dep,

type Out = (A, B, C, D, E)

fn out(&self) -> <(&A, &B, &C, &D, &E) as UseFutureDep>::Out

fn apply(self, state: &mut Vec<Box<dyn Any, Global>, Global>) -> bool

impl<A, B, C, D> UseFutureDep for (&A, &B, &C, &D)where A: Dep, B: Dep, C: Dep, D: Dep,

type Out = (A, B, C, D)

fn out(&self) -> <(&A, &B, &C, &D) as UseFutureDep>::Out

fn apply(self, state: &mut Vec<Box<dyn Any, Global>, Global>) -> bool

impl UseFutureDep for ()

type Out = ()

fn out(&self) -> <() as UseFutureDep>::Out

fn apply(self, _state: &mut Vec<Box<dyn Any, Global>, Global>) -> bool

Implementors