Struct CStackList 

#[repr(C)]
pub struct CStackList<H, T: CStackListHeadLimit>(pub T, pub H);

A list using a guaranteed memory layout (repr(C)), with tail stored first so appending items does not change the memory layout of prior items.

Tuple Fields

0: T

1: H

Trait Implementations

impl<H: 'static, T: CStackListHeadLimit> CStackListHeadLimit for CStackList<H, T>

const HEAD_LIMIT: usize

The offset to the end of the head element.

impl<H: 'static, T: CStackListHeadLimit> CStackListHeadPadded for CStackList<H, T>

const HEAD_PADDED: bool

Whether the head element is padded to the next alignment boundary.

impl<H: Clone, T: Clone + CStackListHeadLimit> Clone for CStackList<H, T>

fn clone(&self) -> CStackList<H, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<H, T> Debug for CStackList<H, T>

where H: Debug + 'static, T: DebugHelper + List + CStackListHeadLimit,

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

Formats the value using the given formatter.

impl<H: 'static, T: List + CStackListHeadLimit, Idx> Index<Idx> for CStackList<H, T>

where Self: ListIndex<Idx>, <Self as ListIndex<Idx>>::Output: Sized,

type Output = <CStackList<H, T> as ListIndex<Idx>>::Output

The returned type after indexing.

fn index(&self, index: Idx) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<A: 'static> IntoRustTuple for CStackList<A, CNil<()>>

type Tuple = (A,)

The native tuple type with fields in logical source order.

fn into_rust_tuple(self) -> Self::Tuple

Moves each logical field into the corresponding native tuple field.

impl<A: 'static, B: 'static> IntoRustTuple for CStackList<A, CStackList<B, CNil<()>>>

type Tuple = (A, B)

The native tuple type with fields in logical source order.

fn into_rust_tuple(self) -> Self::Tuple

Moves each logical field into the corresponding native tuple field.

impl<A: 'static, B: 'static, C: 'static> IntoRustTuple for CStackList<A, CStackList<B, CStackList<C, CNil<()>>>>

type Tuple = (A, B, C)

The native tuple type with fields in logical source order.

fn into_rust_tuple(self) -> Self::Tuple

Moves each logical field into the corresponding native tuple field.

impl<A: 'static, B: 'static, C: 'static, D: 'static> IntoRustTuple for CStackList<A, CStackList<B, CStackList<C, CStackList<D, CNil<()>>>>>

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

The native tuple type with fields in logical source order.

fn into_rust_tuple(self) -> Self::Tuple

Moves each logical field into the corresponding native tuple field.

impl<A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> IntoRustTuple for CStackList<A, CStackList<B, CStackList<C, CStackList<D, CStackList<E, CNil<()>>>>>>

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

The native tuple type with fields in logical source order.

fn into_rust_tuple(self) -> Self::Tuple

Moves each logical field into the corresponding native tuple field.

impl<A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> IntoRustTuple for CStackList<A, CStackList<B, CStackList<C, CStackList<D, CStackList<E, CStackList<F, CNil<()>>>>>>>

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

The native tuple type with fields in logical source order.

fn into_rust_tuple(self) -> Self::Tuple

Moves each logical field into the corresponding native tuple field.

impl<A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static> IntoRustTuple for CStackList<A, CStackList<B, CStackList<C, CStackList<D, CStackList<E, CStackList<F, CStackList<G, CNil<()>>>>>>>>

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

The native tuple type with fields in logical source order.

fn into_rust_tuple(self) -> Self::Tuple

Moves each logical field into the corresponding native tuple field.

impl<A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static> IntoRustTuple for CStackList<A, CStackList<B, CStackList<C, CStackList<D, CStackList<E, CStackList<F, CStackList<G, CStackList<H, CNil<()>>>>>>>>>

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

The native tuple type with fields in logical source order.

fn into_rust_tuple(self) -> Self::Tuple

Moves each logical field into the corresponding native tuple field.

impl<A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static> IntoRustTuple for CStackList<A, CStackList<B, CStackList<C, CStackList<D, CStackList<E, CStackList<F, CStackList<G, CStackList<H, CStackList<I, CNil<()>>>>>>>>>>

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

