Struct PushToStack

Source

pub struct PushToStack<Values>(pub Values);

Expand description

Results to insert during the framework’s effect-application phase.

Apply supports tuples of arity 0–16 (including heterogeneous items) and homogeneous arrays of any length. Values are inserted left to right, so the last value becomes the top. Empty tuples/arrays insert nothing. The wrapper owns values, not storage references, and does not apply itself automatically.

Tuple Fields§

§0: Values

PushToStack

Struct PushToStack Copy item path

Tuple Fields§

Trait Implementations§

impl<Destination, A: StackValue, B: StackValue> Apply<PushToStack<(A, B)>> for Destinationwhere Destination: PushStack<A::Storage> + PushStack<B::Storage> + Sized,

fn apply(&mut self, effect: PushToStack<(A, B)>)

impl<Destination, A: StackValue, B: StackValue, C: StackValue> Apply<PushToStack<(A, B, C)>> for Destinationwhere Destination: PushStack<A::Storage> + PushStack<B::Storage> + PushStack<C::Storage> + Sized,

fn apply(&mut self, effect: PushToStack<(A, B, C)>)

impl<Destination, A: StackValue, B: StackValue, C: StackValue, D: StackValue> Apply<PushToStack<(A, B, C, D)>> for Destinationwhere Destination: PushStack<A::Storage> + PushStack<B::Storage> + PushStack<C::Storage> + PushStack<D::Storage> + Sized,

fn apply(&mut self, effect: PushToStack<(A, B, C, D)>)

impl<Destination, A: StackValue, B: StackValue, C: StackValue, D: StackValue, E: StackValue> Apply<PushToStack<(A, B, C, D, E)>> for Destinationwhere Destination: PushStack<A::Storage> + PushStack<B::Storage> + PushStack<C::Storage> + PushStack<D::Storage> + PushStack<E::Storage> + Sized,

fn apply(&mut self, effect: PushToStack<(A, B, C, D, E)>)

fn apply(&mut self, effect: PushToStack<(A, B, C, D, E, F)>)

fn apply(&mut self, effect: PushToStack<(A, B, C, D, E, F, G)>)

fn apply(&mut self, effect: PushToStack<(A, B, C, D, E, F, G, H)>)

fn apply(&mut self, effect: PushToStack<(A, B, C, D, E, F, G, H, I)>)

fn apply(&mut self, effect: PushToStack<(A, B, C, D, E, F, G, H, I, J)>)

fn apply(&mut self, effect: PushToStack<(A, B, C, D, E, F, G, H, I, J, K)>)

fn apply(&mut self, effect: PushToStack<(A, B, C, D, E, F, G, H, I, J, K, L)>)

fn apply( &mut self, effect: PushToStack<(A, B, C, D, E, F, G, H, I, J, K, L, M)>, )

fn apply( &mut self, effect: PushToStack<(A, B, C, D, E, F, G, H, I, J, K, L, M, N)>, )

fn apply( &mut self, effect: PushToStack<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)>, )

fn apply( &mut self, effect: PushToStack<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)>, )

impl<Destination, A: StackValue> Apply<PushToStack<(A,)>> for Destinationwhere Destination: PushStack<A::Storage> + Sized,

fn apply(&mut self, effect: PushToStack<(A,)>)

impl<D, T: StackValue, const N: usize> Apply<PushToStack<[T; N]>> for Dwhere D: PushStack<T::Storage>,

fn apply(&mut self, effect: PushToStack<[T; N]>)

impl<Values: Clone> Clone for PushToStack<Values>

fn clone(&self) -> PushToStack<Values>

fn clone_from(&mut self, source: &Self)

impl<Values: Copy> Copy for PushToStack<Values>

impl<Values: Debug> Debug for PushToStack<Values>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl<Values: Eq> Eq for PushToStack<Values>

impl<Values: PartialEq> PartialEq for PushToStack<Values>

fn eq(&self, other: &PushToStack<Values>) -> bool

fn ne(&self, other: &Rhs) -> bool

impl<Values: PartialEq> StructuralPartialEq for PushToStack<Values>

Auto Trait Implementations§

impl<Values> Freeze for PushToStack<Values>where Values: Freeze,

impl<Values> RefUnwindSafe for PushToStack<Values>where Values: RefUnwindSafe,

impl<Values> Send for PushToStack<Values>where Values: Send,

impl<Values> Sync for PushToStack<Values>where Values: Sync,

impl<Values> Unpin for PushToStack<Values>where Values: Unpin,

