Trait intuicio_essentials::prelude::DataStackPack

pub trait DataStackPack: Sized {
    // Required methods
    fn stack_push(self, stack: &mut DataStack);
    fn stack_pop(stack: &mut DataStack) -> Self;
    fn pack_types() -> Vec<TypeHash>;

    // Provided method
    fn stack_push_reversed(self, stack: &mut DataStack) { ... }
}

Required Methods

fn stack_push(self, stack: &mut DataStack)

fn stack_pop(stack: &mut DataStack) -> Self

fn pack_types() -> Vec<TypeHash>

Provided Methods

fn stack_push_reversed(self, stack: &mut DataStack)

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl DataStackPack for ()

fn stack_push(self, _: &mut DataStack)

fn stack_pop(_: &mut DataStack)

fn pack_types() -> Vec<TypeHash>

impl<A> DataStackPack for (A,)

where A: 'static,

fn stack_push(self, stack: &mut DataStack)

fn stack_pop(stack: &mut DataStack) -> (A,)

fn pack_types() -> Vec<TypeHash>

impl<A, B> DataStackPack for (A, B)

where A: 'static, B: 'static,

fn stack_push(self, stack: &mut DataStack)

fn stack_pop(stack: &mut DataStack) -> (A, B)

fn pack_types() -> Vec<TypeHash>

impl<A, B, C> DataStackPack for (A, B, C)

where A: 'static, B: 'static, C: 'static,

fn stack_push(self, stack: &mut DataStack)

fn stack_pop(stack: &mut DataStack) -> (A, B, C)

fn pack_types() -> Vec<TypeHash>

impl<A, B, C, D> DataStackPack for (A, B, C, D)

where A: 'static, B: 'static, C: 'static, D: 'static,

fn stack_push(self, stack: &mut DataStack)

fn stack_pop(stack: &mut DataStack) -> (A, B, C, D)

fn pack_types() -> Vec<TypeHash>

impl<A, B, C, D, E> DataStackPack for (A, B, C, D, E)

where A: 'static, B: 'static, C: 'static, D: 'static, E: 'static,

fn stack_push(self, stack: &mut DataStack)

fn stack_pop(stack: &mut DataStack) -> (A, B, C, D, E)

fn pack_types() -> Vec<TypeHash>

impl<A, B, C, D, E, F> DataStackPack for (A, B, C, D, E, F)

where A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static,

fn stack_push(self, stack: &mut DataStack)

fn stack_pop(stack: &mut DataStack) -> (A, B, C, D, E, F)

fn pack_types() -> Vec<TypeHash>

impl<A, B, C, D, E, F, G> DataStackPack for (A, B, C, D, E, F, G)

where A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static,

fn stack_push(self, stack: &mut DataStack)

fn stack_pop(stack: &mut DataStack) -> (A, B, C, D, E, F, G)

fn pack_types() -> Vec<TypeHash>

impl<A, B, C, D, E, F, G, H> DataStackPack for (A, B, C, D, E, F, G, H)

where A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static,

fn stack_push(self, stack: &mut DataStack)

fn stack_pop(stack: &mut DataStack) -> (A, B, C, D, E, F, G, H)

fn pack_types() -> Vec<TypeHash>

impl<A, B, C, D, E, F, G, H, I> DataStackPack for (A, B, C, D, E, F, G, H, I)

where A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static,

fn stack_push(self, stack: &mut DataStack)

fn stack_pop(stack: &mut DataStack) -> (A, B, C, D, E, F, G, H, I)

fn pack_types() -> Vec<TypeHash>

impl<A, B, C, D, E, F, G, H, I, J> DataStackPack for (A, B, C, D, E, F, G, H, I, J)

where A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static,

fn stack_push(self, stack: &mut DataStack)

fn stack_pop(stack: &mut DataStack) -> (A, B, C, D, E, F, G, H, I, J)

fn pack_types() -> Vec<TypeHash>

impl<A, B, C, D, E, F, G, H, I, J, K> DataStackPack for (A, B, C, D, E, F, G, H, I, J, K)

where A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static,

fn stack_push(self, stack: &mut DataStack)

fn stack_pop(stack: &mut DataStack) -> (A, B, C, D, E, F, G, H, I, J, K)

fn pack_types() -> Vec<TypeHash>

impl<A, B, C, D, E, F, G, H, I, J, K, L> DataStackPack for (A, B, C, D, E, F, G, H, I, J, K, L)

where A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static,

fn stack_push(self, stack: &mut DataStack)

fn stack_pop(stack: &mut DataStack) -> (A, B, C, D, E, F, G, H, I, J, K, L)

fn pack_types() -> Vec<TypeHash>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M> DataStackPack for (A, B, C, D, E, F, G, H, I, J, K, L, M)

where A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static,

fn stack_push(self, stack: &mut DataStack)

fn stack_pop(stack: &mut DataStack) -> (A, B, C, D, E, F, G, H, I, J, K, L, M)

fn pack_types() -> Vec<TypeHash>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N> DataStackPack for (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

where A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static,

fn stack_push(self, stack: &mut DataStack)

fn stack_pop( stack: &mut DataStack ) -> (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

fn pack_types() -> Vec<TypeHash>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> DataStackPack for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

where A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static, O: 'static,

fn stack_push(self, stack: &mut DataStack)

fn stack_pop( stack: &mut DataStack ) -> (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

fn pack_types() -> Vec<TypeHash>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> DataStackPack for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)

where A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static, O: 'static, P: 'static,

fn stack_push(self, stack: &mut DataStack)

fn stack_pop( stack: &mut DataStack ) -> (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)

fn pack_types() -> Vec<TypeHash>

Implementors