The native tuple type with fields in logical source order.

fn into_rust_tuple(self) -> Self::Tuple

Moves each logical field into the corresponding native tuple field.

impl<A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static> IntoRustTuple for CStackList<A, CStackList<B, CStackList<C, CStackList<D, CStackList<E, CStackList<F, CStackList<G, CStackList<H, CStackList<I, CStackList<J, CNil<()>>>>>>>>>>>

type Tuple = (A, B, C, D, E, F, G, H, I, J)

The native tuple type with fields in logical source order.

fn into_rust_tuple(self) -> Self::Tuple

Moves each logical field into the corresponding native tuple field.

impl<A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static> IntoRustTuple for CStackList<A, CStackList<B, CStackList<C, CStackList<D, CStackList<E, CStackList<F, CStackList<G, CStackList<H, CStackList<I, CStackList<J, CStackList<K, CNil<()>>>>>>>>>>>>

type Tuple = (A, B, C, D, E, F, G, H, I, J, K)

The native tuple type with fields in logical source order.

fn into_rust_tuple(self) -> Self::Tuple

Moves each logical field into the corresponding native tuple field.

impl<A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static> IntoRustTuple for CStackList<A, CStackList<B, CStackList<C, CStackList<D, CStackList<E, CStackList<F, CStackList<G, CStackList<H, CStackList<I, CStackList<J, CStackList<K, CStackList<L, CNil<()>>>>>>>>>>>>>

type Tuple = (A, B, C, D, E, F, G, H, I, J, K, L)

The native tuple type with fields in logical source order.

fn into_rust_tuple(self) -> Self::Tuple

Moves each logical field into the corresponding native tuple field.

impl<H: 'static, T: List + CStackListHeadLimit> List for CStackList<H, T>

type Empty = CNil<()>

The type returned by List::empty().

type Head = H

The type of head.

type Tail = T

The type of the rest of the list.

type Push<U: 'static> = CStackList<U, CStackList<H, T>>

The type of the list after pushing a new value.

type Append<U: List> = <<T as List>::Append<U> as List>::Push<H>

The style of List appended to Self

type ReverseOnto<U: List> = <T as List>::ReverseOnto<<U as List>::Push<H>>

The resulting list when reversing Self onto U.

fn empty() -> Self::Empty

Returns a new empty list that can be used to create a list with the same characteristics.

fn head(&self) -> &Self::Head

Returns a reference to the head.

fn tail(&self) -> &Self::Tail

Returns a reference to the rest of the list.

fn push<U: 'static>(self, item: U) -> Self::Push<U>

Pushes a new value onto the front of the list, returning a new list.

fn append<U: List>(self, other: U) -> Self::Append<U>

Append U as the tail of Self.

fn reverse_onto<U: List>(self, other: U) -> Self::ReverseOnto<U>

Reverse Self and append the result to other.

fn is_empty(&self) -> bool

Returns true if the list is empty.

const LENGTH: usize = _

The length of the list, computed at compile time.

fn len(&self) -> usize

Returns the length of the list.

fn reverse(self) -> Self::ReverseOnto<Self::Empty>

where Self: Sized,

Reverse this list, returning a new list with elements in opposite order.

impl<H: 'static, T, U: Unsigned, B: Bit> ListIndex<RangeFrom<UInt<U, B>>> for CStackList<H, T>

where T: ListIndex<RangeFrom<Sub1<UInt<U, B>>>> + List + CStackListHeadLimit, UInt<U, B>: Sub<B1>,

type Output = <T as ListIndex<RangeFrom<<UInt<U, B> as Sub<B1>>::Output>>>::Output

The output reference type when indexing with Idx.

fn index(&self, index: RangeFrom<UInt<U, B>>) -> &Self::Output

Return a reference to the element or sublist selected by index.

impl<H: 'static, T: List + CStackListHeadLimit> ListIndex<RangeFrom<UTerm>> for CStackList<H, T>

type Output = CStackList<H, T>

The output reference type when indexing with Idx.