impl<Values> UnsafeUnpin for PushToStack<Values>where Values: UnsafeUnpin,

impl<Values> UnwindSafe for PushToStack<Values>where Values: UnwindSafe,

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<D> Apply<PushToStack<()>> for D

fn apply(&mut self, _: PushToStack<()>)

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> CloneToUninit for Twhere T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

impl<Q, K> Equivalent<K> for Qwhere Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

fn equivalent(&self, key: &K) -> bool

impl<T> From<T> for T

fn from(t: T) -> T

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<'src, T> IntoMaybe<'src, T> for Twhere T: 'src,

type Proj<U: 'src> = U

fn map_maybe<R>( self, _f: impl FnOnce(&'src T) -> &'src R, g: impl FnOnce(T) -> R, ) -> <T as IntoMaybe<'src, T>>::Proj<R>where R: 'src,

impl<T> OrderedSeq<'_, T> for Twhere T: Clone,

impl<'p, T> Seq<'p, T> for Twhere T: Clone,

type Item<'a> = &'a T where T: 'a

type Iter<'a> = Once<&'a T> where T: 'a

fn seq_iter(&self) -> <T as Seq<'p, T>>::Iter<'_>

fn contains(&self, val: &T) -> boolwhere T: PartialEq,

fn to_maybe_ref<'b>(item: <T as Seq<'p, T>>::Item<'b>) -> Maybe<T, &'p T>where 'p: 'b,

impl<T> ToOwned for Twhere T: Clone,

type Owned = T

fn to_owned(&self) -> T

fn clone_into(&self, target: &mut T)

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Struct PushToStack

impl<Destination, A: StackValue, B: StackValue> Apply<PushToStack<(A, B)>> for Destination
where Destination: PushStack<A::Storage> + PushStack<B::Storage> + Sized,

impl<Destination, A: StackValue, B: StackValue, C: StackValue> Apply<PushToStack<(A, B, C)>> for Destination
where Destination: PushStack<A::Storage> + PushStack<B::Storage> + PushStack<C::Storage> + Sized,

impl<Destination, A: StackValue, B: StackValue, C: StackValue, D: StackValue> Apply<PushToStack<(A, B, C, D)>> for Destination
where Destination: PushStack<A::Storage> + PushStack<B::Storage> + PushStack<C::Storage> + PushStack<D::Storage> + Sized,

impl<Destination, A: StackValue, B: StackValue, C: StackValue, D: StackValue, E: StackValue> Apply<PushToStack<(A, B, C, D, E)>> for Destination
where Destination: PushStack<A::Storage> + PushStack<B::Storage> + PushStack<C::Storage> + PushStack<D::Storage> + PushStack<E::Storage> + Sized,

impl<Destination, A: StackValue> Apply<PushToStack<(A,)>> for Destination
where Destination: PushStack<A::Storage> + Sized,

impl<D, T: StackValue, const N: usize> Apply<PushToStack<[T; N]>> for D
where D: PushStack<T::Storage>,

impl<Values> Freeze for PushToStack<Values>
where Values: Freeze,

impl<Values> RefUnwindSafe for PushToStack<Values>
where Values: RefUnwindSafe,

impl<Values> Send for PushToStack<Values>
where Values: Send,

impl<Values> Sync for PushToStack<Values>
where Values: Sync,

impl<Values> Unpin for PushToStack<Values>
where Values: Unpin,

impl<Values> UnsafeUnpin for PushToStack<Values>
where Values: UnsafeUnpin,

impl<Values> UnwindSafe for PushToStack<Values>
where Values: UnwindSafe,

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<T> CloneToUninit for T
where T: Clone,

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

impl<T, U> Into<U> for T
where U: From<T>,

impl<'src, T> IntoMaybe<'src, T> for T
where T: 'src,

fn map_maybe<R>( self, _f: impl FnOnce(&'src T) -> &'src R, g: impl FnOnce(T) -> R, ) -> <T as IntoMaybe<'src, T>>::Proj<R>
where R: 'src,

impl<T> OrderedSeq<'_, T> for T
where T: Clone,

impl<'p, T> Seq<'p, T> for T
where T: Clone,

fn contains(&self, val: &T) -> bool
where T: PartialEq,

fn to_maybe_ref<'b>(item: <T as Seq<'p, T>>::Item<'b>) -> Maybe<T, &'p T>
where 'p: 'b,

impl<T> ToOwned for T
where T: Clone,

impl<T, U> TryFrom<U> for T
where U: Into<T>,

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,