fn index(&self, _index: RangeFrom<U0>) -> &Self::Output

Return a reference to the element or sublist selected by index.

impl<H: 'static, T, U: Unsigned, B: Bit> ListIndex<RangeTo<UInt<U, B>>> for CStackList<H, T>

where T: ListIndex<RangeTo<Sub1<UInt<U, B>>>> + List + CStackListHeadLimit, <T as ListIndex<RangeTo<Sub1<UInt<U, B>>>>>::Output: List, UInt<U, B>: Sub<B1>,

type Output = <<T as ListIndex<RangeTo<<UInt<U, B> as Sub<B1>>::Output>>>::Output as List>::Push<H>

The output reference type when indexing with Idx.

fn index(&self, _index: RangeTo<UInt<U, B>>) -> &Self::Output

Return a reference to the element or sublist selected by index.

impl<H: 'static, T: List + CStackListHeadLimit> ListIndex<RangeTo<UTerm>> for CStackList<H, T>

type Output = CNil<CStackList<H, T>>

The output reference type when indexing with Idx.

fn index(&self, _index: RangeTo<U0>) -> &Self::Output

Return a reference to the element or sublist selected by index.

impl<H: 'static, T, U: Unsigned, B: Bit> ListIndex<RangeToInclusive<UInt<U, B>>> for CStackList<H, T>

where T: ListIndex<RangeToInclusive<Sub1<UInt<U, B>>>> + List + CStackListHeadLimit, <T as ListIndex<RangeToInclusive<Sub1<UInt<U, B>>>>>::Output: List, UInt<U, B>: Sub<B1>,

type Output = <<T as ListIndex<RangeToInclusive<<UInt<U, B> as Sub<B1>>::Output>>>::Output as List>::Push<H>

The output reference type when indexing with Idx.

fn index(&self, _index: RangeToInclusive<UInt<U, B>>) -> &Self::Output

Return a reference to the element or sublist selected by index.

impl<H: 'static, T: List + CStackListHeadLimit> ListIndex<RangeToInclusive<UTerm>> for CStackList<H, T>

type Output = CStackList<H, CNil<T>>

The output reference type when indexing with Idx.

fn index(&self, _index: RangeToInclusive<U0>) -> &Self::Output

Return a reference to the element or sublist selected by index.

impl<H: 'static, T, U: Unsigned, B: Bit> ListIndex<UInt<U, B>> for CStackList<H, T>

where T: ListIndex<Sub1<UInt<U, B>>> + List + CStackListHeadLimit, UInt<U, B>: Sub<B1>,

type Output = <T as ListIndex<<UInt<U, B> as Sub<B1>>::Output>>::Output

The output reference type when indexing with Idx.

fn index(&self, index: UInt<U, B>) -> &Self::Output

Return a reference to the element or sublist selected by index.

impl<H: 'static, T: List + CStackListHeadLimit> ListIndex<UTerm> for CStackList<H, T>

type Output = H

The output reference type when indexing with Idx.

fn index(&self, _index: U0) -> &Self::Output

Return a reference to the element or sublist selected by index.

impl<P: ListTypeProperty, H: 'static, T: ListTypeIteratorAdvance<P> + CStackListHeadLimit> ListTypeIteratorAdvance<P> for CStackList<H, T>

fn advancer<R: List>(iter: &mut ListTypeIterator<R, P>) -> Option<P::Output>

Advance the iterator, returning the next property value.

impl<H, T, O: List> PartialEq<O> for CStackList<H, T>

where H: PartialEq<O::Head> + 'static, T: PartialEq<O::Tail> + List + CStackListHeadLimit,

fn eq(&self, other: &O) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<H: 'static, T: List + CStackListHeadLimit> StackResult for CStackList<H, T>

unsafe fn take_result(stack: &mut RawStack) -> H

Transfers the concrete head out of its owned stack slot.

impl<H: 'static, T: ToTypeIdList + 'static + CStackListHeadLimit> ToTypeIdList for CStackList<H, T>

fn to_stack_info_list() -> Vec<StackInfo>

Enumerates tail storage followed by the opaque head.

• Complexity: O(n) slots for n list elements.