Struct Stack

Source

pub struct Stack<T, const CAP: usize, IDX, S: Storage = Bare> { /* private fields */ }

Expand description

A static stack backed by an Array.

It is generic in respect to its elements (T), capacity (CAP), index size (IDX) and storage (S).

The index size will upper-bound the capacity to the maximum for that type, e.g. u8::MAX for StackU8.

The index size determines the maximum possible number of elements in the stack, thereby upper-bounding the capacity to the maximum value representable by the index type. For example, u8::MAX for StackU8.

The total size in bytes of the stack may be influenced by the chosen index size, depending on the size and alignment of the elements. This difference could only be significant for small capacities, as only one index is stored.

See also the related aliases that specify IDX: StackU8, StackU16, StackU32, StackUsize, and the DataStack trait.

§Methods

All the stack operations are done from the back.

The methods are the same for all IDX sizes:

The following list of methods links to the ones implemented for StackU8:

Construct: new, new_copied, from_array(copy).
Deconstruct: to_array, to_vec(alloc). as_slice, as_mut_slice,
Query: len, is_empty, is_full, capacity, remaining_capacity, contains.
Resize: resize_default(own), resize_default_truncate (own).
Convert: to_idx_u8(own), to_idx_u16(own), to_idx_u32(own), to_idx_usize(own).
Iterate: iter, extend,
Stack operations without bounds on T:
- clear: clear.
- push: push.
- pop: pop (unsafe).
- peek: peek(mut), peek_nth(mut),
- drop: drop, drop_n, drop_replace_default.
- nip: nip, nip2.
- swap: swap, swap2,
- rot: rot, rot_cc, rot2, rot2_cc.
Stack operations depending on T: Clone.
- pop: pop (safe).
- dup: dup, dup2.
- over: over, over2.
- tuck: tuck, tuck2.
Stack chainable const operations depending on T: Copy.
- clear: own_clear.
- push: own_push(uc),
- pop: own_pop(uc).
- drop: own_drop(uc), own_drop_n(uc).
- nip: own_nip(uc), own_nip2(uc).
- swap: own_swap(uc), own_swap2(uc).
- rot: own_rot(uc), own_rot_cc(uc), own_rot2(uc), own_rot2_cc(uc).
- dup: own_dup(uc), own_dup2(uc).
- over: own_over(uc), own_over2(uc).
- tuck: own_tuck(uc), own_tuck2(uc).

Implementations§

Source §

impl<T: Default, const CAP: usize> Stack<T, CAP, u8, Bare>

§Stack resize.

Source

pub fn resize_default<const NEW_CAP: usize>( self, ) -> Result<Stack<T, NEW_CAP, u8, Bare>, IndexOutOfBounds> ⓘ

Available on crate feature _stack_u8 only.

Converts the current stack to a different capacity while preserving all existing elements.

This method creates a new stack with the specified new capacity and moves the current elements into it. The operation ensures that the new stack can accommodate the number of elements currently held in the stack. It is designed to work with both increases and decreases in capacity, as long as the new capacity can fit the current number of elements.

§Errors

Returns [IndexOutOfBounds(Some(NEW_CAP))] if NEW_CAP < self.len(), if CAP > u8::MAX or if CAP > isize::MAX / size_of::<T>().

§Examples

let s = StackU8::<_, 8>::from([1, 2, 3, 4]);
let less_cap: StackU8::<_, 4> = s.resize_default().unwrap();
assert_eq![s.as_slice(), less_cap.as_slice()];
let more_cap: StackU8::<_, 12> = s.resize_default().unwrap();
assert_eq![s.as_slice(), more_cap.as_slice()];
assert![s.resize_default::<2>().is_err()]; // too small

Source

pub fn resize_default_truncate<const NEW_CAP: usize>( self, ) -> Stack<T, NEW_CAP, u8, Bare>

Available on crate feature _stack_u8 only.

Converts the current stack to a different capacity, dropping elements if needed.

This method creates a new stack with the specified new capacity and moves the current elements into it. The operation will drop any elements that can’t fit in the new capacity, starting with the first ones (from the front of the stack).

§Examples

let s = StackU8::<_, 8>::from([1, 2, 3, 4]);
let less_cap: StackU8::<_, 4> = s.resize_default_truncate();
assert_eq![less_cap.as_slice(), s.as_slice()];
let more_cap: StackU8::<_, 12> = s.resize_default_truncate();
assert_eq![more_cap.as_slice(), s.as_slice()];
let drop_cap: StackU8::<_, 2> = s.resize_default_truncate();
assert_eq![drop_cap.as_slice(), &[3, 4]];

Source §

impl<T: Default, const CAP: usize> Stack<T, CAP, u8, Boxed>

Source

pub fn resize_default<const NEW_CAP: usize>( self, ) -> Result<Stack<T, NEW_CAP, u8, Boxed>, IndexOutOfBounds> ⓘ

Available on crate features alloc and _stack_u8 only.

Converts the current stack to a different capacity while preserving all existing elements.

This method creates a new stack with the specified new capacity and moves the current elements into it. The operation ensures that the new stack can accommodate the number of elements currently held in the stack. It is designed to work with both increases and decreases in capacity, as long as the new capacity can fit the current number of elements.

§Errors

Returns [IndexOutOfBounds(Some(NEW_CAP))] if NEW_CAP < self.len(), if CAP > u8::MAX or if CAP > isize::MAX / size_of::<T>().

§Examples

let s = StackU8::<_, 8, Boxed>::from([1, 2, 3, 4]);
let less_cap: StackU8::<_, 4, Boxed> = s.clone().resize_default().unwrap();
assert_eq![s.as_slice(), less_cap.as_slice()];
let more_cap: StackU8::<_, 12, Boxed> = s.clone().resize_default().unwrap();
assert_eq![s.as_slice(), more_cap.as_slice()];
assert![s.resize_default::<2>().is_err()]; // too small

Source

pub fn resize_default_truncate<const NEW_CAP: usize>( self, ) -> Stack<T, NEW_CAP, u8, Boxed>

Available on crate features alloc and _stack_u8 only.

Converts the current stack to a different capacity while preserving all existing elements.

This method creates a new stack with the specified new capacity and moves the current elements into it. The operation will drop any elements that can’t fit in the new capacity, starting with the first ones (from the front of the stack).

§Examples

let s = StackU8::<_, 8, Boxed>::from([1, 2, 3, 4]);
let less_cap: StackU8::<_, 4, Boxed> = s.clone().resize_default_truncate();
assert_eq![less_cap.as_slice(), s.as_slice()];
let more_cap: StackU8::<_, 12, Boxed> = s.clone().resize_default_truncate();
assert_eq![more_cap.as_slice(), s.as_slice()];
let drop_cap: StackU8::<_, 2, Boxed> = s.resize_default_truncate();
assert_eq![drop_cap.as_slice(), &[3, 4]];

Source §

impl<T: ConstDefault + Copy, const CAP: usize> Stack<T, CAP, u8, Bare>

Source

pub const fn own_resize_default<const NEW_CAP: usize>( self, ) -> Own<Result<Stack<T, NEW_CAP, u8, Bare>, IndexOutOfBounds>, ()>

Available on crate feature _stack_u8 only.

Converts the current stack to a different capacity while preserving all existing elements.

This method creates a new stack with the specified new capacity and moves the current elements into it. The operation ensures that the new stack can accommodate the number of elements currently held in the stack. It is designed to work with both increases and decreases in capacity, as long as the new capacity can fit the current number of elements.

§Errors

Returns [IndexOutOfBounds(Some(NEW_CAP))] if NEW_CAP < self.len(), if CAP > u8::MAX or if CAP > isize::MAX / size_of::<T>().

§Examples

const S: StackU8<i32, 8> = StackU8::own_new(0)
    .s_const_unwrap().s.own_push(1).s.own_push(2).s.own_push(3).s;
const T: StackU8<i32, 4> = S.own_resize_default().s_const_unwrap().s;
assert_eq![S.as_slice(), T.as_slice()];
let _ = S.own_resize_default::<2>().s_assert_err(); // too small

Source

pub const fn own_resize_default_truncate<const NEW_CAP: usize>( self, ) -> Own<Stack<T, NEW_CAP, u8, Bare>, ()>

Available on crate feature _stack_u8 only.

Converts the current stack to a different capacity, dropping elements if needed.

This method creates a new stack with the specified new capacity and moves the current elements into it. The operation will drop any elements that can’t fit in the new capacity, starting with the first ones (from the front of the stack).

§Examples

const S: StackU8<i32, 8> = StackU8::own_new(0)
    .s_const_unwrap().s.own_push(1).s.own_push(2).s.own_push(3).s;
const T: StackU8<i32, 4> = S.own_resize_default_truncate().s;
assert_eq![S.as_slice(), T.as_slice()];
const U: StackU8<i32, 2> = S.own_resize_default_truncate().s;
assert_eq![U.as_slice(), &[2, 3]];

Returns NotEnoughSpace if CAP > usize::MAX.

§Examples

let s = StackU8::<_, 6>::from([1, 2, 3, 4]);
let t: StackUsize::<_, 6> = s.to_idx_usize().unwrap();
assert_eq![s.as_slice(), t.as_slice()];

Source §

let s = StackU8::<_, 6, Boxed>::from([1, 2, 3]);
let t: StackUsize::<_, 6, Boxed> = s.to_idx_usize().unwrap();
assert_eq![t.as_slice(), &[1, 2, 3]];

Source §

const S: StackU8<i32, 6> = StackU8::own_new(0)
    .s_const_unwrap().s.own_push(1).s.own_push(2).s.own_push(3).s;
const T: StackUsize<i32, 6> = S.own_to_idx_usize().s_const_unwrap().s;
assert_eq![S.as_slice(), T.as_slice()];

Source §

impl<T: Default, const CAP: usize> Stack<T, CAP, u16, Bare>

§Stack resize.

Source

pub fn resize_default<const NEW_CAP: usize>( self, ) -> Result<Stack<T, NEW_CAP, u16, Bare>, IndexOutOfBounds> ⓘ

Available on crate feature _stack_u16 only.

Converts the current stack to a different capacity while preserving all existing elements.

This method creates a new stack with the specified new capacity and moves the current elements into it. The operation ensures that the new stack can accommodate the number of elements currently held in the stack. It is designed to work with both increases and decreases in capacity, as long as the new capacity can fit the current number of elements.

§Errors

Returns [IndexOutOfBounds(Some(NEW_CAP))] if NEW_CAP < self.len(), if CAP > u16::MAX or if CAP > isize::MAX / size_of::<T>().

§Examples

let s = StackU16::<_, 8>::from([1, 2, 3, 4]);
let less_cap: StackU16::<_, 4> = s.resize_default().unwrap();
assert_eq![s.as_slice(), less_cap.as_slice()];
let more_cap: StackU16::<_, 12> = s.resize_default().unwrap();
assert_eq![s.as_slice(), more_cap.as_slice()];
assert![s.resize_default::<2>().is_err()]; // too small

Source

pub fn resize_default_truncate<const NEW_CAP: usize>( self, ) -> Stack<T, NEW_CAP, u16, Bare>

Available on crate feature _stack_u16 only.

Converts the current stack to a different capacity, dropping elements if needed.

This method creates a new stack with the specified new capacity and moves the current elements into it. The operation will drop any elements that can’t fit in the new capacity, starting with the first ones (from the front of the stack).

§Examples

let s = StackU16::<_, 8>::from([1, 2, 3, 4]);
let less_cap: StackU16::<_, 4> = s.resize_default_truncate();
assert_eq![less_cap.as_slice(), s.as_slice()];
let more_cap: StackU16::<_, 12> = s.resize_default_truncate();
assert_eq![more_cap.as_slice(), s.as_slice()];
let drop_cap: StackU16::<_, 2> = s.resize_default_truncate();
assert_eq![drop_cap.as_slice(), &[3, 4]];

Source §

impl<T: Default, const CAP: usize> Stack<T, CAP, u16, Boxed>

Source

pub fn resize_default<const NEW_CAP: usize>( self, ) -> Result<Stack<T, NEW_CAP, u16, Boxed>, IndexOutOfBounds> ⓘ

Available on crate features alloc and _stack_u16 only.

Converts the current stack to a different capacity while preserving all existing elements.

This method creates a new stack with the specified new capacity and moves the current elements into it. The operation ensures that the new stack can accommodate the number of elements currently held in the stack. It is designed to work with both increases and decreases in capacity, as long as the new capacity can fit the current number of elements.

§Errors

Returns [IndexOutOfBounds(Some(NEW_CAP))] if NEW_CAP < self.len(), if CAP > u16::MAX or if CAP > isize::MAX / size_of::<T>().

§Examples

let s = StackU16::<_, 8, Boxed>::from([1, 2, 3, 4]);
let less_cap: StackU16::<_, 4, Boxed> = s.clone().resize_default().unwrap();
assert_eq![s.as_slice(), less_cap.as_slice()];
let more_cap: StackU16::<_, 12, Boxed> = s.clone().resize_default().unwrap();
assert_eq![s.as_slice(), more_cap.as_slice()];
assert![s.resize_default::<2>().is_err()]; // too small

Source

pub fn resize_default_truncate<const NEW_CAP: usize>( self, ) -> Stack<T, NEW_CAP, u16, Boxed>

Available on crate features alloc and _stack_u16 only.

Converts the current stack to a different capacity while preserving all existing elements.

This method creates a new stack with the specified new capacity and moves the current elements into it. The operation will drop any elements that can’t fit in the new capacity, starting with the first ones (from the front of the stack).

§Examples

let s = StackU16::<_, 8, Boxed>::from([1, 2, 3, 4]);
let less_cap: StackU16::<_, 4, Boxed> = s.clone().resize_default_truncate();
assert_eq![less_cap.as_slice(), s.as_slice()];
let more_cap: StackU16::<_, 12, Boxed> = s.clone().resize_default_truncate();
assert_eq![more_cap.as_slice(), s.as_slice()];
let drop_cap: StackU16::<_, 2, Boxed> = s.resize_default_truncate();
assert_eq![drop_cap.as_slice(), &[3, 4]];

Source §

impl<T: ConstDefault + Copy, const CAP: usize> Stack<T, CAP, u16, Bare>

Source

pub const fn own_resize_default<const NEW_CAP: usize>( self, ) -> Own<Result<Stack<T, NEW_CAP, u16, Bare>, IndexOutOfBounds>, ()>

Available on crate feature _stack_u16 only.

Converts the current stack to a different capacity while preserving all existing elements.

This method creates a new stack with the specified new capacity and moves the current elements into it. The operation ensures that the new stack can accommodate the number of elements currently held in the stack. It is designed to work with both increases and decreases in capacity, as long as the new capacity can fit the current number of elements.

§Errors

Returns [IndexOutOfBounds(Some(NEW_CAP))] if NEW_CAP < self.len(), if CAP > u16::MAX or if CAP > isize::MAX / size_of::<T>().

§Examples

const S: StackU16<i32, 8> = StackU16::own_new(0)
    .s_const_unwrap().s.own_push(1).s.own_push(2).s.own_push(3).s;
const T: StackU16<i32, 4> = S.own_resize_default().s_const_unwrap().s;
assert_eq![S.as_slice(), T.as_slice()];
let _ = S.own_resize_default::<2>().s_assert_err(); // too small

Source

pub const fn own_resize_default_truncate<const NEW_CAP: usize>( self, ) -> Own<Stack<T, NEW_CAP, u16, Bare>, ()>

Available on crate feature _stack_u16 only.

Converts the current stack to a different capacity, dropping elements if needed.

This method creates a new stack with the specified new capacity and moves the current elements into it. The operation will drop any elements that can’t fit in the new capacity, starting with the first ones (from the front of the stack).

§Examples

const S: StackU16<i32, 8> = StackU16::own_new(0)
    .s_const_unwrap().s.own_push(1).s.own_push(2).s.own_push(3).s;
const T: StackU16<i32, 4> = S.own_resize_default_truncate().s;
assert_eq![S.as_slice(), T.as_slice()];
const U: StackU16<i32, 2> = S.own_resize_default_truncate().s;
assert_eq![U.as_slice(), &[2, 3]];

Returns NotEnoughSpace if CAP > usize::MAX.

§Examples

let s = StackU16::<_, 6>::from([1, 2, 3, 4]);
let t: StackUsize::<_, 6> = s.to_idx_usize().unwrap();
assert_eq![s.as_slice(), t.as_slice()];

Source §

let s = StackU16::<_, 6, Boxed>::from([1, 2, 3]);
let t: StackUsize::<_, 6, Boxed> = s.to_idx_usize().unwrap();
assert_eq![t.as_slice(), &[1, 2, 3]];

Source §

const S: StackU16<i32, 6> = StackU16::own_new(0)
    .s_const_unwrap().s.own_push(1).s.own_push(2).s.own_push(3).s;
const T: StackUsize<i32, 6> = S.own_to_idx_usize().s_const_unwrap().s;
assert_eq![S.as_slice(), T.as_slice()];

Source §

impl<T: Default, const CAP: usize> Stack<T, CAP, u32, Bare>

§Stack resize.

Source

pub fn resize_default<const NEW_CAP: usize>( self, ) -> Result<Stack<T, NEW_CAP, u32, Bare>, IndexOutOfBounds> ⓘ

Available on crate feature _stack_u32 only.

Converts the current stack to a different capacity while preserving all existing elements.

This method creates a new stack with the specified new capacity and moves the current elements into it. The operation ensures that the new stack can accommodate the number of elements currently held in the stack. It is designed to work with both increases and decreases in capacity, as long as the new capacity can fit the current number of elements.

§Errors

Returns [IndexOutOfBounds(Some(NEW_CAP))] if NEW_CAP < self.len(), if CAP > u32::MAX or if CAP > isize::MAX / size_of::<T>().

§Examples

let s = StackU32::<_, 8>::from([1, 2, 3, 4]);
let less_cap: StackU32::<_, 4> = s.resize_default().unwrap();
assert_eq![s.as_slice(), less_cap.as_slice()];
let more_cap: StackU32::<_, 12> = s.resize_default().unwrap();
assert_eq![s.as_slice(), more_cap.as_slice()];
assert![s.resize_default::<2>().is_err()]; // too small

Source

pub fn resize_default_truncate<const NEW_CAP: usize>( self, ) -> Stack<T, NEW_CAP, u32, Bare>

Available on crate feature _stack_u32 only.

Converts the current stack to a different capacity, dropping elements if needed.

This method creates a new stack with the specified new capacity and moves the current elements into it. The operation will drop any elements that can’t fit in the new capacity, starting with the first ones (from the front of the stack).

§Examples

let s = StackU32::<_, 8>::from([1, 2, 3, 4]);
let less_cap: StackU32::<_, 4> = s.resize_default_truncate();
assert_eq![less_cap.as_slice(), s.as_slice()];
let more_cap: StackU32::<_, 12> = s.resize_default_truncate();
assert_eq![more_cap.as_slice(), s.as_slice()];
let drop_cap: StackU32::<_, 2> = s.resize_default_truncate();
assert_eq![drop_cap.as_slice(), &[3, 4]];

Source §

impl<T: Default, const CAP: usize> Stack<T, CAP, u32, Boxed>

Source

pub fn resize_default<const NEW_CAP: usize>( self, ) -> Result<Stack<T, NEW_CAP, u32, Boxed>, IndexOutOfBounds> ⓘ

Available on crate features alloc and _stack_u32 only.

Converts the current stack to a different capacity while preserving all existing elements.

This method creates a new stack with the specified new capacity and moves the current elements into it. The operation ensures that the new stack can accommodate the number of elements currently held in the stack. It is designed to work with both increases and decreases in capacity, as long as the new capacity can fit the current number of elements.

§Errors

Returns [IndexOutOfBounds(Some(NEW_CAP))] if NEW_CAP < self.len(), if CAP > u32::MAX or if CAP > isize::MAX / size_of::<T>().

§Examples

let s = StackU32::<_, 8, Boxed>::from([1, 2, 3, 4]);
let less_cap: StackU32::<_, 4, Boxed> = s.clone().resize_default().unwrap();
assert_eq![s.as_slice(), less_cap.as_slice()];
let more_cap: StackU32::<_, 12, Boxed> = s.clone().resize_default().unwrap();
assert_eq![s.as_slice(), more_cap.as_slice()];
assert![s.resize_default::<2>().is_err()]; // too small

Source

pub fn resize_default_truncate<const NEW_CAP: usize>( self, ) -> Stack<T, NEW_CAP, u32, Boxed>

Available on crate features alloc and _stack_u32 only.

Converts the current stack to a different capacity while preserving all existing elements.

This method creates a new stack with the specified new capacity and moves the current elements into it. The operation will drop any elements that can’t fit in the new capacity, starting with the first ones (from the front of the stack).

§Examples

let s = StackU32::<_, 8, Boxed>::from([1, 2, 3, 4]);
let less_cap: StackU32::<_, 4, Boxed> = s.clone().resize_default_truncate();
assert_eq![less_cap.as_slice(), s.as_slice()];
let more_cap: StackU32::<_, 12, Boxed> = s.clone().resize_default_truncate();
assert_eq![more_cap.as_slice(), s.as_slice()];
let drop_cap: StackU32::<_, 2, Boxed> = s.resize_default_truncate();
assert_eq![drop_cap.as_slice(), &[3, 4]];

Source §

impl<T: ConstDefault + Copy, const CAP: usize> Stack<T, CAP, u32, Bare>

Source

pub const fn own_resize_default<const NEW_CAP: usize>( self, ) -> Own<Result<Stack<T, NEW_CAP, u32, Bare>, IndexOutOfBounds>, ()>

Available on crate feature _stack_u32 only.

Converts the current stack to a different capacity while preserving all existing elements.

This method creates a new stack with the specified new capacity and moves the current elements into it. The operation ensures that the new stack can accommodate the number of elements currently held in the stack. It is designed to work with both increases and decreases in capacity, as long as the new capacity can fit the current number of elements.

§Errors

Returns [IndexOutOfBounds(Some(NEW_CAP))] if NEW_CAP < self.len(), if CAP > u32::MAX or if CAP > isize::MAX / size_of::<T>().

§Examples

const S: StackU32<i32, 8> = StackU32::own_new(0)
    .s_const_unwrap().s.own_push(1).s.own_push(2).s.own_push(3).s;
const T: StackU32<i32, 4> = S.own_resize_default().s_const_unwrap().s;
assert_eq![S.as_slice(), T.as_slice()];
let _ = S.own_resize_default::<2>().s_assert_err(); // too small

Source

pub const fn own_resize_default_truncate<const NEW_CAP: usize>( self, ) -> Own<Stack<T, NEW_CAP, u32, Bare>, ()>

Available on crate feature _stack_u32 only.

Converts the current stack to a different capacity, dropping elements if needed.

This method creates a new stack with the specified new capacity and moves the current elements into it. The operation will drop any elements that can’t fit in the new capacity, starting with the first ones (from the front of the stack).

§Examples

const S: StackU32<i32, 8> = StackU32::own_new(0)
    .s_const_unwrap().s.own_push(1).s.own_push(2).s.own_push(3).s;
const T: StackU32<i32, 4> = S.own_resize_default_truncate().s;
assert_eq![S.as_slice(), T.as_slice()];
const U: StackU32<i32, 2> = S.own_resize_default_truncate().s;
assert_eq![U.as_slice(), &[2, 3]];

Returns NotEnoughSpace if CAP > usize::MAX.

§Examples

let s = StackU32::<_, 6>::from([1, 2, 3, 4]);
let t: StackUsize::<_, 6> = s.to_idx_usize().unwrap();
assert_eq![s.as_slice(), t.as_slice()];

Source §

let s = StackU32::<_, 6, Boxed>::from([1, 2, 3]);
let t: StackUsize::<_, 6, Boxed> = s.to_idx_usize().unwrap();
assert_eq![t.as_slice(), &[1, 2, 3]];

Source §

const S: StackU32<i32, 6> = StackU32::own_new(0)
    .s_const_unwrap().s.own_push(1).s.own_push(2).s.own_push(3).s;
const T: StackUsize<i32, 6> = S.own_to_idx_usize().s_const_unwrap().s;
assert_eq![S.as_slice(), T.as_slice()];

Source §

impl<T: Default, const CAP: usize> Stack<T, CAP, usize, Bare>

§Stack resize.

Source

pub fn resize_default<const NEW_CAP: usize>( self, ) -> Result<Stack<T, NEW_CAP, usize, Bare>, IndexOutOfBounds> ⓘ

Available on crate feature _stack_usize only.

Converts the current stack to a different capacity while preserving all existing elements.

This method creates a new stack with the specified new capacity and moves the current elements into it. The operation ensures that the new stack can accommodate the number of elements currently held in the stack. It is designed to work with both increases and decreases in capacity, as long as the new capacity can fit the current number of elements.

§Errors

Returns [IndexOutOfBounds(Some(NEW_CAP))] if NEW_CAP < self.len(), if CAP > usize::MAX or if CAP > isize::MAX / size_of::<T>().

§Examples

let s = StackUsize::<_, 8>::from([1, 2, 3, 4]);
let less_cap: StackUsize::<_, 4> = s.resize_default().unwrap();
assert_eq![s.as_slice(), less_cap.as_slice()];
let more_cap: StackUsize::<_, 12> = s.resize_default().unwrap();
assert_eq![s.as_slice(), more_cap.as_slice()];
assert![s.resize_default::<2>().is_err()]; // too small

Source

pub fn resize_default_truncate<const NEW_CAP: usize>( self, ) -> Stack<T, NEW_CAP, usize, Bare>

Available on crate feature _stack_usize only.

Converts the current stack to a different capacity, dropping elements if needed.

This method creates a new stack with the specified new capacity and moves the current elements into it. The operation will drop any elements that can’t fit in the new capacity, starting with the first ones (from the front of the stack).

§Examples

let s = StackUsize::<_, 8>::from([1, 2, 3, 4]);
let less_cap: StackUsize::<_, 4> = s.resize_default_truncate();
assert_eq![less_cap.as_slice(), s.as_slice()];
let more_cap: StackUsize::<_, 12> = s.resize_default_truncate();
assert_eq![more_cap.as_slice(), s.as_slice()];
let drop_cap: StackUsize::<_, 2> = s.resize_default_truncate();
assert_eq![drop_cap.as_slice(), &[3, 4]];

Source §

impl<T: Default, const CAP: usize> Stack<T, CAP, usize, Boxed>

Source

pub fn resize_default<const NEW_CAP: usize>( self, ) -> Result<Stack<T, NEW_CAP, usize, Boxed>, IndexOutOfBounds> ⓘ

Available on crate features alloc and _stack_usize only.

Converts the current stack to a different capacity while preserving all existing elements.

This method creates a new stack with the specified new capacity and moves the current elements into it. The operation ensures that the new stack can accommodate the number of elements currently held in the stack. It is designed to work with both increases and decreases in capacity, as long as the new capacity can fit the current number of elements.

§Errors

Returns [IndexOutOfBounds(Some(NEW_CAP))] if NEW_CAP < self.len(), if CAP > usize::MAX or if CAP > isize::MAX / size_of::<T>().

§Examples

let s = StackUsize::<_, 8, Boxed>::from([1, 2, 3, 4]);
let less_cap: StackUsize::<_, 4, Boxed> = s.clone().resize_default().unwrap();
assert_eq![s.as_slice(), less_cap.as_slice()];
let more_cap: StackUsize::<_, 12, Boxed> = s.clone().resize_default().unwrap();
assert_eq![s.as_slice(), more_cap.as_slice()];
assert![s.resize_default::<2>().is_err()]; // too small

Source

pub fn resize_default_truncate<const NEW_CAP: usize>( self, ) -> Stack<T, NEW_CAP, usize, Boxed>

Available on crate features alloc and _stack_usize only.

Converts the current stack to a different capacity while preserving all existing elements.

This method creates a new stack with the specified new capacity and moves the current elements into it. The operation will drop any elements that can’t fit in the new capacity, starting with the first ones (from the front of the stack).

§Examples

let s = StackUsize::<_, 8, Boxed>::from([1, 2, 3, 4]);
let less_cap: StackUsize::<_, 4, Boxed> = s.clone().resize_default_truncate();
assert_eq![less_cap.as_slice(), s.as_slice()];
let more_cap: StackUsize::<_, 12, Boxed> = s.clone().resize_default_truncate();
assert_eq![more_cap.as_slice(), s.as_slice()];
let drop_cap: StackUsize::<_, 2, Boxed> = s.resize_default_truncate();
assert_eq![drop_cap.as_slice(), &[3, 4]];

Source §

impl<T: ConstDefault + Copy, const CAP: usize> Stack<T, CAP, usize, Bare>

Source

pub const fn own_resize_default<const NEW_CAP: usize>( self, ) -> Own<Result<Stack<T, NEW_CAP, usize, Bare>, IndexOutOfBounds>, ()>

Available on crate feature _stack_usize only.

Converts the current stack to a different capacity while preserving all existing elements.

This method creates a new stack with the specified new capacity and moves the current elements into it. The operation ensures that the new stack can accommodate the number of elements currently held in the stack. It is designed to work with both increases and decreases in capacity, as long as the new capacity can fit the current number of elements.

§Errors

Returns [IndexOutOfBounds(Some(NEW_CAP))] if NEW_CAP < self.len(), if CAP > usize::MAX or if CAP > isize::MAX / size_of::<T>().

§Examples

const S: StackUsize<i32, 8> = StackUsize::own_new(0)
    .s_const_unwrap().s.own_push(1).s.own_push(2).s.own_push(3).s;
const T: StackUsize<i32, 4> = S.own_resize_default().s_const_unwrap().s;
assert_eq![S.as_slice(), T.as_slice()];
let _ = S.own_resize_default::<2>().s_assert_err(); // too small

Source

pub const fn own_resize_default_truncate<const NEW_CAP: usize>( self, ) -> Own<Stack<T, NEW_CAP, usize, Bare>, ()>

Available on crate feature _stack_usize only.

Converts the current stack to a different capacity, dropping elements if needed.

This method creates a new stack with the specified new capacity and moves the current elements into it. The operation will drop any elements that can’t fit in the new capacity, starting with the first ones (from the front of the stack).

§Examples

const S: StackUsize<i32, 8> = StackUsize::own_new(0)
    .s_const_unwrap().s.own_push(1).s.own_push(2).s.own_push(3).s;
const T: StackUsize<i32, 4> = S.own_resize_default_truncate().s;
assert_eq![S.as_slice(), T.as_slice()];
const U: StackUsize<i32, 2> = S.own_resize_default_truncate().s;
assert_eq![U.as_slice(), &[2, 3]];

Returns NotEnoughSpace if CAP > usize::MAX.

§Examples

let s = StackUsize::<_, 6>::from([1, 2, 3, 4]);
let t: StackUsize::<_, 6> = s.to_idx_usize().unwrap();
assert_eq![s.as_slice(), t.as_slice()];

Source §

let s = StackUsize::<_, 6, Boxed>::from([1, 2, 3]);
let t: StackUsize::<_, 6, Boxed> = s.to_idx_usize().unwrap();
assert_eq![t.as_slice(), &[1, 2, 3]];

Source §

const S: StackUsize<i32, 6> = StackUsize::own_new(0)
    .s_const_unwrap().s.own_push(1).s.own_push(2).s.own_push(3).s;
const T: StackUsize<i32, 6> = S.own_to_idx_usize().s_const_unwrap().s;
assert_eq![S.as_slice(), T.as_slice()];

Source §

impl<T: Clone, const CAP: usize> Stack<T, CAP, u8, Bare>

§Methods for `StackU8`

This impl block contains no items.

Source §

impl<T: Clone, const CAP: usize> Stack<T, CAP, u8, Bare>

Source

pub fn new(element: T) -> Result<Self, MismatchedCapacity> ⓘ

Returns an empty stack, allocated in the stack, cloning element to fill the remaining free data.

§Errors

Returns MismatchedCapacity if CAP > u8::MAX or if CAP > isize::MAX / size_of::<T>().

§Examples

let s = StackU8::<_, 16>::new(0).unwrap();

Source §

impl<T: Copy, const CAP: usize> Stack<T, CAP, u8, Bare>

Source

pub const fn new_copied(element: T) -> Result<Self, MismatchedCapacity> ⓘ

Returns an empty stack, allocated in the stack, copying element to fill the remaining free data, in compile-time.

§Errors

Returns MismatchedCapacity if CAP > u8::MAX or if CAP > isize::MAX / size_of::<T>().

§Examples

const S: StackU8<i32, 16> = unwrap![ok StackU8::new_copied(0)];

Source §

impl<T: Clone, const CAP: usize> Stack<T, CAP, u8, Boxed>

Source

pub fn new(element: T) -> Self

Available on crate feature alloc only.

Returns an empty stack, allocated in the heap, cloning element to fill the remaining free data.

§Examples

let s = StackU8::<_, 100, Boxed>::new(0);

Source §

impl<T, const CAP: usize> Stack<T, CAP, u8, Bare>

Source

pub const fn from_array_copy(arr: [T; CAP]) -> Stack<T, CAP, u8, Bare>

Converts an array into a full stack.

§Examples

const S: StackU8<i32, 3> = StackU8::from_array_copy([1, 2, 3]);

Source §

impl<T, const CAP: usize, S: Storage> Stack<T, CAP, u8, S>

Source

pub fn from_array(arr: [T; CAP]) -> Stack<T, CAP, u8, S>

Converts an array into a full stack.

§Examples

let s = StackU8::<_, 3>::from_array([1, 2, 3]);

Clears the stack.

( 1 2 3 -- )

§Examples

let mut s = StackU8::<_, 8>::from([1, 2, 3, 4]);
s.clear();
assert![s.is_empty()];

Source

pub fn push(&mut self, element: T) -> Result<(), NotEnoughSpace> ⓘ

Pushes a new element to the top of the stack.

( 1 -- 1 2 )

§Errors

Returns NotEnoughSpace if the stack is full.

§Examples

let mut s = StackU8::<_, 2>::default();
s.push(1)?;
s.push(2)?;
assert![s.push(3).is_err()];
assert_eq![s.as_slice(), &[1, 2]];

Source

pub fn pop(&mut self) -> Result<T, NotEnoughElements> ⓘ

Available on crate feature unsafe_ptr or Clone only.

Pops the top stack element.

( 1 2 -- 1 )

§Errors

Returns NotEnoughElements if the stack is empty.

§Examples

let mut s = StackU8::<_, 2>::from([1, 2]);
assert_eq![2, s.pop()?];
assert_eq![1, s.pop()?];
assert![s.is_empty()];

§Examples

let mut s = StackU8::<_, 5>::from([1, 2, 3, 4, 5]);
assert_eq![s.peek_nth_mut(0), Ok(&mut 5)];
assert_eq![s.peek_nth_mut(4), Ok(&mut 1)];

Source

pub fn drop(&mut self) -> Result<(), NotEnoughElements> ⓘ

Drops the top stack element.

( 1 2 -- 1 )

§Errors

Returns NotEnoughElements if the stack is empty.

§Examples

let mut s = StackU8::<_, 2>::from([1, 2]);
s.drop();
assert_eq![s.as_slice(), &[1]];

Source

pub fn drop_n(&mut self, n: u8) -> Result<(), NotEnoughElements> ⓘ

Drops the top n stack elements.

( 1 2 3 4 -- 1 ) for n == 3

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least n elements.

§Examples

let mut s = StackU8::<_, 4>::from([1, 2, 3, 4]);
s.drop_n(3);
assert_eq![s.as_slice(), &[1]];

Source

pub fn nip(&mut self) -> Result<(), NotEnoughElements> ⓘ

Drops the next of stack element.

( 1 2 -- 2 )

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least 2 elements.

§Examples

let mut s = StackU8::<_, 2>::from([1, 2]);
s.nip();
assert_eq![s.as_slice(), &[2]];

Source

pub fn nip2(&mut self) -> Result<(), NotEnoughElements> ⓘ

Drops the pair of next stack elements.

( 1 2 3 4 -- 3 4 )

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least 4 elements.

§Examples

let mut s = StackU8::<_, 8>::from([1, 2, 3, 4]);
s.nip2();
assert_eq![s.as_slice(), &[3, 4]];

Source

pub fn swap(&mut self) -> Result<(), NotEnoughElements> ⓘ

Swaps the top two stack elements.

( 1 2 -- 2 1 )

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least 2 elements.

§Examples

let mut s = StackU8::<_, 2>::from([1, 2]);
s.swap();
assert_eq![s.as_slice(), &[2, 1]];

Source

pub fn swap2(&mut self) -> Result<(), NotEnoughElements> ⓘ

Swaps the top two pair stack elements.

( 1 2 3 4 -- 3 4 1 2 )

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least 4 elements.

§Examples

let mut s = StackU8::<_, 4>::from([1, 2, 3, 4]);
s.swap2();
assert_eq![s.as_slice(), &[3, 4, 1, 2]];

Source

pub fn rot(&mut self) -> Result<(), NotEnoughElements> ⓘ

Rotates the top three stack elements, clockwise.

( 1 2 3 -- 2 3 1 )

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least 3 elements.

§Examples

let mut s = StackU8::<_, 3>::from(['a', 'b', 'c']);
s.rot()?;
assert_eq![s.as_slice(), &['b', 'c', 'a']];

Source

pub fn rot_cc(&mut self) -> Result<(), NotEnoughElements> ⓘ

Rotates the top three stack elements, counter-clockwise.

( 1 2 3 -- 3 1 2 )

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least 3 elements.

§Examples

let mut s = StackU8::<_, 3>::from(['a', 'b', 'c']);
s.rot_cc()?;
assert_eq![s.as_slice(), &['c', 'a', 'b']];

Source

pub fn rot2(&mut self) -> Result<(), NotEnoughElements> ⓘ

Rotates the top six stack elements, clockwise, two times.

( 1 2 3 4 5 6 -- 3 4 5 6 1 2 )

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least 6 elements.

§Examples

let mut s = StackU8::<_, 6>::from(['a', 'b', 'c', 'd', 'e', 'f']);
s.rot2()?;
assert_eq![s.as_slice(), &['c', 'd', 'e', 'f', 'a', 'b']];

Source

pub fn rot2_cc(&mut self) -> Result<(), NotEnoughElements> ⓘ

Rotates the top six stack elements, counter-clockwise, two times.

( 1 2 3 4 5 6 -- 5 6 1 2 3 4 )

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least 6 elements.

§Examples

let mut s = StackU8::<_, 6>::from(['a', 'b', 'c', 'd', 'e', 'f']);
s.rot2()?;
assert_eq![s.as_slice(), &['c', 'd', 'e', 'f', 'a', 'b']];

Source §

impl<T: Clone, const CAP: usize, S: Storage> Stack<T, CAP, u8, S>

§Examples

let mut s = StackU8::<_, 6>::from([1, 2, 3, 4]);
s.tuck2()?;
assert_eq![&[3, 4, 1, 2, 3, 4], s.as_slice()];

Source

pub fn to_vec(&self) -> Vec<T> ⓘ

Available on crate feature alloc only.

Returns the stacked elements as a vector.

§Examples

let mut s = StackU8::<_, 5>::from([1, 2]);
s.push(3)?;
s.push(4)?;
s.push(5)?;
assert_eq![s.to_vec(), vec![1, 2, 3, 4, 5]];

Source

pub fn to_array<const LEN: usize>(&self) -> Option<[T; LEN]> ⓘ

Returns some LEN stacked elements as an array, or None if the stack is empty, or there are not at least LEN elements.

This is a non alloc alternative method to to_vec.

§Panics

Panics if the new LEN sized array can’t be allocated.

§Examples

let mut s = StackU8::<_, 5>::from([1, 2]);
s.push(3)?;
s.push(4)?;
s.push(5)?;
assert_eq![s.to_array::<5>(), Some([1, 2, 3, 4, 5])];

§Features

Makes use of the unsafe_array feature if enabled.

Source

pub fn drop_replace_default(&mut self) -> Result<(), NotEnoughElements> ⓘ

Drops the top of stack element, replacing the underlying data with the default value.

( 1 2 -- 1 )

§Errors

Returns NotEnoughElements if the stack is empty.

§Examples

let mut s = StackU8::<_, 2>::from([1, 2]);
s.drop_replace_default();
assert_eq![s.as_slice(), &[1]];

Source §

impl<T: Clone, const CAP: usize> Stack<T, CAP, u16, Bare>

§Methods for `StackU16`

This impl block contains no items.

Source §

impl<T: Clone, const CAP: usize> Stack<T, CAP, u16, Bare>

Source

pub fn new(element: T) -> Result<Self, MismatchedCapacity> ⓘ

Returns an empty stack, allocated in the stack, cloning element to fill the remaining free data.

§Errors

Returns MismatchedCapacity if CAP > u16::MAX or if CAP > isize::MAX / size_of::<T>().

§Examples

let s = StackU16::<_, 16>::new(0).unwrap();

Source §

impl<T: Copy, const CAP: usize> Stack<T, CAP, u16, Bare>

Source

pub const fn new_copied(element: T) -> Result<Self, MismatchedCapacity> ⓘ

Returns an empty stack, allocated in the stack, copying element to fill the remaining free data, in compile-time.

§Errors

Returns MismatchedCapacity if CAP > u16::MAX or if CAP > isize::MAX / size_of::<T>().

§Examples

const S: StackU16<i32, 16> = unwrap![ok StackU16::new_copied(0)];

Source §

impl<T: Clone, const CAP: usize> Stack<T, CAP, u16, Boxed>

Source

pub fn new(element: T) -> Self

Available on crate feature alloc only.

Returns an empty stack, allocated in the heap, cloning element to fill the remaining free data.

§Examples

let s = StackU16::<_, 100, Boxed>::new(0);

Source §

impl<T, const CAP: usize> Stack<T, CAP, u16, Bare>

Source

pub const fn from_array_copy(arr: [T; CAP]) -> Stack<T, CAP, u16, Bare>

Converts an array into a full stack.

§Examples

const S: StackU16<i32, 3> = StackU16::from_array_copy([1, 2, 3]);

Source §

impl<T, const CAP: usize, S: Storage> Stack<T, CAP, u16, S>

Source

pub fn from_array(arr: [T; CAP]) -> Stack<T, CAP, u16, S>

Converts an array into a full stack.

§Examples

let s = StackU16::<_, 3>::from_array([1, 2, 3]);

Clears the stack.

( 1 2 3 -- )

§Examples

let mut s = StackU16::<_, 8>::from([1, 2, 3, 4]);
s.clear();
assert![s.is_empty()];

Source

pub fn push(&mut self, element: T) -> Result<(), NotEnoughSpace> ⓘ

Pushes a new element to the top of the stack.

( 1 -- 1 2 )

§Errors

Returns NotEnoughSpace if the stack is full.

§Examples

let mut s = StackU16::<_, 2>::default();
s.push(1)?;
s.push(2)?;
assert![s.push(3).is_err()];
assert_eq![s.as_slice(), &[1, 2]];

Source

pub fn pop(&mut self) -> Result<T, NotEnoughElements> ⓘ

Available on crate feature unsafe_ptr or Clone only.

Pops the top stack element.

( 1 2 -- 1 )

§Errors

Returns NotEnoughElements if the stack is empty.

§Examples

let mut s = StackU16::<_, 2>::from([1, 2]);
assert_eq![2, s.pop()?];
assert_eq![1, s.pop()?];
assert![s.is_empty()];

§Examples

let mut s = StackU16::<_, 5>::from([1, 2, 3, 4, 5]);
assert_eq![s.peek_nth_mut(0), Ok(&mut 5)];
assert_eq![s.peek_nth_mut(4), Ok(&mut 1)];

Source

pub fn drop(&mut self) -> Result<(), NotEnoughElements> ⓘ

Drops the top stack element.

( 1 2 -- 1 )

§Errors

Returns NotEnoughElements if the stack is empty.

§Examples

let mut s = StackU16::<_, 2>::from([1, 2]);
s.drop();
assert_eq![s.as_slice(), &[1]];

Source

pub fn drop_n(&mut self, n: u16) -> Result<(), NotEnoughElements> ⓘ

Drops the top n stack elements.

( 1 2 3 4 -- 1 ) for n == 3

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least n elements.

§Examples

let mut s = StackU16::<_, 4>::from([1, 2, 3, 4]);
s.drop_n(3);
assert_eq![s.as_slice(), &[1]];

Source

pub fn nip(&mut self) -> Result<(), NotEnoughElements> ⓘ

Drops the next of stack element.

( 1 2 -- 2 )

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least 2 elements.

§Examples

let mut s = StackU16::<_, 2>::from([1, 2]);
s.nip();
assert_eq![s.as_slice(), &[2]];

Source

pub fn nip2(&mut self) -> Result<(), NotEnoughElements> ⓘ

Drops the pair of next stack elements.

( 1 2 3 4 -- 3 4 )

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least 4 elements.

§Examples

let mut s = StackU16::<_, 8>::from([1, 2, 3, 4]);
s.nip2();
assert_eq![s.as_slice(), &[3, 4]];

Source

pub fn swap(&mut self) -> Result<(), NotEnoughElements> ⓘ

Swaps the top two stack elements.

( 1 2 -- 2 1 )

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least 2 elements.

§Examples

let mut s = StackU16::<_, 2>::from([1, 2]);
s.swap();
assert_eq![s.as_slice(), &[2, 1]];

Source

pub fn swap2(&mut self) -> Result<(), NotEnoughElements> ⓘ

Swaps the top two pair stack elements.

( 1 2 3 4 -- 3 4 1 2 )

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least 4 elements.

§Examples

let mut s = StackU16::<_, 4>::from([1, 2, 3, 4]);
s.swap2();
assert_eq![s.as_slice(), &[3, 4, 1, 2]];

Source

pub fn rot(&mut self) -> Result<(), NotEnoughElements> ⓘ

Rotates the top three stack elements, clockwise.

( 1 2 3 -- 2 3 1 )

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least 3 elements.

§Examples

let mut s = StackU16::<_, 3>::from(['a', 'b', 'c']);
s.rot()?;
assert_eq![s.as_slice(), &['b', 'c', 'a']];

Source

pub fn rot_cc(&mut self) -> Result<(), NotEnoughElements> ⓘ

Rotates the top three stack elements, counter-clockwise.

( 1 2 3 -- 3 1 2 )

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least 3 elements.

§Examples

let mut s = StackU16::<_, 3>::from(['a', 'b', 'c']);
s.rot_cc()?;
assert_eq![s.as_slice(), &['c', 'a', 'b']];

Source

pub fn rot2(&mut self) -> Result<(), NotEnoughElements> ⓘ

Rotates the top six stack elements, clockwise, two times.

( 1 2 3 4 5 6 -- 3 4 5 6 1 2 )

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least 6 elements.

§Examples

let mut s = StackU16::<_, 6>::from(['a', 'b', 'c', 'd', 'e', 'f']);
s.rot2()?;
assert_eq![s.as_slice(), &['c', 'd', 'e', 'f', 'a', 'b']];

Source

pub fn rot2_cc(&mut self) -> Result<(), NotEnoughElements> ⓘ

Rotates the top six stack elements, counter-clockwise, two times.

( 1 2 3 4 5 6 -- 5 6 1 2 3 4 )

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least 6 elements.

§Examples

let mut s = StackU16::<_, 6>::from(['a', 'b', 'c', 'd', 'e', 'f']);
s.rot2()?;
assert_eq![s.as_slice(), &['c', 'd', 'e', 'f', 'a', 'b']];

Source §

impl<T: Clone, const CAP: usize, S: Storage> Stack<T, CAP, u16, S>

§Examples

let mut s = StackU16::<_, 6>::from([1, 2, 3, 4]);
s.tuck2()?;
assert_eq![&[3, 4, 1, 2, 3, 4], s.as_slice()];

Source

pub fn to_vec(&self) -> Vec<T> ⓘ

Available on crate feature alloc only.

Returns the stacked elements as a vector.

§Examples

let mut s = StackU16::<_, 5>::from([1, 2]);
s.push(3)?;
s.push(4)?;
s.push(5)?;
assert_eq![s.to_vec(), vec![1, 2, 3, 4, 5]];

Source

pub fn to_array<const LEN: usize>(&self) -> Option<[T; LEN]> ⓘ

Returns some LEN stacked elements as an array, or None if the stack is empty, or there are not at least LEN elements.

This is a non alloc alternative method to to_vec.

§Panics

Panics if the new LEN sized array can’t be allocated.

§Examples

let mut s = StackU16::<_, 5>::from([1, 2]);
s.push(3)?;
s.push(4)?;
s.push(5)?;
assert_eq![s.to_array::<5>(), Some([1, 2, 3, 4, 5])];

§Features

Makes use of the unsafe_array feature if enabled.

Source

pub fn drop_replace_default(&mut self) -> Result<(), NotEnoughElements> ⓘ

Drops the top of stack element, replacing the underlying data with the default value.

( 1 2 -- 1 )

§Errors

Returns NotEnoughElements if the stack is empty.

§Examples

let mut s = StackU16::<_, 2>::from([1, 2]);
s.drop_replace_default();
assert_eq![s.as_slice(), &[1]];

Source §

impl<T: Clone, const CAP: usize> Stack<T, CAP, u32, Bare>

§Methods for `StackU32`

This impl block contains no items.

Source §

impl<T: Clone, const CAP: usize> Stack<T, CAP, u32, Bare>

Source

pub fn new(element: T) -> Result<Self, MismatchedCapacity> ⓘ

Returns an empty stack, allocated in the stack, cloning element to fill the remaining free data.

§Errors

Returns MismatchedCapacity if CAP > u32::MAX or if CAP > isize::MAX / size_of::<T>().

§Examples

let s = StackU32::<_, 16>::new(0).unwrap();

Source §

impl<T: Copy, const CAP: usize> Stack<T, CAP, u32, Bare>

Source

pub const fn new_copied(element: T) -> Result<Self, MismatchedCapacity> ⓘ

Returns an empty stack, allocated in the stack, copying element to fill the remaining free data, in compile-time.

§Errors

Returns MismatchedCapacity if CAP > u32::MAX or if CAP > isize::MAX / size_of::<T>().

§Examples

const S: StackU32<i32, 16> = unwrap![ok StackU32::new_copied(0)];

Source §

impl<T: Clone, const CAP: usize> Stack<T, CAP, u32, Boxed>

Source

pub fn new(element: T) -> Self

Available on crate feature alloc only.

Returns an empty stack, allocated in the heap, cloning element to fill the remaining free data.

§Examples

let s = StackU32::<_, 100, Boxed>::new(0);

Source §

impl<T, const CAP: usize> Stack<T, CAP, u32, Bare>

Source

pub const fn from_array_copy(arr: [T; CAP]) -> Stack<T, CAP, u32, Bare>

Converts an array into a full stack.

§Examples

const S: StackU32<i32, 3> = StackU32::from_array_copy([1, 2, 3]);

Source §

impl<T, const CAP: usize, S: Storage> Stack<T, CAP, u32, S>

Source

pub fn from_array(arr: [T; CAP]) -> Stack<T, CAP, u32, S>

Converts an array into a full stack.

§Examples

let s = StackU32::<_, 3>::from_array([1, 2, 3]);

Clears the stack.

( 1 2 3 -- )

§Examples

let mut s = StackU32::<_, 8>::from([1, 2, 3, 4]);
s.clear();
assert![s.is_empty()];

Source

pub fn push(&mut self, element: T) -> Result<(), NotEnoughSpace> ⓘ

Pushes a new element to the top of the stack.

( 1 -- 1 2 )

§Errors

Returns NotEnoughSpace if the stack is full.

§Examples

let mut s = StackU32::<_, 2>::default();
s.push(1)?;
s.push(2)?;
assert![s.push(3).is_err()];
assert_eq![s.as_slice(), &[1, 2]];

Source

pub fn pop(&mut self) -> Result<T, NotEnoughElements> ⓘ

Available on crate feature unsafe_ptr or Clone only.

Pops the top stack element.

( 1 2 -- 1 )

§Errors

Returns NotEnoughElements if the stack is empty.

§Examples

let mut s = StackU32::<_, 2>::from([1, 2]);
assert_eq![2, s.pop()?];
assert_eq![1, s.pop()?];
assert![s.is_empty()];

§Examples

let mut s = StackU32::<_, 5>::from([1, 2, 3, 4, 5]);
assert_eq![s.peek_nth_mut(0), Ok(&mut 5)];
assert_eq![s.peek_nth_mut(4), Ok(&mut 1)];

Source

pub fn drop(&mut self) -> Result<(), NotEnoughElements> ⓘ

Drops the top stack element.

( 1 2 -- 1 )

§Errors

Returns NotEnoughElements if the stack is empty.

§Examples

let mut s = StackU32::<_, 2>::from([1, 2]);
s.drop();
assert_eq![s.as_slice(), &[1]];

Source

pub fn drop_n(&mut self, n: u32) -> Result<(), NotEnoughElements> ⓘ

Drops the top n stack elements.

( 1 2 3 4 -- 1 ) for n == 3

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least n elements.

§Examples

let mut s = StackU32::<_, 4>::from([1, 2, 3, 4]);
s.drop_n(3);
assert_eq![s.as_slice(), &[1]];

Source

pub fn nip(&mut self) -> Result<(), NotEnoughElements> ⓘ

Drops the next of stack element.

( 1 2 -- 2 )

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least 2 elements.

§Examples

let mut s = StackU32::<_, 2>::from([1, 2]);
s.nip();
assert_eq![s.as_slice(), &[2]];

Source

pub fn nip2(&mut self) -> Result<(), NotEnoughElements> ⓘ

Drops the pair of next stack elements.

( 1 2 3 4 -- 3 4 )

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least 4 elements.

§Examples

let mut s = StackU32::<_, 8>::from([1, 2, 3, 4]);
s.nip2();
assert_eq![s.as_slice(), &[3, 4]];

Source

pub fn swap(&mut self) -> Result<(), NotEnoughElements> ⓘ

Swaps the top two stack elements.

( 1 2 -- 2 1 )

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least 2 elements.

§Examples

let mut s = StackU32::<_, 2>::from([1, 2]);
s.swap();
assert_eq![s.as_slice(), &[2, 1]];

Source

pub fn swap2(&mut self) -> Result<(), NotEnoughElements> ⓘ

Swaps the top two pair stack elements.

( 1 2 3 4 -- 3 4 1 2 )

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least 4 elements.

§Examples

let mut s = StackU32::<_, 4>::from([1, 2, 3, 4]);
s.swap2();
assert_eq![s.as_slice(), &[3, 4, 1, 2]];

Source

pub fn rot(&mut self) -> Result<(), NotEnoughElements> ⓘ

Rotates the top three stack elements, clockwise.

( 1 2 3 -- 2 3 1 )

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least 3 elements.

§Examples

let mut s = StackU32::<_, 3>::from(['a', 'b', 'c']);
s.rot()?;
assert_eq![s.as_slice(), &['b', 'c', 'a']];

Source

pub fn rot_cc(&mut self) -> Result<(), NotEnoughElements> ⓘ

Rotates the top three stack elements, counter-clockwise.

( 1 2 3 -- 3 1 2 )

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least 3 elements.

§Examples

let mut s = StackU32::<_, 3>::from(['a', 'b', 'c']);
s.rot_cc()?;
assert_eq![s.as_slice(), &['c', 'a', 'b']];

Source

pub fn rot2(&mut self) -> Result<(), NotEnoughElements> ⓘ

Rotates the top six stack elements, clockwise, two times.

( 1 2 3 4 5 6 -- 3 4 5 6 1 2 )

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least 6 elements.

§Examples

let mut s = StackU32::<_, 6>::from(['a', 'b', 'c', 'd', 'e', 'f']);
s.rot2()?;
assert_eq![s.as_slice(), &['c', 'd', 'e', 'f', 'a', 'b']];

Source

pub fn rot2_cc(&mut self) -> Result<(), NotEnoughElements> ⓘ

Rotates the top six stack elements, counter-clockwise, two times.

( 1 2 3 4 5 6 -- 5 6 1 2 3 4 )

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least 6 elements.

§Examples

let mut s = StackU32::<_, 6>::from(['a', 'b', 'c', 'd', 'e', 'f']);
s.rot2()?;
assert_eq![s.as_slice(), &['c', 'd', 'e', 'f', 'a', 'b']];

Source §

impl<T: Clone, const CAP: usize, S: Storage> Stack<T, CAP, u32, S>

§Examples

let mut s = StackU32::<_, 6>::from([1, 2, 3, 4]);
s.tuck2()?;
assert_eq![&[3, 4, 1, 2, 3, 4], s.as_slice()];

Source

pub fn to_vec(&self) -> Vec<T> ⓘ

Available on crate feature alloc only.

Returns the stacked elements as a vector.

§Examples

let mut s = StackU32::<_, 5>::from([1, 2]);
s.push(3)?;
s.push(4)?;
s.push(5)?;
assert_eq![s.to_vec(), vec![1, 2, 3, 4, 5]];

Source

pub fn to_array<const LEN: usize>(&self) -> Option<[T; LEN]> ⓘ

Returns some LEN stacked elements as an array, or None if the stack is empty, or there are not at least LEN elements.

This is a non alloc alternative method to to_vec.

§Panics

Panics if the new LEN sized array can’t be allocated.

§Examples

let mut s = StackU32::<_, 5>::from([1, 2]);
s.push(3)?;
s.push(4)?;
s.push(5)?;
assert_eq![s.to_array::<5>(), Some([1, 2, 3, 4, 5])];

§Features

Makes use of the unsafe_array feature if enabled.

Source

pub fn drop_replace_default(&mut self) -> Result<(), NotEnoughElements> ⓘ

Drops the top of stack element, replacing the underlying data with the default value.

( 1 2 -- 1 )

§Errors

Returns NotEnoughElements if the stack is empty.

§Examples

let mut s = StackU32::<_, 2>::from([1, 2]);
s.drop_replace_default();
assert_eq![s.as_slice(), &[1]];

Source §

impl<T: Clone, const CAP: usize> Stack<T, CAP, usize, Bare>

§Methods for `StackUsize`

This impl block contains no items.

Source §

impl<T: Clone, const CAP: usize> Stack<T, CAP, usize, Bare>

Source

pub fn new(element: T) -> Result<Self, MismatchedCapacity> ⓘ

Returns an empty stack, allocated in the stack, cloning element to fill the remaining free data.

§Errors

Returns MismatchedCapacity if CAP > usize::MAX or if CAP > isize::MAX / size_of::<T>().

§Examples

let s = StackUsize::<_, 16>::new(0).unwrap();

Source §

impl<T: Copy, const CAP: usize> Stack<T, CAP, usize, Bare>

Source

pub const fn new_copied(element: T) -> Result<Self, MismatchedCapacity> ⓘ

Returns an empty stack, allocated in the stack, copying element to fill the remaining free data, in compile-time.

§Errors

Returns MismatchedCapacity if CAP > usize::MAX or if CAP > isize::MAX / size_of::<T>().

§Examples

const S: StackUsize<i32, 16> = unwrap![ok StackUsize::new_copied(0)];

Source §

impl<T: Clone, const CAP: usize> Stack<T, CAP, usize, Boxed>

Source

pub fn new(element: T) -> Self

Available on crate feature alloc only.

Returns an empty stack, allocated in the heap, cloning element to fill the remaining free data.

§Examples

let s = StackUsize::<_, 100, Boxed>::new(0);

Source §

impl<T, const CAP: usize> Stack<T, CAP, usize, Bare>

Source

pub const fn from_array_copy(arr: [T; CAP]) -> Stack<T, CAP, usize, Bare>

Converts an array into a full stack.

§Examples

const S: StackUsize<i32, 3> = StackUsize::from_array_copy([1, 2, 3]);

Source §

impl<T, const CAP: usize, S: Storage> Stack<T, CAP, usize, S>

Source

pub fn from_array(arr: [T; CAP]) -> Stack<T, CAP, usize, S>

Converts an array into a full stack.

§Examples

let s = StackUsize::<_, 3>::from_array([1, 2, 3]);

Clears the stack.

( 1 2 3 -- )

§Examples

let mut s = StackUsize::<_, 8>::from([1, 2, 3, 4]);
s.clear();
assert![s.is_empty()];

Source

pub fn push(&mut self, element: T) -> Result<(), NotEnoughSpace> ⓘ

Pushes a new element to the top of the stack.

( 1 -- 1 2 )

§Errors

Returns NotEnoughSpace if the stack is full.

§Examples

let mut s = StackUsize::<_, 2>::default();
s.push(1)?;
s.push(2)?;
assert![s.push(3).is_err()];
assert_eq![s.as_slice(), &[1, 2]];

Source

pub fn pop(&mut self) -> Result<T, NotEnoughElements> ⓘ

Available on crate feature unsafe_ptr or Clone only.

Pops the top stack element.

( 1 2 -- 1 )

§Errors

Returns NotEnoughElements if the stack is empty.

§Examples

let mut s = StackUsize::<_, 2>::from([1, 2]);
assert_eq![2, s.pop()?];
assert_eq![1, s.pop()?];
assert![s.is_empty()];

§Examples

let mut s = StackUsize::<_, 5>::from([1, 2, 3, 4, 5]);
assert_eq![s.peek_nth_mut(0), Ok(&mut 5)];
assert_eq![s.peek_nth_mut(4), Ok(&mut 1)];

Source

pub fn drop(&mut self) -> Result<(), NotEnoughElements> ⓘ

Drops the top stack element.

( 1 2 -- 1 )

§Errors

Returns NotEnoughElements if the stack is empty.

§Examples

let mut s = StackUsize::<_, 2>::from([1, 2]);
s.drop();
assert_eq![s.as_slice(), &[1]];

Source

pub fn drop_n(&mut self, n: usize) -> Result<(), NotEnoughElements> ⓘ

Drops the top n stack elements.

( 1 2 3 4 -- 1 ) for n == 3

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least n elements.

§Examples

let mut s = StackUsize::<_, 4>::from([1, 2, 3, 4]);
s.drop_n(3);
assert_eq![s.as_slice(), &[1]];

Source

pub fn nip(&mut self) -> Result<(), NotEnoughElements> ⓘ

Drops the next of stack element.

( 1 2 -- 2 )

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least 2 elements.

§Examples

let mut s = StackUsize::<_, 2>::from([1, 2]);
s.nip();
assert_eq![s.as_slice(), &[2]];

Source

pub fn nip2(&mut self) -> Result<(), NotEnoughElements> ⓘ

Drops the pair of next stack elements.

( 1 2 3 4 -- 3 4 )

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least 4 elements.

§Examples

let mut s = StackUsize::<_, 8>::from([1, 2, 3, 4]);
s.nip2();
assert_eq![s.as_slice(), &[3, 4]];

Source

pub fn swap(&mut self) -> Result<(), NotEnoughElements> ⓘ

Swaps the top two stack elements.

( 1 2 -- 2 1 )

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least 2 elements.

§Examples

let mut s = StackUsize::<_, 2>::from([1, 2]);
s.swap();
assert_eq![s.as_slice(), &[2, 1]];

Source

pub fn swap2(&mut self) -> Result<(), NotEnoughElements> ⓘ

Swaps the top two pair stack elements.

( 1 2 3 4 -- 3 4 1 2 )

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least 4 elements.

§Examples

let mut s = StackUsize::<_, 4>::from([1, 2, 3, 4]);
s.swap2();
assert_eq![s.as_slice(), &[3, 4, 1, 2]];

Source

pub fn rot(&mut self) -> Result<(), NotEnoughElements> ⓘ

Rotates the top three stack elements, clockwise.

( 1 2 3 -- 2 3 1 )

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least 3 elements.

§Examples

let mut s = StackUsize::<_, 3>::from(['a', 'b', 'c']);
s.rot()?;
assert_eq![s.as_slice(), &['b', 'c', 'a']];

Source

pub fn rot_cc(&mut self) -> Result<(), NotEnoughElements> ⓘ

Rotates the top three stack elements, counter-clockwise.

( 1 2 3 -- 3 1 2 )

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least 3 elements.

§Examples

let mut s = StackUsize::<_, 3>::from(['a', 'b', 'c']);
s.rot_cc()?;
assert_eq![s.as_slice(), &['c', 'a', 'b']];

Source

pub fn rot2(&mut self) -> Result<(), NotEnoughElements> ⓘ

Rotates the top six stack elements, clockwise, two times.

( 1 2 3 4 5 6 -- 3 4 5 6 1 2 )

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least 6 elements.

§Examples

let mut s = StackUsize::<_, 6>::from(['a', 'b', 'c', 'd', 'e', 'f']);
s.rot2()?;
assert_eq![s.as_slice(), &['c', 'd', 'e', 'f', 'a', 'b']];

Source

pub fn rot2_cc(&mut self) -> Result<(), NotEnoughElements> ⓘ

Rotates the top six stack elements, counter-clockwise, two times.

( 1 2 3 4 5 6 -- 5 6 1 2 3 4 )

§Errors

Returns NotEnoughElements if the stack doesn’t contain at least 6 elements.

§Examples

let mut s = StackUsize::<_, 6>::from(['a', 'b', 'c', 'd', 'e', 'f']);
s.rot2()?;
assert_eq![s.as_slice(), &['c', 'd', 'e', 'f', 'a', 'b']];

Source §

impl<T: Clone, const CAP: usize, S: Storage> Stack<T, CAP, usize, S>

§Examples

let mut s = StackUsize::<_, 6>::from([1, 2, 3, 4]);
s.tuck2()?;
assert_eq![&[3, 4, 1, 2, 3, 4], s.as_slice()];

Source

pub fn to_vec(&self) -> Vec<T> ⓘ

Available on crate feature alloc only.

Returns the stacked elements as a vector.

§Examples

let mut s = StackUsize::<_, 5>::from([1, 2]);
s.push(3)?;
s.push(4)?;
s.push(5)?;
assert_eq![s.to_vec(), vec![1, 2, 3, 4, 5]];

Source

pub fn to_array<const LEN: usize>(&self) -> Option<[T; LEN]> ⓘ

Returns some LEN stacked elements as an array, or None if the stack is empty, or there are not at least LEN elements.

This is a non alloc alternative method to to_vec.

§Panics

Panics if the new LEN sized array can’t be allocated.

§Examples

let mut s = StackUsize::<_, 5>::from([1, 2]);
s.push(3)?;
s.push(4)?;
s.push(5)?;
assert_eq![s.to_array::<5>(), Some([1, 2, 3, 4, 5])];

§Features

Makes use of the unsafe_array feature if enabled.

Source

pub fn drop_replace_default(&mut self) -> Result<(), NotEnoughElements> ⓘ

Drops the top of stack element, replacing the underlying data with the default value.

( 1 2 -- 1 )

§Errors

Returns NotEnoughElements if the stack is empty.

§Examples

let mut s = StackUsize::<_, 2>::from([1, 2]);
s.drop_replace_default();
assert_eq![s.as_slice(), &[1]];

Source §

impl<T: Copy, const CAP: usize> Stack<T, CAP, u8, Bare>

§Chainable const

operations depending on T: Copy

Every method is const and returns Own<Self, V>.

Source

pub const fn own_new(element: T) -> Own<Result<Self, MismatchedCapacity>, ()>

Returns an empty stack, allocated in the stack, copying element to fill the remaining free data.

§Errors

Returns MismatchedCapacity if CAP > u8::MAX or if CAP > isize::MAX / size_of::<T>().

§Examples

const S: StackU8<i32, 16> = StackU8::own_new(0).s_const_unwrap().s;

Source

pub const fn own_clear(self) -> Own<Self, ()>

Clears the stack in compile-time.

( 1 2 3 -- )

§Examples

const S: StackU8<i32, 3> = StackU8::from_array_copy([1, 2, 3]).own_clear().s;
assert![S.is_empty()];

Source

pub const fn own_push(self, element: T) -> Own<Self, Result<(), NotEnoughSpace>>

Pushes a new element to the top of the stack in compile-time.

( 1 -- 1 2 )

§Errors

Returns Own<S,NotEnoughSpace> if the stack is full.

§Examples

const S: StackU8<i32, 2> = StackU8::own_new(0).s_const_unwrap().s
    .own_push(1).v_assert_ok().s
    .own_push(2).v_assert_ok().s;
assert_eq![S.as_slice(), &[1, 2]];
assert![S.own_push(3).v.is_err_and(|e| matches![e, NotEnoughSpace])];

Source

pub const fn own_push_unchecked(self, element: T) -> Own<Self, ()>

Pushes a new element to the top of the stack in compile-time, unchecked version.

( 1 -- 1 2 )

§Panics

Panics if the stack is full.

§Examples

const S: StackU8<i32, 2> = StackU8::own_new(0).s_const_unwrap().s
    .own_push_unchecked(1).s.own_push_unchecked(2).s;
assert_eq![S.as_slice(), &[1, 2]];

Source

pub const fn own_pop(self) -> Own<Self, Result<T, NotEnoughElements>>

Pops the top stack element in compile-time.

( 1 2 3 -- 1 2 )

§Errors

Returns Own<S,NotEnoughElements> if the stack is empty.

§Examples

const S: Own<StackU8<i32, 3>, Result<i32, NotEnoughElements>> =
   StackU8::from_array_copy([1, 2, 3]).own_pop();
S.s_assert(|s| s.as_slice() == &[1, 2]).v_assert_eq(&Ok(3));

Source

pub const fn own_pop_unchecked(self) -> Own<Self, T>

Pops the top stack element in compile-time, unchecked version.

( 1 2 3 -- 1 2 )

§Panics

Panics if the stack is empty.

§Examples

const S: Own<StackU8<i32, 3>, i32> =
   StackU8::from_array_copy([1, 2, 3]).own_pop_unchecked();
S.s_assert(|s| s.as_slice() == &[1, 2]).v_assert_eq(&3);

Source

pub const fn own_peek(self) -> Own<Self, Result<T, NotEnoughElements>>

Peeks the top stack element in compile-time.

( 1 2 3 -- 1 2 )

§Errors

Returns Own<S,NotEnoughElements> if the stack is empty.

§Examples

const S: Own<StackU8<i32, 3>, Result<i32, NotEnoughElements>> =
  StackU8::from_array_copy([1, 2, 3]).own_peek();
S.s_assert(|s| s.as_slice() == &[1, 2, 3]).v_assert_eq(&Ok(3));

Source

pub const fn own_peek_unchecked(self) -> Own<Self, T>

Peeks the top stack element in compile-time, unchecked version.

( 1 2 3 -- 1 2 )

§Panics

Panics if the stack is empty.

§Examples

const S: Own<StackU8<i32, 3>, i32> = StackU8::from_array_copy([1, 2, 3])
    .own_peek_unchecked();
S.s_assert(|s| s.as_slice() == &[1, 2, 3]).v_assert_eq(&3);

Source

pub const fn own_drop(self) -> Own<Self, Result<(), NotEnoughElements>>

Drops the top stack element in compile-time.

( 1 2 -- 1 )

§Errors

Returns Own<self,NotEnoughElements> if the stack is empty.

§Examples

const S: StackU8<i32, 2> = StackU8::from_array_copy([1, 2])
    .own_drop().v_assert_ok().s;
assert_eq![S.as_slice(), &[1]];

const T: StackU8<i32, 2> = StackU8::own_new(0).s_const_unwrap().s
    .own_drop().v_assert_err().s;
assert![T.is_empty()];

Source

pub const fn own_drop_unchecked(self) -> Own<Self, ()>

Swaps the top two pair stack elements, unchecked version.

( 1 2 -- 1 )

§Panics

Panics if the stack is empty.

§Examples

const S: StackU8<i32, 2> = StackU8::from_array_copy([1, 2])
    .own_drop_unchecked().s;
assert_eq![S.as_slice(), &[1]];

Source

pub const fn own_drop_n(self, n: u8) -> Own<Self, Result<(), NotEnoughElements>>

Drops the top n stack elements.

( 1 2 3 4 -- 1 ) for n == 3

§Errors

Returns Own<self,NotEnoughElements> if the stack doesn’t contain at least n elements.

§Examples

const S: StackU8<i32, 4> = StackU8::from_array_copy([1, 2, 3, 4])
    .own_drop_n(3).v_assert_ok().s;
assert_eq![S.as_slice(), &[1]];

Source

pub const fn own_drop_n_unchecked(self, n: u8) -> Own<Self, ()>

Drops the top n stack elements, unchecked version.

( 1 2 3 4 -- 1 ) for n == 3

§Panics

Panics if the stack doesn’t contain at least n elements.

§Examples

const S: StackU8<i32, 4> = StackU8::from_array_copy([1, 2, 3, 4])
    .own_drop_n_unchecked(3).s;
assert_eq![S.as_slice(), &[1]];

Source

pub const fn own_nip(self) -> Own<Self, Result<(), NotEnoughElements>>

Drops the next of stack element in compile-time.

( 1 2 -- 2 )

§Errors

Returns Own<self,NotEnoughElements> if the stack doesn’t contain at least 2 elements.

§Examples

const S: StackU8<i32, 2> = StackU8::from_array_copy([1, 2])
    .own_nip().v_assert_ok().s;
assert_eq![S.as_slice(), &[2]];

const T: StackU8<i32, 2> = StackU8::own_new(0).s_const_unwrap().s
    .own_push(1).v_assert_ok().s.own_nip().v_assert_err().s;
assert_eq![T.as_slice(), &[1]];

Source

pub const fn own_nip_unchecked(self) -> Own<Self, ()>

Drops the next of stack element in compile-time, unchecked version.

( 1 2 -- 2 )

§Panics

Panics if the stack doesn’t contain at least 2 elements.

§Examples

const S: StackU8<i32, 2> = StackU8::from_array_copy([1, 2])
    .own_nip_unchecked().s;
assert_eq![S.as_slice(), &[2]];

Source

pub const fn own_nip2(self) -> Own<Self, Result<(), NotEnoughElements>>

Drops the pair of next stack elements.

( 1 2 3 4 -- 3 4 )

§Errors

Returns Own<self,NotEnoughElements> if the stack doesn’t contain at least 4 elements.

§Examples

const S: StackU8<i32, 4> = StackU8::from_array_copy([1, 2, 3, 4])
    .own_nip2().v_assert_ok().s;
assert_eq![S.as_slice(), &[3, 4]];

Source

pub const fn own_nip2_unchecked(self) -> Own<Self, ()>

Drops the pair of next stack elements, unchecked version.

( 1 2 3 4 -- 3 4 )

§Panics

Panics if the stack doesn’t contain at least 4 elements.

§Examples

const S: StackU8<i32, 4> = StackU8::from_array_copy([1, 2, 3, 4])
    .own_nip2_unchecked().s;
assert_eq![S.as_slice(), &[3, 4]];

Source

pub const fn own_swap(self) -> Own<Self, Result<(), NotEnoughElements>>

Swaps the top two stack elements in compile-time.

( 1 2 -- 2 1 )

§Errors

Returns Own<self,NotEnoughElements> if the stack doesn’t contain at least 2 elements.

§Examples

const S: StackU8<i32, 2> = StackU8::from_array_copy([1, 2])
    .own_swap().v_assert_ok().s;
assert_eq![S.as_slice(), &[2, 1]];

const T: StackU8<i32, 1> = StackU8::from_array_copy([1])
    .own_swap().v_assert_err().s;
assert_eq![T.as_slice(), &[1]];

Source

pub const fn own_swap_unchecked(self) -> Own<Self, ()>

Swaps the top two stack elements in compile-time, unchecked version.

( 1 2 -- 2 1 )

§Panics

Panics if the stack doesn’t contain at least 2 elements.

§Examples

const S: StackU8<i32, 2> = StackU8::from_array_copy([1, 2])
    .own_swap_unchecked().s;
assert_eq![S.as_slice(), &[2, 1]];

Source

pub const fn own_swap2(self) -> Own<Self, Result<(), NotEnoughElements>>

Swaps the top two pair stack elements in compile-time.

( 1 2 3 4 -- 3 4 1 2 )

§Errors

Returns Own<self,NotEnoughElements> if the stack doesn’t contain at least 4 elements.

§Examples

const S: StackU8<i32, 4> = StackU8::from_array_copy([1, 2, 3, 4])
    .own_swap2().v_assert_ok().s;
assert_eq![S.as_slice(), &[3, 4, 1, 2]];

const T: StackU8<i32, 3> = StackU8::from_array_copy([1, 2, 3])
    .own_swap2().v_assert_err().s;
assert_eq![T.as_slice(), &[1, 2, 3]];

Source

pub const fn own_swap2_unchecked(self) -> Own<Self, ()>

Swaps the top two pair stack elements in compile-time, unchecked version.

( 1 2 3 4 -- 3 4 1 2 )

§Panics

Panics if the stack doesn’t contain at least 4 elements.

§Examples

const S: StackU8<i32, 4> = StackU8::from_array_copy([1, 2, 3, 4])
    .own_swap2_unchecked().s;
assert_eq![S.as_slice(), &[3, 4, 1, 2]];

Source

pub const fn own_rot(self) -> Own<Self, Result<(), NotEnoughElements>>

Rotates the top three stack elements, clockwise.

( 1 2 3 -- 2 3 1 )

§Errors

Returns Own<self,NotEnoughElements> if the stack doesn’t contain at least 3 elements.

§Examples

const S: StackU8<i32, 4> = StackU8::from_array_copy([0, 1, 2, 3])
    .own_rot().v_assert_ok().s;
assert_eq![S.as_slice(), &[0, 2, 3, 1]];

Source

pub const fn own_rot_unchecked(self) -> Own<Self, ()>

Rotates the top three stack elements, clockwise, unchecked version.

( 1 2 3 -- 2 3 1 )

§Panics

Panics if the stack doesn’t contain at least 6 elements. if the stack doesn’t contain at least 3 elements.

§Examples

const S: StackU8<i32, 4> = StackU8::from_array_copy([0, 1, 2, 3])
    .own_rot_unchecked().s;
assert_eq![S.as_slice(), &[0, 2, 3, 1]];

Source

pub const fn own_rot_cc(self) -> Own<Self, Result<(), NotEnoughElements>>

Rotates the top three stack elements, counter-clockwise.

( 1 2 3 -- 3 1 2 )

§Errors

Returns Own<S,NotEnoughElements> if the stack doesn’t contain at least 3 elements.

§Examples

const S: StackU8<i32, 4> = StackU8::from_array_copy([0, 1, 2, 3])
    .own_rot_cc().v_assert_ok().s;
assert_eq![S.as_slice(), &[0, 3, 1, 2]];

Source

pub const fn own_rot_cc_unchecked(self) -> Own<Self, ()>

Rotates the top three stack elements, counter-clockwise, unchecked version.

( 1 2 3 -- 3 1 2 )

§Errors

Returns Own<S,NotEnoughElements> if the stack doesn’t contain at least 3 elements.

§Examples

const S: StackU8<i32, 4> = StackU8::from_array_copy([0, 1, 2, 3])
    .own_rot_cc_unchecked().s;
assert_eq![S.as_slice(), &[0, 3, 1, 2]];

Source

pub const fn own_rot2(self) -> Own<Self, Result<(), NotEnoughElements>>

Rotates the top six stack elements, clockwise, two times.

( 1 2 3 4 5 6 -- 3 4 5 6 1 2 )

§Errors

Returns Own<self,NotEnoughElements> if the stack doesn’t contain at least 6 elements.

§Examples

const S: StackU8<i32, 7> = StackU8::from_array_copy([0, 1, 2, 3, 4, 5, 6])
    .own_rot2().v_assert_ok().s;
assert_eq![S.as_slice(), &[0, 3, 4, 5, 6, 1, 2]];

Source

pub const fn own_rot2_unchecked(self) -> Own<Self, ()>

Rotates the top six stack elements, clockwise, two times, unchecked version.

( 1 2 3 4 5 6 -- 3 4 5 6 1 2 )

§Panics

Panics if the stack doesn’t contain at least 6 elements.

§Examples

const S: StackU8<i32, 7> = StackU8::from_array_copy([0, 1, 2, 3, 4, 5, 6])
    .own_rot2_unchecked().s;
assert_eq![S.as_slice(), &[0, 3, 4, 5, 6, 1, 2]];

Source

pub const fn own_rot2_cc(self) -> Own<Self, Result<(), NotEnoughElements>>

Rotates the top six stack elements, counter-clockwise, two times.

( 1 2 3 4 5 6 -- 5 6 1 2 3 4 )

§Errors

Returns Own<self,NotEnoughElements> if the stack doesn’t contain at least 6 elements.

§Examples

const S: StackU8<i32, 7> = StackU8::from_array_copy([0, 1, 2, 3, 4, 5, 6])
    .own_rot2_cc().v_assert_ok().s;
assert_eq![S.as_slice(), &[0, 5, 6, 1, 2, 3, 4]];

Source

pub const fn own_rot2_cc_unchecked(self) -> Own<Self, ()>

Rotates the top six stack elements, counter-clockwise, two times, unchecked version.

( 1 2 3 4 5 6 -- 5 6 1 2 3 4 )

§Panics

Panics if the stack doesn’t contain at least 6 elements.

§Examples

const S: StackU8<i32, 7> = StackU8::from_array_copy([0, 1, 2, 3, 4, 5, 6])
    .own_rot2_cc_unchecked().s;
assert_eq![S.as_slice(), &[0, 5, 6, 1, 2, 3, 4]];

Source

pub const fn own_dup(self) -> Own<Self, Result<(), DataNotEnough>>

Duplicates the top stack element.

( 1 -- 1 1 )

§Errors

Returns Own<self,DataNotEnough::Elements> if the stack is empty or Own<self,DataNotEnough::Space> if the stack is full.

§Examples

const S: StackU8<i32, 3> = StackU8::own_new(0).s_const_unwrap().s
    .own_push(1).s.own_dup().v_assert_ok().s;
assert_eq![S.as_slice(), &[1, 1]];

Source

pub const fn own_dup_unchecked(self) -> Own<Self, ()>

Duplicates the top stack element, unchecked version.

( 1 -- 1 1 )

§Panics

Panics if the stack is either empty or full.

§Examples

const S: StackU8<i32, 3> = StackU8::own_new(0).s_const_unwrap().s
    .own_push(1).s.own_dup_unchecked().s;
assert_eq![S.as_slice(), &[1, 1]];

Source

pub const fn own_dup2(self) -> Own<Self, Result<(), DataNotEnough>>

Duplicates the top stack pair of elements.

( 1 2 -- 1 2 1 2 )

§Errors

Returns Own<self,DataNotEnough::Elements> if the stack doesn’t have at least 2 elements, or Own<self,DataNotEnough::Space> if it doesn’t have enough space for 2 extra elements.

§Examples

const S: StackU8<i32, 6> = StackU8::from_array_copy([0, 1, 2, 0, 0, 0])
    .own_drop_n(3).s.own_dup2().v_assert_ok().s;
assert_eq![S.as_slice(), &[0, 1, 2, 1, 2]];

Source

pub const fn own_dup2_unchecked(self) -> Own<Self, ()>

Duplicates the top stack pair of elements, unchecked version.

( 1 2 -- 1 2 1 2 )

§Panics

Panics if the stack doesn’t have at least 2 elements, or if it doesn’t have enough space for 2 extra elements.

§Examples

const S: StackU8<i32, 6> = StackU8::from_array_copy([0, 1, 2, 0, 0, 0])
    .own_drop_n(3).s.own_dup2_unchecked().s;
assert_eq![S.as_slice(), &[0, 1, 2, 1, 2]];

Source

pub const fn own_over(self) -> Own<Self, Result<(), DataNotEnough>>

Duplicates the next of stack element to the top.

( 1 2 -- 1 2 1 )

§Errors

Returns Own<self,DataNotEnough::Elements> if the stack doesn’t have at least 2 elements, or Own<self,DataNotEnough::Space> if it doesn’t have enough space for 2 extra elements.

§Examples

const S: StackU8<i32, 4> = StackU8::from_array_copy([0, 1, 2, 0])
    .own_drop().s.own_over().v_assert_ok().s;
assert_eq![S.as_slice(), &[0, 1, 2, 1]];

Source

pub const fn own_over_unchecked(self) -> Own<Self, ()>

Duplicates the next of stack element to the top.

( 1 2 -- 1 2 1 )

§Panics

Panics if the stack doesn’t have at least 2 elements, or if it doesn’t have enough space for 2 extra elements.

§Examples

const S: StackU8<i32, 4> = StackU8::from_array_copy([0, 1, 2, 0])
    .own_drop().s.own_over_unchecked().s;
assert_eq![S.as_slice(), &[0, 1, 2, 1]];

Source

pub const fn own_over2(self) -> Own<Self, Result<(), DataNotEnough>>

Duplicates the next of stack pair of elements to the top.

( 1 2 3 4 -- 1 2 3 4 1 2 )

§Errors

Returns Own<self,DataNotEnough::Elements> if the stack doesn’t have at least 4 elements, or Own<self,DataNotEnough::Space> if it doesn’t have enough space for 2 extra elements.

§Examples

const S: StackU8<i32, 7> = StackU8::from_array_copy([0, 1, 2, 3, 4, 0, 0])
    .own_drop_n(2).s.own_over2().v_assert_ok().s;
assert_eq![S.as_slice(), &[0, 1, 2, 3, 4, 1, 2]];

Source

pub const fn own_over2_unchecked(self) -> Own<Self, ()>

Duplicates the next of stack pair of elements to the top.

( 1 2 3 4 -- 1 2 3 4 1 2 )

§Panics

Panics if the stack doesn’t have at least 4 elements, or if it doesn’t have enough space for 2 extra elements.

§Examples

const S: StackU8<i32, 7> = StackU8::from_array_copy([0, 1, 2, 3, 4, 0, 0])
    .own_drop_n(2).s.own_over2_unchecked().s;
assert_eq![S.as_slice(), &[0, 1, 2, 3, 4, 1, 2]];

Source

pub const fn own_tuck(self) -> Own<Self, Result<(), DataNotEnough>>

Duplicates the top element before the next of stack element.

( 1 2 -- 2 1 2 )

§Errors

Returns Own<self,DataNotEnough::Elements> if the stack doesn’t have at least 2 elements, or Own<self,DataNotEnough::Space> if it doesn’t have enough space for 1 extra elements.

§Examples

const S: StackU8<i32, 4> = StackU8::from_array_copy([0, 1, 2, 0])
    .own_drop().s.own_tuck().v_assert_ok().s;
assert_eq![S.as_slice(), &[0, 2, 1, 2]];

Source

pub const fn own_tuck_unchecked(self) -> Own<Self, ()>

Duplicates the top element before the next of stack element, unchecked version.

( 1 2 -- 2 1 2 )

§Panics

Panics if the stack doesn’t have at least 2 elements, or if it doesn’t have enough space for 1 extra elements.

§Examples

const S: StackU8<i32, 4> = StackU8::from_array_copy([0, 1, 2, 0])
    .own_drop().s.own_tuck_unchecked().s;
assert_eq![S.as_slice(), &[0, 2, 1, 2]];

Source

pub const fn own_tuck2(self) -> Own<Self, Result<(), DataNotEnough>>

Duplicates the top pair of elements before the next of stack pair of elements.

( 1 2 3 4 -- 3 4 1 2 3 4 )

§Errors

Returns Own<self,DataNotEnough::Elements> if the stack doesn’t have at least 4 elements, or Own<self,DataNotEnough::Space> if it doesn’t have enough space for 2 extra elements.

§Examples

const S: StackU8<i32, 7> = StackU8::from_array_copy([0, 1, 2, 3, 4, 0, 0])
    .own_drop_n(2).s.own_tuck2_unchecked().s;
assert_eq![S.as_slice(), &[0, 3, 4, 1, 2, 3, 4]];

Source

pub const fn own_tuck2_unchecked(self) -> Own<Self, ()>

Duplicates the top pair of elements before the next of stack pair of elements, unchecked version.

( 1 2 3 4 -- 3 4 1 2 3 4 )

§Panics

Panics if the stack doesn’t have at least 4 elements, or if it doesn’t have enough space for 2 extra elements.

§Examples

const S: StackU8<i32, 7> = StackU8::from_array_copy([0, 1, 2, 3, 4, 0, 0])
    .own_drop_n(2).s.own_tuck2_unchecked().s;
assert_eq![S.as_slice(), &[0, 3, 4, 1, 2, 3, 4]];

Source §

impl<T: Copy, const CAP: usize> Stack<T, CAP, u16, Bare>

§Chainable const

operations depending on T: Copy

Every method is const and returns Own<Self, V>.

Source

pub const fn own_new(element: T) -> Own<Result<Self, MismatchedCapacity>, ()>

Returns an empty stack, allocated in the stack, copying element to fill the remaining free data.

§Errors

Returns MismatchedCapacity if CAP > u16::MAX or if CAP > isize::MAX / size_of::<T>().

§Examples

const S: StackU16<i32, 16> = StackU16::own_new(0).s_const_unwrap().s;

Source

pub const fn own_clear(self) -> Own<Self, ()>

Clears the stack in compile-time.

( 1 2 3 -- )

§Examples

const S: StackU16<i32, 3> = StackU16::from_array_copy([1, 2, 3]).own_clear().s;
assert![S.is_empty()];

Source

pub const fn own_push(self, element: T) -> Own<Self, Result<(), NotEnoughSpace>>

Pushes a new element to the top of the stack in compile-time.

( 1 -- 1 2 )

§Errors

Returns Own<S,NotEnoughSpace> if the stack is full.

§Examples

const S: StackU16<i32, 2> = StackU16::own_new(0).s_const_unwrap().s
    .own_push(1).v_assert_ok().s
    .own_push(2).v_assert_ok().s;
assert_eq![S.as_slice(), &[1, 2]];
assert![S.own_push(3).v.is_err_and(|e| matches![e, NotEnoughSpace])];

Source

pub const fn own_push_unchecked(self, element: T) -> Own<Self, ()>

Pushes a new element to the top of the stack in compile-time, unchecked version.

( 1 -- 1 2 )

§Panics

Panics if the stack is full.

§Examples

const S: StackU16<i32, 2> = StackU16::own_new(0).s_const_unwrap().s
    .own_push_unchecked(1).s.own_push_unchecked(2).s;
assert_eq![S.as_slice(), &[1, 2]];

Source

pub const fn own_pop(self) -> Own<Self, Result<T, NotEnoughElements>>

Pops the top stack element in compile-time.

( 1 2 3 -- 1 2 )

§Errors

Returns Own<S,NotEnoughElements> if the stack is empty.

§Examples

const S: Own<StackU16<i32, 3>, Result<i32, NotEnoughElements>> =
   StackU16::from_array_copy([1, 2, 3]).own_pop();
S.s_assert(|s| s.as_slice() == &[1, 2]).v_assert_eq(&Ok(3));

Source

pub const fn own_pop_unchecked(self) -> Own<Self, T>

Pops the top stack element in compile-time, unchecked version.

( 1 2 3 -- 1 2 )

§Panics

Panics if the stack is empty.

§Examples

const S: Own<StackU16<i32, 3>, i32> =
   StackU16::from_array_copy([1, 2, 3]).own_pop_unchecked();
S.s_assert(|s| s.as_slice() == &[1, 2]).v_assert_eq(&3);

Source

pub const fn own_peek(self) -> Own<Self, Result<T, NotEnoughElements>>

Peeks the top stack element in compile-time.

( 1 2 3 -- 1 2 )

§Errors

Returns Own<S,NotEnoughElements> if the stack is empty.

§Examples

const S: Own<StackU16<i32, 3>, Result<i32, NotEnoughElements>> =
  StackU16::from_array_copy([1, 2, 3]).own_peek();
S.s_assert(|s| s.as_slice() == &[1, 2, 3]).v_assert_eq(&Ok(3));

Source

pub const fn own_peek_unchecked(self) -> Own<Self, T>

Peeks the top stack element in compile-time, unchecked version.

( 1 2 3 -- 1 2 )

§Panics

Panics if the stack is empty.

§Examples

const S: Own<StackU16<i32, 3>, i32> = StackU16::from_array_copy([1, 2, 3])
    .own_peek_unchecked();
S.s_assert(|s| s.as_slice() == &[1, 2, 3]).v_assert_eq(&3);

Source

pub const fn own_drop(self) -> Own<Self, Result<(), NotEnoughElements>>

Drops the top stack element in compile-time.

( 1 2 -- 1 )

§Errors

Returns Own<self,NotEnoughElements> if the stack is empty.

§Examples

const S: StackU16<i32, 2> = StackU16::from_array_copy([1, 2])
    .own_drop().v_assert_ok().s;
assert_eq![S.as_slice(), &[1]];

const T: StackU16<i32, 2> = StackU16::own_new(0).s_const_unwrap().s
    .own_drop().v_assert_err().s;
assert![T.is_empty()];

Source

pub const fn own_drop_unchecked(self) -> Own<Self, ()>

Swaps the top two pair stack elements, unchecked version.

( 1 2 -- 1 )

§Panics

Panics if the stack is empty.

§Examples

const S: StackU16<i32, 2> = StackU16::from_array_copy([1, 2])
    .own_drop_unchecked().s;
assert_eq![S.as_slice(), &[1]];

Source

pub const fn own_drop_n( self, n: u16, ) -> Own<Self, Result<(), NotEnoughElements>>

Drops the top n stack elements.

( 1 2 3 4 -- 1 ) for n == 3

§Errors

Returns Own<self,NotEnoughElements> if the stack doesn’t contain at least n elements.

§Examples

const S: StackU16<i32, 4> = StackU16::from_array_copy([1, 2, 3, 4])
    .own_drop_n(3).v_assert_ok().s;
assert_eq![S.as_slice(), &[1]];

Source

pub const fn own_drop_n_unchecked(self, n: u16) -> Own<Self, ()>

Drops the top n stack elements, unchecked version.

( 1 2 3 4 -- 1 ) for n == 3

§Panics

Panics if the stack doesn’t contain at least n elements.

§Examples

const S: StackU16<i32, 4> = StackU16::from_array_copy([1, 2, 3, 4])
    .own_drop_n_unchecked(3).s;
assert_eq![S.as_slice(), &[1]];

Source

pub const fn own_nip(self) -> Own<Self, Result<(), NotEnoughElements>>

Drops the next of stack element in compile-time.

( 1 2 -- 2 )

§Errors

Returns Own<self,NotEnoughElements> if the stack doesn’t contain at least 2 elements.

§Examples

const S: StackU16<i32, 2> = StackU16::from_array_copy([1, 2])
    .own_nip().v_assert_ok().s;
assert_eq![S.as_slice(), &[2]];

const T: StackU16<i32, 2> = StackU16::own_new(0).s_const_unwrap().s
    .own_push(1).v_assert_ok().s.own_nip().v_assert_err().s;
assert_eq![T.as_slice(), &[1]];

Source

pub const fn own_nip_unchecked(self) -> Own<Self, ()>

Drops the next of stack element in compile-time, unchecked version.

( 1 2 -- 2 )

§Panics

Panics if the stack doesn’t contain at least 2 elements.

§Examples

const S: StackU16<i32, 2> = StackU16::from_array_copy([1, 2])
    .own_nip_unchecked().s;
assert_eq![S.as_slice(), &[2]];

Source

pub const fn own_nip2(self) -> Own<Self, Result<(), NotEnoughElements>>

Drops the pair of next stack elements.

( 1 2 3 4 -- 3 4 )

§Errors

Returns Own<self,NotEnoughElements> if the stack doesn’t contain at least 4 elements.

§Examples

const S: StackU16<i32, 4> = StackU16::from_array_copy([1, 2, 3, 4])
    .own_nip2().v_assert_ok().s;
assert_eq![S.as_slice(), &[3, 4]];

Source

pub const fn own_nip2_unchecked(self) -> Own<Self, ()>

Drops the pair of next stack elements, unchecked version.

( 1 2 3 4 -- 3 4 )

§Panics

Panics if the stack doesn’t contain at least 4 elements.

§Examples

const S: StackU16<i32, 4> = StackU16::from_array_copy([1, 2, 3, 4])
    .own_nip2_unchecked().s;
assert_eq![S.as_slice(), &[3, 4]];

Source

pub const fn own_swap(self) -> Own<Self, Result<(), NotEnoughElements>>

Swaps the top two stack elements in compile-time.

( 1 2 -- 2 1 )

§Errors

Returns Own<self,NotEnoughElements> if the stack doesn’t contain at least 2 elements.

§Examples

const S: StackU16<i32, 2> = StackU16::from_array_copy([1, 2])
    .own_swap().v_assert_ok().s;
assert_eq![S.as_slice(), &[2, 1]];

const T: StackU16<i32, 1> = StackU16::from_array_copy([1])
    .own_swap().v_assert_err().s;
assert_eq![T.as_slice(), &[1]];

Source

pub const fn own_swap_unchecked(self) -> Own<Self, ()>

Swaps the top two stack elements in compile-time, unchecked version.

( 1 2 -- 2 1 )

§Panics

Panics if the stack doesn’t contain at least 2 elements.

§Examples

const S: StackU16<i32, 2> = StackU16::from_array_copy([1, 2])
    .own_swap_unchecked().s;
assert_eq![S.as_slice(), &[2, 1]];

Source

pub const fn own_swap2(self) -> Own<Self, Result<(), NotEnoughElements>>

Swaps the top two pair stack elements in compile-time.

( 1 2 3 4 -- 3 4 1 2 )

§Errors

Returns Own<self,NotEnoughElements> if the stack doesn’t contain at least 4 elements.

§Examples

const S: StackU16<i32, 4> = StackU16::from_array_copy([1, 2, 3, 4])
    .own_swap2().v_assert_ok().s;
assert_eq![S.as_slice(), &[3, 4, 1, 2]];

const T: StackU16<i32, 3> = StackU16::from_array_copy([1, 2, 3])
    .own_swap2().v_assert_err().s;
assert_eq![T.as_slice(), &[1, 2, 3]];

Source

pub const fn own_swap2_unchecked(self) -> Own<Self, ()>

Swaps the top two pair stack elements in compile-time, unchecked version.

( 1 2 3 4 -- 3 4 1 2 )

§Panics

Panics if the stack doesn’t contain at least 4 elements.

§Examples

const S: StackU16<i32, 4> = StackU16::from_array_copy([1, 2, 3, 4])
    .own_swap2_unchecked().s;
assert_eq![S.as_slice(), &[3, 4, 1, 2]];

Source

pub const fn own_rot(self) -> Own<Self, Result<(), NotEnoughElements>>

Rotates the top three stack elements, clockwise.

( 1 2 3 -- 2 3 1 )

§Errors

Returns Own<self,NotEnoughElements> if the stack doesn’t contain at least 3 elements.

§Examples

const S: StackU16<i32, 4> = StackU16::from_array_copy([0, 1, 2, 3])
    .own_rot().v_assert_ok().s;
assert_eq![S.as_slice(), &[0, 2, 3, 1]];

Source

pub const fn own_rot_unchecked(self) -> Own<Self, ()>

Rotates the top three stack elements, clockwise, unchecked version.

( 1 2 3 -- 2 3 1 )

§Panics

Panics if the stack doesn’t contain at least 6 elements. if the stack doesn’t contain at least 3 elements.

§Examples

const S: StackU16<i32, 4> = StackU16::from_array_copy([0, 1, 2, 3])
    .own_rot_unchecked().s;
assert_eq![S.as_slice(), &[0, 2, 3, 1]];

Source

pub const fn own_rot_cc(self) -> Own<Self, Result<(), NotEnoughElements>>

Rotates the top three stack elements, counter-clockwise.

( 1 2 3 -- 3 1 2 )

§Errors

Returns Own<S,NotEnoughElements> if the stack doesn’t contain at least 3 elements.

§Examples

const S: StackU16<i32, 4> = StackU16::from_array_copy([0, 1, 2, 3])
    .own_rot_cc().v_assert_ok().s;
assert_eq![S.as_slice(), &[0, 3, 1, 2]];

Source

pub const fn own_rot_cc_unchecked(self) -> Own<Self, ()>

Rotates the top three stack elements, counter-clockwise, unchecked version.

( 1 2 3 -- 3 1 2 )

§Errors

Returns Own<S,NotEnoughElements> if the stack doesn’t contain at least 3 elements.

§Examples

const S: StackU16<i32, 4> = StackU16::from_array_copy([0, 1, 2, 3])
    .own_rot_cc_unchecked().s;
assert_eq![S.as_slice(), &[0, 3, 1, 2]];

Source

pub const fn own_rot2(self) -> Own<Self, Result<(), NotEnoughElements>>

Rotates the top six stack elements, clockwise, two times.

( 1 2 3 4 5 6 -- 3 4 5 6 1 2 )

§Errors

Returns Own<self,NotEnoughElements> if the stack doesn’t contain at least 6 elements.

§Examples

const S: StackU16<i32, 7> = StackU16::from_array_copy([0, 1, 2, 3, 4, 5, 6])
    .own_rot2().v_assert_ok().s;
assert_eq![S.as_slice(), &[0, 3, 4, 5, 6, 1, 2]];

Source

pub const fn own_rot2_unchecked(self) -> Own<Self, ()>

Rotates the top six stack elements, clockwise, two times, unchecked version.

( 1 2 3 4 5 6 -- 3 4 5 6 1 2 )

§Panics

Panics if the stack doesn’t contain at least 6 elements.

§Examples

const S: StackU16<i32, 7> = StackU16::from_array_copy([0, 1, 2, 3, 4, 5, 6])
    .own_rot2_unchecked().s;
assert_eq![S.as_slice(), &[0, 3, 4, 5, 6, 1, 2]];

Source

pub const fn own_rot2_cc(self) -> Own<Self, Result<(), NotEnoughElements>>

Rotates the top six stack elements, counter-clockwise, two times.

( 1 2 3 4 5 6 -- 5 6 1 2 3 4 )

§Errors

Returns Own<self,NotEnoughElements> if the stack doesn’t contain at least 6 elements.

§Examples

const S: StackU16<i32, 7> = StackU16::from_array_copy([0, 1, 2, 3, 4, 5, 6])
    .own_rot2_cc().v_assert_ok().s;
assert_eq![S.as_slice(), &[0, 5, 6, 1, 2, 3, 4]];

Source

pub const fn own_rot2_cc_unchecked(self) -> Own<Self, ()>

Rotates the top six stack elements, counter-clockwise, two times, unchecked version.

( 1 2 3 4 5 6 -- 5 6 1 2 3 4 )

§Panics

Panics if the stack doesn’t contain at least 6 elements.

§Examples

const S: StackU16<i32, 7> = StackU16::from_array_copy([0, 1, 2, 3, 4, 5, 6])
    .own_rot2_cc_unchecked().s;
assert_eq![S.as_slice(), &[0, 5, 6, 1, 2, 3, 4]];

Source

pub const fn own_dup(self) -> Own<Self, Result<(), DataNotEnough>>

Duplicates the top stack element.

( 1 -- 1 1 )

§Errors

Returns Own<self,DataNotEnough::Elements> if the stack is empty or Own<self,DataNotEnough::Space> if the stack is full.

§Examples

const S: StackU16<i32, 3> = StackU16::own_new(0).s_const_unwrap().s
    .own_push(1).s.own_dup().v_assert_ok().s;
assert_eq![S.as_slice(), &[1, 1]];

Source

pub const fn own_dup_unchecked(self) -> Own<Self, ()>

Duplicates the top stack element, unchecked version.

( 1 -- 1 1 )

§Panics

Panics if the stack is either empty or full.

§Examples

const S: StackU16<i32, 3> = StackU16::own_new(0).s_const_unwrap().s
    .own_push(1).s.own_dup_unchecked().s;
assert_eq![S.as_slice(), &[1, 1]];

Source

pub const fn own_dup2(self) -> Own<Self, Result<(), DataNotEnough>>

Duplicates the top stack pair of elements.

( 1 2 -- 1 2 1 2 )

§Errors

Returns Own<self,DataNotEnough::Elements> if the stack doesn’t have at least 2 elements, or Own<self,DataNotEnough::Space> if it doesn’t have enough space for 2 extra elements.

§Examples

const S: StackU16<i32, 6> = StackU16::from_array_copy([0, 1, 2, 0, 0, 0])
    .own_drop_n(3).s.own_dup2().v_assert_ok().s;
assert_eq![S.as_slice(), &[0, 1, 2, 1, 2]];

Source

pub const fn own_dup2_unchecked(self) -> Own<Self, ()>

Duplicates the top stack pair of elements, unchecked version.

( 1 2 -- 1 2 1 2 )

§Panics

Panics if the stack doesn’t have at least 2 elements, or if it doesn’t have enough space for 2 extra elements.

§Examples

const S: StackU16<i32, 6> = StackU16::from_array_copy([0, 1, 2, 0, 0, 0])
    .own_drop_n(3).s.own_dup2_unchecked().s;
assert_eq![S.as_slice(), &[0, 1, 2, 1, 2]];

Source

pub const fn own_over(self) -> Own<Self, Result<(), DataNotEnough>>

Duplicates the next of stack element to the top.

( 1 2 -- 1 2 1 )

§Errors

Returns Own<self,DataNotEnough::Elements> if the stack doesn’t have at least 2 elements, or Own<self,DataNotEnough::Space> if it doesn’t have enough space for 2 extra elements.

§Examples

const S: StackU16<i32, 4> = StackU16::from_array_copy([0, 1, 2, 0])
    .own_drop().s.own_over().v_assert_ok().s;
assert_eq![S.as_slice(), &[0, 1, 2, 1]];

Source

pub const fn own_over_unchecked(self) -> Own<Self, ()>

Duplicates the next of stack element to the top.

( 1 2 -- 1 2 1 )

§Panics

Panics if the stack doesn’t have at least 2 elements, or if it doesn’t have enough space for 2 extra elements.

§Examples

const S: StackU16<i32, 4> = StackU16::from_array_copy([0, 1, 2, 0])
    .own_drop().s.own_over_unchecked().s;
assert_eq![S.as_slice(), &[0, 1, 2, 1]];

Source

pub const fn own_over2(self) -> Own<Self, Result<(), DataNotEnough>>

Duplicates the next of stack pair of elements to the top.

( 1 2 3 4 -- 1 2 3 4 1 2 )

§Errors

Returns Own<self,DataNotEnough::Elements> if the stack doesn’t have at least 4 elements, or Own<self,DataNotEnough::Space> if it doesn’t have enough space for 2 extra elements.

§Examples

const S: StackU16<i32, 7> = StackU16::from_array_copy([0, 1, 2, 3, 4, 0, 0])
    .own_drop_n(2).s.own_over2().v_assert_ok().s;
assert_eq![S.as_slice(), &[0, 1, 2, 3, 4, 1, 2]];

Source

pub const fn own_over2_unchecked(self) -> Own<Self, ()>

Duplicates the next of stack pair of elements to the top.

( 1 2 3 4 -- 1 2 3 4 1 2 )

§Panics

Panics if the stack doesn’t have at least 4 elements, or if it doesn’t have enough space for 2 extra elements.

§Examples

const S: StackU16<i32, 7> = StackU16::from_array_copy([0, 1, 2, 3, 4, 0, 0])
    .own_drop_n(2).s.own_over2_unchecked().s;
assert_eq![S.as_slice(), &[0, 1, 2, 3, 4, 1, 2]];

Source

pub const fn own_tuck(self) -> Own<Self, Result<(), DataNotEnough>>

Duplicates the top element before the next of stack element.

( 1 2 -- 2 1 2 )

§Errors

Returns Own<self,DataNotEnough::Elements> if the stack doesn’t have at least 2 elements, or Own<self,DataNotEnough::Space> if it doesn’t have enough space for 1 extra elements.

§Examples

const S: StackU16<i32, 4> = StackU16::from_array_copy([0, 1, 2, 0])
    .own_drop().s.own_tuck().v_assert_ok().s;
assert_eq![S.as_slice(), &[0, 2, 1, 2]];

Source

pub const fn own_tuck_unchecked(self) -> Own<Self, ()>

Duplicates the top element before the next of stack element, unchecked version.

( 1 2 -- 2 1 2 )

§Panics

Panics if the stack doesn’t have at least 2 elements, or if it doesn’t have enough space for 1 extra elements.

§Examples

const S: StackU16<i32, 4> = StackU16::from_array_copy([0, 1, 2, 0])
    .own_drop().s.own_tuck_unchecked().s;
assert_eq![S.as_slice(), &[0, 2, 1, 2]];

Source

pub const fn own_tuck2(self) -> Own<Self, Result<(), DataNotEnough>>

Duplicates the top pair of elements before the next of stack pair of elements.

( 1 2 3 4 -- 3 4 1 2 3 4 )

§Errors

Returns Own<self,DataNotEnough::Elements> if the stack doesn’t have at least 4 elements, or Own<self,DataNotEnough::Space> if it doesn’t have enough space for 2 extra elements.

§Examples

const S: StackU16<i32, 7> = StackU16::from_array_copy([0, 1, 2, 3, 4, 0, 0])
    .own_drop_n(2).s.own_tuck2_unchecked().s;
assert_eq![S.as_slice(), &[0, 3, 4, 1, 2, 3, 4]];

Source

pub const fn own_tuck2_unchecked(self) -> Own<Self, ()>

Duplicates the top pair of elements before the next of stack pair of elements, unchecked version.

( 1 2 3 4 -- 3 4 1 2 3 4 )

§Panics

Panics if the stack doesn’t have at least 4 elements, or if it doesn’t have enough space for 2 extra elements.

§Examples

const S: StackU16<i32, 7> = StackU16::from_array_copy([0, 1, 2, 3, 4, 0, 0])
    .own_drop_n(2).s.own_tuck2_unchecked().s;
assert_eq![S.as_slice(), &[0, 3, 4, 1, 2, 3, 4]];

Source §

impl<T: Copy, const CAP: usize> Stack<T, CAP, u32, Bare>

§Chainable const

operations depending on T: Copy

Every method is const and returns Own<Self, V>.

Source

pub const fn own_new(element: T) -> Own<Result<Self, MismatchedCapacity>, ()>

Returns an empty stack, allocated in the stack, copying element to fill the remaining free data.

§Errors

Returns MismatchedCapacity if CAP > u32::MAX or if CAP > isize::MAX / size_of::<T>().

§Examples

const S: StackU32<i32, 16> = StackU32::own_new(0).s_const_unwrap().s;

Source

pub const fn own_clear(self) -> Own<Self, ()>

Clears the stack in compile-time.

( 1 2 3 -- )

§Examples

const S: StackU32<i32, 3> = StackU32::from_array_copy([1, 2, 3]).own_clear().s;
assert![S.is_empty()];

Source

pub const fn own_push(self, element: T) -> Own<Self, Result<(), NotEnoughSpace>>

Pushes a new element to the top of the stack in compile-time.

( 1 -- 1 2 )

§Errors

Returns Own<S,NotEnoughSpace> if the stack is full.

§Examples

const S: StackU32<i32, 2> = StackU32::own_new(0).s_const_unwrap().s
    .own_push(1).v_assert_ok().s
    .own_push(2).v_assert_ok().s;
assert_eq![S.as_slice(), &[1, 2]];
assert![S.own_push(3).v.is_err_and(|e| matches![e, NotEnoughSpace])];

Source

pub const fn own_push_unchecked(self, element: T) -> Own<Self, ()>

Pushes a new element to the top of the stack in compile-time, unchecked version.

( 1 -- 1 2 )

§Panics

Panics if the stack is full.

§Examples

const S: StackU32<i32, 2> = StackU32::own_new(0).s_const_unwrap().s
    .own_push_unchecked(1).s.own_push_unchecked(2).s;
assert_eq![S.as_slice(), &[1, 2]];

Source

pub const fn own_pop(self) -> Own<Self, Result<T, NotEnoughElements>>

Pops the top stack element in compile-time.

( 1 2 3 -- 1 2 )

§Errors

Returns Own<S,NotEnoughElements> if the stack is empty.

§Examples

const S: Own<StackU32<i32, 3>, Result<i32, NotEnoughElements>> =
   StackU32::from_array_copy([1, 2, 3]).own_pop();
S.s_assert(|s| s.as_slice() == &[1, 2]).v_assert_eq(&Ok(3));

Source

pub const fn own_pop_unchecked(self) -> Own<Self, T>

Pops the top stack element in compile-time, unchecked version.

( 1 2 3 -- 1 2 )

§Panics

Panics if the stack is empty.

§Examples

const S: Own<StackU32<i32, 3>, i32> =
   StackU32::from_array_copy([1, 2, 3]).own_pop_unchecked();
S.s_assert(|s| s.as_slice() == &[1, 2]).v_assert_eq(&3);

Source

pub const fn own_peek(self) -> Own<Self, Result<T, NotEnoughElements>>

Peeks the top stack element in compile-time.

( 1 2 3 -- 1 2 )

§Errors

Returns Own<S,NotEnoughElements> if the stack is empty.

§Examples

const S: Own<StackU32<i32, 3>, Result<i32, NotEnoughElements>> =
  StackU32::from_array_copy([1, 2, 3]).own_peek();
S.s_assert(|s| s.as_slice() == &[1, 2, 3]).v_assert_eq(&Ok(3));

Source

pub const fn own_peek_unchecked(self) -> Own<Self, T>

Peeks the top stack element in compile-time, unchecked version.

( 1 2 3 -- 1 2 )

§Panics

Panics if the stack is empty.

§Examples

const S: Own<StackU32<i32, 3>, i32> = StackU32::from_array_copy([1, 2, 3])
    .own_peek_unchecked();
S.s_assert(|s| s.as_slice() == &[1, 2, 3]).v_assert_eq(&3);

Source

pub const fn own_drop(self) -> Own<Self, Result<(), NotEnoughElements>>

Drops the top stack element in compile-time.

( 1 2 -- 1 )

§Errors

Returns Own<self,NotEnoughElements> if the stack is empty.

§Examples

const S: StackU32<i32, 2> = StackU32::from_array_copy([1, 2])
    .own_drop().v_assert_ok().s;
assert_eq![S.as_slice(), &[1]];

const T: StackU32<i32, 2> = StackU32::own_new(0).s_const_unwrap().s
    .own_drop().v_assert_err().s;
assert![T.is_empty()];

Source

pub const fn own_drop_unchecked(self) -> Own<Self, ()>

Swaps the top two pair stack elements, unchecked version.

( 1 2 -- 1 )

§Panics

Panics if the stack is empty.

§Examples

const S: StackU32<i32, 2> = StackU32::from_array_copy([1, 2])
    .own_drop_unchecked().s;
assert_eq![S.as_slice(), &[1]];

Source

pub const fn own_drop_n( self, n: u32, ) -> Own<Self, Result<(), NotEnoughElements>>

Drops the top n stack elements.

( 1 2 3 4 -- 1 ) for n == 3

§Errors

Returns Own<self,NotEnoughElements> if the stack doesn’t contain at least n elements.

§Examples

const S: StackU32<i32, 4> = StackU32::from_array_copy([1, 2, 3, 4])
    .own_drop_n(3).v_assert_ok().s;
assert_eq![S.as_slice(), &[1]];

Source

pub const fn own_drop_n_unchecked(self, n: u32) -> Own<Self, ()>

Drops the top n stack elements, unchecked version.

( 1 2 3 4 -- 1 ) for n == 3

§Panics

Panics if the stack doesn’t contain at least n elements.

§Examples

const S: StackU32<i32, 4> = StackU32::from_array_copy([1, 2, 3, 4])
    .own_drop_n_unchecked(3).s;
assert_eq![S.as_slice(), &[1]];

Source

pub const fn own_nip(self) -> Own<Self, Result<(), NotEnoughElements>>

Drops the next of stack element in compile-time.

( 1 2 -- 2 )

§Errors

Returns Own<self,NotEnoughElements> if the stack doesn’t contain at least 2 elements.

§Examples

const S: StackU32<i32, 2> = StackU32::from_array_copy([1, 2])
    .own_nip().v_assert_ok().s;
assert_eq![S.as_slice(), &[2]];

const T: StackU32<i32, 2> = StackU32::own_new(0).s_const_unwrap().s
    .own_push(1).v_assert_ok().s.own_nip().v_assert_err().s;
assert_eq![T.as_slice(), &[1]];

Source

pub const fn own_nip_unchecked(self) -> Own<Self, ()>

Drops the next of stack element in compile-time, unchecked version.

( 1 2 -- 2 )

§Panics

Panics if the stack doesn’t contain at least 2 elements.

§Examples

const S: StackU32<i32, 2> = StackU32::from_array_copy([1, 2])
    .own_nip_unchecked().s;
assert_eq![S.as_slice(), &[2]];

Source

pub const fn own_nip2(self) -> Own<Self, Result<(), NotEnoughElements>>

Drops the pair of next stack elements.

( 1 2 3 4 -- 3 4 )

§Errors

Returns Own<self,NotEnoughElements> if the stack doesn’t contain at least 4 elements.

§Examples

const S: StackU32<i32, 4> = StackU32::from_array_copy([1, 2, 3, 4])
    .own_nip2().v_assert_ok().s;
assert_eq![S.as_slice(), &[3, 4]];

Source

pub const fn own_nip2_unchecked(self) -> Own<Self, ()>

Drops the pair of next stack elements, unchecked version.

( 1 2 3 4 -- 3 4 )

§Panics

Panics if the stack doesn’t contain at least 4 elements.

§Examples

const S: StackU32<i32, 4> = StackU32::from_array_copy([1, 2, 3, 4])
    .own_nip2_unchecked().s;
assert_eq![S.as_slice(), &[3, 4]];

Source

pub const fn own_swap(self) -> Own<Self, Result<(), NotEnoughElements>>

Swaps the top two stack elements in compile-time.

( 1 2 -- 2 1 )

§Errors

Returns Own<self,NotEnoughElements> if the stack doesn’t contain at least 2 elements.

§Examples

const S: StackU32<i32, 2> = StackU32::from_array_copy([1, 2])
    .own_swap().v_assert_ok().s;
assert_eq![S.as_slice(), &[2, 1]];

const T: StackU32<i32, 1> = StackU32::from_array_copy([1])
    .own_swap().v_assert_err().s;
assert_eq![T.as_slice(), &[1]];

Source

pub const fn own_swap_unchecked(self) -> Own<Self, ()>

Swaps the top two stack elements in compile-time, unchecked version.

( 1 2 -- 2 1 )

§Panics

Panics if the stack doesn’t contain at least 2 elements.

§Examples

const S: StackU32<i32, 2> = StackU32::from_array_copy([1, 2])
    .own_swap_unchecked().s;
assert_eq![S.as_slice(), &[2, 1]];

Source

pub const fn own_swap2(self) -> Own<Self, Result<(), NotEnoughElements>>

Swaps the top two pair stack elements in compile-time.

( 1 2 3 4 -- 3 4 1 2 )

§Errors

Returns Own<self,NotEnoughElements> if the stack doesn’t contain at least 4 elements.

§Examples

const S: StackU32<i32, 4> = StackU32::from_array_copy([1, 2, 3, 4])
    .own_swap2().v_assert_ok().s;
assert_eq![S.as_slice(), &[3, 4, 1, 2]];

const T: StackU32<i32, 3> = StackU32::from_array_copy([1, 2, 3])
    .own_swap2().v_assert_err().s;
assert_eq![T.as_slice(), &[1, 2, 3]];

Source

pub const fn own_swap2_unchecked(self) -> Own<Self, ()>

Swaps the top two pair stack elements in compile-time, unchecked version.

( 1 2 3 4 -- 3 4 1 2 )

§Panics

Panics if the stack doesn’t contain at least 4 elements.

§Examples

const S: StackU32<i32, 4> = StackU32::from_array_copy([1, 2, 3, 4])
    .own_swap2_unchecked().s;
assert_eq![S.as_slice(), &[3, 4, 1, 2]];

Source

pub const fn own_rot(self) -> Own<Self, Result<(), NotEnoughElements>>

Rotates the top three stack elements, clockwise.

( 1 2 3 -- 2 3 1 )

§Errors

Returns Own<self,NotEnoughElements> if the stack doesn’t contain at least 3 elements.

§Examples

const S: StackU32<i32, 4> = StackU32::from_array_copy([0, 1, 2, 3])
    .own_rot().v_assert_ok().s;
assert_eq![S.as_slice(), &[0, 2, 3, 1]];

Source

pub const fn own_rot_unchecked(self) -> Own<Self, ()>

Rotates the top three stack elements, clockwise, unchecked version.

( 1 2 3 -- 2 3 1 )

§Panics

Panics if the stack doesn’t contain at least 6 elements. if the stack doesn’t contain at least 3 elements.

§Examples

const S: StackU32<i32, 4> = StackU32::from_array_copy([0, 1, 2, 3])
    .own_rot_unchecked().s;
assert_eq![S.as_slice(), &[0, 2, 3, 1]];

Source

pub const fn own_rot_cc(self) -> Own<Self, Result<(), NotEnoughElements>>

Rotates the top three stack elements, counter-clockwise.

( 1 2 3 -- 3 1 2 )

§Errors

Returns Own<S,NotEnoughElements> if the stack doesn’t contain at least 3 elements.

§Examples

const S: StackU32<i32, 4> = StackU32::from_array_copy([0, 1, 2, 3])
    .own_rot_cc().v_assert_ok().s;
assert_eq![S.as_slice(), &[0, 3, 1, 2]];

Source

pub const fn own_rot_cc_unchecked(self) -> Own<Self, ()>

Rotates the top three stack elements, counter-clockwise, unchecked version.

( 1 2 3 -- 3 1 2 )

§Errors

Returns Own<S,NotEnoughElements> if the stack doesn’t contain at least 3 elements.

§Examples

const S: StackU32<i32, 4> = StackU32::from_array_copy([0, 1, 2, 3])
    .own_rot_cc_unchecked().s;
assert_eq![S.as_slice(), &[0, 3, 1, 2]];

Source

pub const fn own_rot2(self) -> Own<Self, Result<(), NotEnoughElements>>

Rotates the top six stack elements, clockwise, two times.

( 1 2 3 4 5 6 -- 3 4 5 6 1 2 )

§Errors

Returns Own<self,NotEnoughElements> if the stack doesn’t contain at least 6 elements.

§Examples

const S: StackU32<i32, 7> = StackU32::from_array_copy([0, 1, 2, 3, 4, 5, 6])
    .own_rot2().v_assert_ok().s;
assert_eq![S.as_slice(), &[0, 3, 4, 5, 6, 1, 2]];

Source

pub const fn own_rot2_unchecked(self) -> Own<Self, ()>

Rotates the top six stack elements, clockwise, two times, unchecked version.

( 1 2 3 4 5 6 -- 3 4 5 6 1 2 )

§Panics

Panics if the stack doesn’t contain at least 6 elements.

§Examples

const S: StackU32<i32, 7> = StackU32::from_array_copy([0, 1, 2, 3, 4, 5, 6])
    .own_rot2_unchecked().s;
assert_eq![S.as_slice(), &[0, 3, 4, 5, 6, 1, 2]];

Source

pub const fn own_rot2_cc(self) -> Own<Self, Result<(), NotEnoughElements>>

Rotates the top six stack elements, counter-clockwise, two times.

( 1 2 3 4 5 6 -- 5 6 1 2 3 4 )

§Errors

Returns Own<self,NotEnoughElements> if the stack doesn’t contain at least 6 elements.

§Examples

const S: StackU32<i32, 7> = StackU32::from_array_copy([0, 1, 2, 3, 4, 5, 6])
    .own_rot2_cc().v_assert_ok().s;
assert_eq![S.as_slice(), &[0, 5, 6, 1, 2, 3, 4]];

Source

pub const fn own_rot2_cc_unchecked(self) -> Own<Self, ()>

Rotates the top six stack elements, counter-clockwise, two times, unchecked version.

( 1 2 3 4 5 6 -- 5 6 1 2 3 4 )

§Panics

Panics if the stack doesn’t contain at least 6 elements.

§Examples

const S: StackU32<i32, 7> = StackU32::from_array_copy([0, 1, 2, 3, 4, 5, 6])
    .own_rot2_cc_unchecked().s;
assert_eq![S.as_slice(), &[0, 5, 6, 1, 2, 3, 4]];

Source

pub const fn own_dup(self) -> Own<Self, Result<(), DataNotEnough>>

Duplicates the top stack element.

( 1 -- 1 1 )

§Errors

Returns Own<self,DataNotEnough::Elements> if the stack is empty or Own<self,DataNotEnough::Space> if the stack is full.

§Examples

const S: StackU32<i32, 3> = StackU32::own_new(0).s_const_unwrap().s
    .own_push(1).s.own_dup().v_assert_ok().s;
assert_eq![S.as_slice(), &[1, 1]];

Source

pub const fn own_dup_unchecked(self) -> Own<Self, ()>

Duplicates the top stack element, unchecked version.

( 1 -- 1 1 )

§Panics

Panics if the stack is either empty or full.

§Examples

const S: StackU32<i32, 3> = StackU32::own_new(0).s_const_unwrap().s
    .own_push(1).s.own_dup_unchecked().s;
assert_eq![S.as_slice(), &[1, 1]];

Source

pub const fn own_dup2(self) -> Own<Self, Result<(), DataNotEnough>>

Duplicates the top stack pair of elements.

( 1 2 -- 1 2 1 2 )

§Errors

Returns Own<self,DataNotEnough::Elements> if the stack doesn’t have at least 2 elements, or Own<self,DataNotEnough::Space> if it doesn’t have enough space for 2 extra elements.

§Examples

const S: StackU32<i32, 6> = StackU32::from_array_copy([0, 1, 2, 0, 0, 0])
    .own_drop_n(3).s.own_dup2().v_assert_ok().s;
assert_eq![S.as_slice(), &[0, 1, 2, 1, 2]];

Source

pub const fn own_dup2_unchecked(self) -> Own<Self, ()>

Duplicates the top stack pair of elements, unchecked version.

( 1 2 -- 1 2 1 2 )

§Panics

Panics if the stack doesn’t have at least 2 elements, or if it doesn’t have enough space for 2 extra elements.

§Examples

const S: StackU32<i32, 6> = StackU32::from_array_copy([0, 1, 2, 0, 0, 0])
    .own_drop_n(3).s.own_dup2_unchecked().s;
assert_eq![S.as_slice(), &[0, 1, 2, 1, 2]];

Source

pub const fn own_over(self) -> Own<Self, Result<(), DataNotEnough>>

Duplicates the next of stack element to the top.

( 1 2 -- 1 2 1 )

§Errors

Returns Own<self,DataNotEnough::Elements> if the stack doesn’t have at least 2 elements, or Own<self,DataNotEnough::Space> if it doesn’t have enough space for 2 extra elements.

§Examples

const S: StackU32<i32, 4> = StackU32::from_array_copy([0, 1, 2, 0])
    .own_drop().s.own_over().v_assert_ok().s;
assert_eq![S.as_slice(), &[0, 1, 2, 1]];

Source

pub const fn own_over_unchecked(self) -> Own<Self, ()>

Duplicates the next of stack element to the top.

( 1 2 -- 1 2 1 )

§Panics

Panics if the stack doesn’t have at least 2 elements, or if it doesn’t have enough space for 2 extra elements.

§Examples

const S: StackU32<i32, 4> = StackU32::from_array_copy([0, 1, 2, 0])
    .own_drop().s.own_over_unchecked().s;
assert_eq![S.as_slice(), &[0, 1, 2, 1]];

Source

pub const fn own_over2(self) -> Own<Self, Result<(), DataNotEnough>>

Duplicates the next of stack pair of elements to the top.

( 1 2 3 4 -- 1 2 3 4 1 2 )

§Errors

Returns Own<self,DataNotEnough::Elements> if the stack doesn’t have at least 4 elements, or Own<self,DataNotEnough::Space> if it doesn’t have enough space for 2 extra elements.

§Examples

const S: StackU32<i32, 7> = StackU32::from_array_copy([0, 1, 2, 3, 4, 0, 0])
    .own_drop_n(2).s.own_over2().v_assert_ok().s;
assert_eq![S.as_slice(), &[0, 1, 2, 3, 4, 1, 2]];

Source

pub const fn own_over2_unchecked(self) -> Own<Self, ()>

Duplicates the next of stack pair of elements to the top.

( 1 2 3 4 -- 1 2 3 4 1 2 )

§Panics

Panics if the stack doesn’t have at least 4 elements, or if it doesn’t have enough space for 2 extra elements.

§Examples

const S: StackU32<i32, 7> = StackU32::from_array_copy([0, 1, 2, 3, 4, 0, 0])
    .own_drop_n(2).s.own_over2_unchecked().s;
assert_eq![S.as_slice(), &[0, 1, 2, 3, 4, 1, 2]];

Source

pub const fn own_tuck(self) -> Own<Self, Result<(), DataNotEnough>>

Duplicates the top element before the next of stack element.

( 1 2 -- 2 1 2 )

§Errors

Returns Own<self,DataNotEnough::Elements> if the stack doesn’t have at least 2 elements, or Own<self,DataNotEnough::Space> if it doesn’t have enough space for 1 extra elements.

§Examples

const S: StackU32<i32, 4> = StackU32::from_array_copy([0, 1, 2, 0])
    .own_drop().s.own_tuck().v_assert_ok().s;
assert_eq![S.as_slice(), &[0, 2, 1, 2]];

Source

pub const fn own_tuck_unchecked(self) -> Own<Self, ()>

Duplicates the top element before the next of stack element, unchecked version.

( 1 2 -- 2 1 2 )

§Panics

Panics if the stack doesn’t have at least 2 elements, or if it doesn’t have enough space for 1 extra elements.

§Examples

const S: StackU32<i32, 4> = StackU32::from_array_copy([0, 1, 2, 0])
    .own_drop().s.own_tuck_unchecked().s;
assert_eq![S.as_slice(), &[0, 2, 1, 2]];

Source

pub const fn own_tuck2(self) -> Own<Self, Result<(), DataNotEnough>>

Duplicates the top pair of elements before the next of stack pair of elements.

( 1 2 3 4 -- 3 4 1 2 3 4 )

§Errors

Returns Own<self,DataNotEnough::Elements> if the stack doesn’t have at least 4 elements, or Own<self,DataNotEnough::Space> if it doesn’t have enough space for 2 extra elements.

§Examples

const S: StackU32<i32, 7> = StackU32::from_array_copy([0, 1, 2, 3, 4, 0, 0])
    .own_drop_n(2).s.own_tuck2_unchecked().s;
assert_eq![S.as_slice(), &[0, 3, 4, 1, 2, 3, 4]];

Source

pub const fn own_tuck2_unchecked(self) -> Own<Self, ()>

Duplicates the top pair of elements before the next of stack pair of elements, unchecked version.

( 1 2 3 4 -- 3 4 1 2 3 4 )

§Panics

Panics if the stack doesn’t have at least 4 elements, or if it doesn’t have enough space for 2 extra elements.

§Examples

const S: StackU32<i32, 7> = StackU32::from_array_copy([0, 1, 2, 3, 4, 0, 0])
    .own_drop_n(2).s.own_tuck2_unchecked().s;
assert_eq![S.as_slice(), &[0, 3, 4, 1, 2, 3, 4]];

Source §

impl<T: Copy, const CAP: usize> Stack<T, CAP, usize, Bare>

§Chainable const

operations depending on T: Copy

Every method is const and returns Own<Self, V>.

Source

pub const fn own_new(element: T) -> Own<Result<Self, MismatchedCapacity>, ()>

Returns an empty stack, allocated in the stack, copying element to fill the remaining free data.

§Errors

Returns MismatchedCapacity if CAP > usize::MAX or if CAP > isize::MAX / size_of::<T>().

§Examples

const S: StackUsize<i32, 16> = StackUsize::own_new(0).s_const_unwrap().s;

Source

pub const fn own_clear(self) -> Own<Self, ()>

Clears the stack in compile-time.

( 1 2 3 -- )

§Examples

const S: StackUsize<i32, 3> = StackUsize::from_array_copy([1, 2, 3]).own_clear().s;
assert![S.is_empty()];

Source

pub const fn own_push(self, element: T) -> Own<Self, Result<(), NotEnoughSpace>>

Pushes a new element to the top of the stack in compile-time.

( 1 -- 1 2 )

§Errors

Returns Own<S,NotEnoughSpace> if the stack is full.

§Examples

const S: StackUsize<i32, 2> = StackUsize::own_new(0).s_const_unwrap().s
    .own_push(1).v_assert_ok().s
    .own_push(2).v_assert_ok().s;
assert_eq![S.as_slice(), &[1, 2]];
assert![S.own_push(3).v.is_err_and(|e| matches![e, NotEnoughSpace])];

Source

pub const fn own_push_unchecked(self, element: T) -> Own<Self, ()>

Pushes a new element to the top of the stack in compile-time, unchecked version.

( 1 -- 1 2 )

§Panics

Panics if the stack is full.

§Examples

const S: StackUsize<i32, 2> = StackUsize::own_new(0).s_const_unwrap().s
    .own_push_unchecked(1).s.own_push_unchecked(2).s;
assert_eq![S.as_slice(), &[1, 2]];

Source

pub const fn own_pop(self) -> Own<Self, Result<T, NotEnoughElements>>

Pops the top stack element in compile-time.

( 1 2 3 -- 1 2 )

§Errors

Returns Own<S,NotEnoughElements> if the stack is empty.

§Examples

const S: Own<StackUsize<i32, 3>, Result<i32, NotEnoughElements>> =
   StackUsize::from_array_copy([1, 2, 3]).own_pop();
S.s_assert(|s| s.as_slice() == &[1, 2]).v_assert_eq(&Ok(3));

Source

pub const fn own_pop_unchecked(self) -> Own<Self, T>

Pops the top stack element in compile-time, unchecked version.

( 1 2 3 -- 1 2 )

§Panics

Panics if the stack is empty.

§Examples

const S: Own<StackUsize<i32, 3>, i32> =
   StackUsize::from_array_copy([1, 2, 3]).own_pop_unchecked();
S.s_assert(|s| s.as_slice() == &[1, 2]).v_assert_eq(&3);

Source

pub const fn own_peek(self) -> Own<Self, Result<T, NotEnoughElements>>

Peeks the top stack element in compile-time.

( 1 2 3 -- 1 2 )

§Errors

Returns Own<S,NotEnoughElements> if the stack is empty.

§Examples

const S: Own<StackUsize<i32, 3>, Result<i32, NotEnoughElements>> =
  StackUsize::from_array_copy([1, 2, 3]).own_peek();
S.s_assert(|s| s.as_slice() == &[1, 2, 3]).v_assert_eq(&Ok(3));

Source

pub const fn own_peek_unchecked(self) -> Own<Self, T>

Peeks the top stack element in compile-time, unchecked version.

( 1 2 3 -- 1 2 )

§Panics

Panics if the stack is empty.

§Examples

const S: Own<StackUsize<i32, 3>, i32> = StackUsize::from_array_copy([1, 2, 3])
    .own_peek_unchecked();
S.s_assert(|s| s.as_slice() == &[1, 2, 3]).v_assert_eq(&3);

Source

pub const fn own_drop(self) -> Own<Self, Result<(), NotEnoughElements>>

Drops the top stack element in compile-time.

( 1 2 -- 1 )

§Errors

Returns Own<self,NotEnoughElements> if the stack is empty.

§Examples

const S: StackUsize<i32, 2> = StackUsize::from_array_copy([1, 2])
    .own_drop().v_assert_ok().s;
assert_eq![S.as_slice(), &[1]];

const T: StackUsize<i32, 2> = StackUsize::own_new(0).s_const_unwrap().s
    .own_drop().v_assert_err().s;
assert![T.is_empty()];

Source

pub const fn own_drop_unchecked(self) -> Own<Self, ()>

Swaps the top two pair stack elements, unchecked version.

( 1 2 -- 1 )

§Panics

Panics if the stack is empty.

§Examples

const S: StackUsize<i32, 2> = StackUsize::from_array_copy([1, 2])
    .own_drop_unchecked().s;
assert_eq![S.as_slice(), &[1]];

Source

pub const fn own_drop_n( self, n: usize, ) -> Own<Self, Result<(), NotEnoughElements>>

Drops the top n stack elements.

( 1 2 3 4 -- 1 ) for n == 3

§Errors

Returns Own<self,NotEnoughElements> if the stack doesn’t contain at least n elements.

§Examples

const S: StackUsize<i32, 4> = StackUsize::from_array_copy([1, 2, 3, 4])
    .own_drop_n(3).v_assert_ok().s;
assert_eq![S.as_slice(), &[1]];

Source

pub const fn own_drop_n_unchecked(self, n: usize) -> Own<Self, ()>

Drops the top n stack elements, unchecked version.

( 1 2 3 4 -- 1 ) for n == 3

§Panics

Panics if the stack doesn’t contain at least n elements.

§Examples

const S: StackUsize<i32, 4> = StackUsize::from_array_copy([1, 2, 3, 4])
    .own_drop_n_unchecked(3).s;
assert_eq![S.as_slice(), &[1]];

Source

pub const fn own_nip(self) -> Own<Self, Result<(), NotEnoughElements>>

Drops the next of stack element in compile-time.

( 1 2 -- 2 )

§Errors

Returns Own<self,NotEnoughElements> if the stack doesn’t contain at least 2 elements.

§Examples

const S: StackUsize<i32, 2> = StackUsize::from_array_copy([1, 2])
    .own_nip().v_assert_ok().s;
assert_eq![S.as_slice(), &[2]];

const T: StackUsize<i32, 2> = StackUsize::own_new(0).s_const_unwrap().s
    .own_push(1).v_assert_ok().s.own_nip().v_assert_err().s;
assert_eq![T.as_slice(), &[1]];

Source

pub const fn own_nip_unchecked(self) -> Own<Self, ()>

Drops the next of stack element in compile-time, unchecked version.

( 1 2 -- 2 )

§Panics

Panics if the stack doesn’t contain at least 2 elements.

§Examples

const S: StackUsize<i32, 2> = StackUsize::from_array_copy([1, 2])
    .own_nip_unchecked().s;
assert_eq![S.as_slice(), &[2]];

Source

pub const fn own_nip2(self) -> Own<Self, Result<(), NotEnoughElements>>

Drops the pair of next stack elements.

( 1 2 3 4 -- 3 4 )

§Errors

Returns Own<self,NotEnoughElements> if the stack doesn’t contain at least 4 elements.

§Examples

const S: StackUsize<i32, 4> = StackUsize::from_array_copy([1, 2, 3, 4])
    .own_nip2().v_assert_ok().s;
assert_eq![S.as_slice(), &[3, 4]];

Source

pub const fn own_nip2_unchecked(self) -> Own<Self, ()>

Drops the pair of next stack elements, unchecked version.

( 1 2 3 4 -- 3 4 )

§Panics

Panics if the stack doesn’t contain at least 4 elements.

§Examples

const S: StackUsize<i32, 4> = StackUsize::from_array_copy([1, 2, 3, 4])
    .own_nip2_unchecked().s;
assert_eq![S.as_slice(), &[3, 4]];

Source

pub const fn own_swap(self) -> Own<Self, Result<(), NotEnoughElements>>

Swaps the top two stack elements in compile-time.

( 1 2 -- 2 1 )

§Errors

Returns Own<self,NotEnoughElements> if the stack doesn’t contain at least 2 elements.

§Examples

const S: StackUsize<i32, 2> = StackUsize::from_array_copy([1, 2])
    .own_swap().v_assert_ok().s;
assert_eq![S.as_slice(), &[2, 1]];

const T: StackUsize<i32, 1> = StackUsize::from_array_copy([1])
    .own_swap().v_assert_err().s;
assert_eq![T.as_slice(), &[1]];

Source

pub const fn own_swap_unchecked(self) -> Own<Self, ()>

Swaps the top two stack elements in compile-time, unchecked version.

( 1 2 -- 2 1 )

§Panics

Panics if the stack doesn’t contain at least 2 elements.

§Examples

const S: StackUsize<i32, 2> = StackUsize::from_array_copy([1, 2])
    .own_swap_unchecked().s;
assert_eq![S.as_slice(), &[2, 1]];

Source

pub const fn own_swap2(self) -> Own<Self, Result<(), NotEnoughElements>>

Swaps the top two pair stack elements in compile-time.

( 1 2 3 4 -- 3 4 1 2 )

§Errors

Returns Own<self,NotEnoughElements> if the stack doesn’t contain at least 4 elements.

§Examples

const S: StackUsize<i32, 4> = StackUsize::from_array_copy([1, 2, 3, 4])
    .own_swap2().v_assert_ok().s;
assert_eq![S.as_slice(), &[3, 4, 1, 2]];

const T: StackUsize<i32, 3> = StackUsize::from_array_copy([1, 2, 3])
    .own_swap2().v_assert_err().s;
assert_eq![T.as_slice(), &[1, 2, 3]];

Source

pub const fn own_swap2_unchecked(self) -> Own<Self, ()>

Swaps the top two pair stack elements in compile-time, unchecked version.

( 1 2 3 4 -- 3 4 1 2 )

§Panics

Panics if the stack doesn’t contain at least 4 elements.

§Examples

const S: StackUsize<i32, 4> = StackUsize::from_array_copy([1, 2, 3, 4])
    .own_swap2_unchecked().s;
assert_eq![S.as_slice(), &[3, 4, 1, 2]];

Source

pub const fn own_rot(self) -> Own<Self, Result<(), NotEnoughElements>>

Rotates the top three stack elements, clockwise.

( 1 2 3 -- 2 3 1 )

§Errors

Returns Own<self,NotEnoughElements> if the stack doesn’t contain at least 3 elements.

§Examples

const S: StackUsize<i32, 4> = StackUsize::from_array_copy([0, 1, 2, 3])
    .own_rot().v_assert_ok().s;
assert_eq![S.as_slice(), &[0, 2, 3, 1]];

Source

pub const fn own_rot_unchecked(self) -> Own<Self, ()>

Rotates the top three stack elements, clockwise, unchecked version.

( 1 2 3 -- 2 3 1 )

§Panics

Panics if the stack doesn’t contain at least 6 elements. if the stack doesn’t contain at least 3 elements.

§Examples

const S: StackUsize<i32, 4> = StackUsize::from_array_copy([0, 1, 2, 3])
    .own_rot_unchecked().s;
assert_eq![S.as_slice(), &[0, 2, 3, 1]];

Source

pub const fn own_rot_cc(self) -> Own<Self, Result<(), NotEnoughElements>>

Rotates the top three stack elements, counter-clockwise.

( 1 2 3 -- 3 1 2 )

§Errors

Returns Own<S,NotEnoughElements> if the stack doesn’t contain at least 3 elements.

§Examples

const S: StackUsize<i32, 4> = StackUsize::from_array_copy([0, 1, 2, 3])
    .own_rot_cc().v_assert_ok().s;
assert_eq![S.as_slice(), &[0, 3, 1, 2]];

Source

pub const fn own_rot_cc_unchecked(self) -> Own<Self, ()>

Rotates the top three stack elements, counter-clockwise, unchecked version.

( 1 2 3 -- 3 1 2 )

§Errors

Returns Own<S,NotEnoughElements> if the stack doesn’t contain at least 3 elements.

§Examples

const S: StackUsize<i32, 4> = StackUsize::from_array_copy([0, 1, 2, 3])
    .own_rot_cc_unchecked().s;
assert_eq![S.as_slice(), &[0, 3, 1, 2]];

Source

pub const fn own_rot2(self) -> Own<Self, Result<(), NotEnoughElements>>

Rotates the top six stack elements, clockwise, two times.

( 1 2 3 4 5 6 -- 3 4 5 6 1 2 )

§Errors

Returns Own<self,NotEnoughElements> if the stack doesn’t contain at least 6 elements.

§Examples

const S: StackUsize<i32, 7> = StackUsize::from_array_copy([0, 1, 2, 3, 4, 5, 6])
    .own_rot2().v_assert_ok().s;
assert_eq![S.as_slice(), &[0, 3, 4, 5, 6, 1, 2]];

Source

pub const fn own_rot2_unchecked(self) -> Own<Self, ()>

Rotates the top six stack elements, clockwise, two times, unchecked version.

( 1 2 3 4 5 6 -- 3 4 5 6 1 2 )

§Panics

Panics if the stack doesn’t contain at least 6 elements.

§Examples

const S: StackUsize<i32, 7> = StackUsize::from_array_copy([0, 1, 2, 3, 4, 5, 6])
    .own_rot2_unchecked().s;
assert_eq![S.as_slice(), &[0, 3, 4, 5, 6, 1, 2]];

Source

pub const fn own_rot2_cc(self) -> Own<Self, Result<(), NotEnoughElements>>

Rotates the top six stack elements, counter-clockwise, two times.

( 1 2 3 4 5 6 -- 5 6 1 2 3 4 )

§Errors

Returns Own<self,NotEnoughElements> if the stack doesn’t contain at least 6 elements.

§Examples

const S: StackUsize<i32, 7> = StackUsize::from_array_copy([0, 1, 2, 3, 4, 5, 6])
    .own_rot2_cc().v_assert_ok().s;
assert_eq![S.as_slice(), &[0, 5, 6, 1, 2, 3, 4]];

Source

pub const fn own_rot2_cc_unchecked(self) -> Own<Self, ()>

Rotates the top six stack elements, counter-clockwise, two times, unchecked version.

( 1 2 3 4 5 6 -- 5 6 1 2 3 4 )

§Panics

Panics if the stack doesn’t contain at least 6 elements.

§Examples

const S: StackUsize<i32, 7> = StackUsize::from_array_copy([0, 1, 2, 3, 4, 5, 6])
    .own_rot2_cc_unchecked().s;
assert_eq![S.as_slice(), &[0, 5, 6, 1, 2, 3, 4]];

Source

pub const fn own_dup(self) -> Own<Self, Result<(), DataNotEnough>>

Duplicates the top stack element.

( 1 -- 1 1 )

§Errors

Returns Own<self,DataNotEnough::Elements> if the stack is empty or Own<self,DataNotEnough::Space> if the stack is full.

§Examples

const S: StackUsize<i32, 3> = StackUsize::own_new(0).s_const_unwrap().s
    .own_push(1).s.own_dup().v_assert_ok().s;
assert_eq![S.as_slice(), &[1, 1]];

Source

pub const fn own_dup_unchecked(self) -> Own<Self, ()>

Duplicates the top stack element, unchecked version.

( 1 -- 1 1 )

§Panics

Panics if the stack is either empty or full.

§Examples

const S: StackUsize<i32, 3> = StackUsize::own_new(0).s_const_unwrap().s
    .own_push(1).s.own_dup_unchecked().s;
assert_eq![S.as_slice(), &[1, 1]];

Source

pub const fn own_dup2(self) -> Own<Self, Result<(), DataNotEnough>>

Duplicates the top stack pair of elements.

( 1 2 -- 1 2 1 2 )

§Errors

Returns Own<self,DataNotEnough::Elements> if the stack doesn’t have at least 2 elements, or Own<self,DataNotEnough::Space> if it doesn’t have enough space for 2 extra elements.

§Examples

const S: StackUsize<i32, 6> = StackUsize::from_array_copy([0, 1, 2, 0, 0, 0])
    .own_drop_n(3).s.own_dup2().v_assert_ok().s;
assert_eq![S.as_slice(), &[0, 1, 2, 1, 2]];

Source

pub const fn own_dup2_unchecked(self) -> Own<Self, ()>

Duplicates the top stack pair of elements, unchecked version.

( 1 2 -- 1 2 1 2 )

§Panics

Panics if the stack doesn’t have at least 2 elements, or if it doesn’t have enough space for 2 extra elements.

§Examples

const S: StackUsize<i32, 6> = StackUsize::from_array_copy([0, 1, 2, 0, 0, 0])
    .own_drop_n(3).s.own_dup2_unchecked().s;
assert_eq![S.as_slice(), &[0, 1, 2, 1, 2]];

Source

pub const fn own_over(self) -> Own<Self, Result<(), DataNotEnough>>

Duplicates the next of stack element to the top.

( 1 2 -- 1 2 1 )

§Errors

Returns Own<self,DataNotEnough::Elements> if the stack doesn’t have at least 2 elements, or Own<self,DataNotEnough::Space> if it doesn’t have enough space for 2 extra elements.

§Examples

const S: StackUsize<i32, 4> = StackUsize::from_array_copy([0, 1, 2, 0])
    .own_drop().s.own_over().v_assert_ok().s;
assert_eq![S.as_slice(), &[0, 1, 2, 1]];

Source

pub const fn own_over_unchecked(self) -> Own<Self, ()>

Duplicates the next of stack element to the top.

( 1 2 -- 1 2 1 )

§Panics

Panics if the stack doesn’t have at least 2 elements, or if it doesn’t have enough space for 2 extra elements.

§Examples

const S: StackUsize<i32, 4> = StackUsize::from_array_copy([0, 1, 2, 0])
    .own_drop().s.own_over_unchecked().s;
assert_eq![S.as_slice(), &[0, 1, 2, 1]];

Source

pub const fn own_over2(self) -> Own<Self, Result<(), DataNotEnough>>

Duplicates the next of stack pair of elements to the top.

( 1 2 3 4 -- 1 2 3 4 1 2 )

§Errors

Returns Own<self,DataNotEnough::Elements> if the stack doesn’t have at least 4 elements, or Own<self,DataNotEnough::Space> if it doesn’t have enough space for 2 extra elements.

§Examples

const S: StackUsize<i32, 7> = StackUsize::from_array_copy([0, 1, 2, 3, 4, 0, 0])
    .own_drop_n(2).s.own_over2().v_assert_ok().s;
assert_eq![S.as_slice(), &[0, 1, 2, 3, 4, 1, 2]];

Source

pub const fn own_over2_unchecked(self) -> Own<Self, ()>

Duplicates the next of stack pair of elements to the top.

( 1 2 3 4 -- 1 2 3 4 1 2 )

§Panics

Panics if the stack doesn’t have at least 4 elements, or if it doesn’t have enough space for 2 extra elements.

§Examples

const S: StackUsize<i32, 7> = StackUsize::from_array_copy([0, 1, 2, 3, 4, 0, 0])
    .own_drop_n(2).s.own_over2_unchecked().s;
assert_eq![S.as_slice(), &[0, 1, 2, 3, 4, 1, 2]];

Source

pub const fn own_tuck(self) -> Own<Self, Result<(), DataNotEnough>>

Duplicates the top element before the next of stack element.

( 1 2 -- 2 1 2 )

§Errors

Returns Own<self,DataNotEnough::Elements> if the stack doesn’t have at least 2 elements, or Own<self,DataNotEnough::Space> if it doesn’t have enough space for 1 extra elements.

§Examples

const S: StackUsize<i32, 4> = StackUsize::from_array_copy([0, 1, 2, 0])
    .own_drop().s.own_tuck().v_assert_ok().s;
assert_eq![S.as_slice(), &[0, 2, 1, 2]];

Source

pub const fn own_tuck_unchecked(self) -> Own<Self, ()>

Duplicates the top element before the next of stack element, unchecked version.

( 1 2 -- 2 1 2 )

§Panics

Panics if the stack doesn’t have at least 2 elements, or if it doesn’t have enough space for 1 extra elements.

§Examples

const S: StackUsize<i32, 4> = StackUsize::from_array_copy([0, 1, 2, 0])
    .own_drop().s.own_tuck_unchecked().s;
assert_eq![S.as_slice(), &[0, 2, 1, 2]];

Source

pub const fn own_tuck2(self) -> Own<Self, Result<(), DataNotEnough>>

Duplicates the top pair of elements before the next of stack pair of elements.

( 1 2 3 4 -- 3 4 1 2 3 4 )

§Errors

Returns Own<self,DataNotEnough::Elements> if the stack doesn’t have at least 4 elements, or Own<self,DataNotEnough::Space> if it doesn’t have enough space for 2 extra elements.

§Examples

const S: StackUsize<i32, 7> = StackUsize::from_array_copy([0, 1, 2, 3, 4, 0, 0])
    .own_drop_n(2).s.own_tuck2_unchecked().s;
assert_eq![S.as_slice(), &[0, 3, 4, 1, 2, 3, 4]];

Source

pub const fn own_tuck2_unchecked(self) -> Own<Self, ()>

Duplicates the top pair of elements before the next of stack pair of elements, unchecked version.

type Resolver = StackResolver<T, CAP, IDX, S>

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

Source §

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output. Read more

§

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize. Read more

Source §

impl<T: Clone, const CAP: usize, IDX: Copy, S: Storage> Clone for Stack<T, CAP, IDX, S>
where S::Stored<[T; CAP]>: Clone,

Source §

fn clone(&self) -> Self

Returns a copy of the value. Read more

Available on crate feature alloc only.

Source §

fn default() -> Self

Returns an empty stack, allocated in the heap, using the default value to fill the remaining free data.

Source §

This method returns an ordering between self and other values if one exists. Read more

1.0.0 · Source§

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

Tests less than (for self and other) and is used by the < operator. Read more

1.0.0 · Source§

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

Tests less than or equal to (for self and other) and is used by the <= operator. Read more

1.0.0 · Source§

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

Tests greater than (for self and other) and is used by the > operator. Read more

The size of this type in bytes.

Source §

fn byte_align(&self) -> usize ⓘ

Returns the alignment of this type in bytes.

Source §

fn byte_size(&self) -> usize ⓘ

Returns the size of this type in bytes. Read more

Source §

fn ptr_size_ratio(&self) -> [usize; 2]

Returns the size ratio between Ptr::BYTES and BYTE_SIZE. Read more

Source §

impl<T, R> Chain<R> for T
where T: ?Sized,

Source §

fn chain<F>(self, f: F) -> R
where F: FnOnce(Self) -> R, Self: Sized,

Chain a function which takes the parameter by value.

Source §

fn chain_ref<F>(&self, f: F) -> R
where F: FnOnce(&Self) -> R,

Chain a function which takes the parameter by shared reference.

Source §

fn chain_mut<F>(&mut self, f: F) -> R
where F: FnOnce(&mut Self) -> R,

Chain a function which takes the parameter by exclusive reference.

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

§

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

Compare self to key and return true if they are equal.

Source §

Source §

fn from(t: T) -> T

Returns the argument unchanged.

§

fn hook_ref<F>(self, f: F) -> Self
where F: FnOnce(&Self),

Applies a function which takes the parameter by shared reference, and then returns the (possibly) modified owned value. Read more

Source §

fn hook_mut<F>(self, f: F) -> Self
where F: FnOnce(&mut Self),

Applies a function which takes the parameter by exclusive reference, and then returns the (possibly) modified owned value. Read more

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self> ⓘ

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

§

fn in_current_span(self) -> Instrumented<Self> ⓘ

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

§

impl<F, T> IntoSample<T> for F
where T: FromSample<F>,

§

fn into_sample(self) -> T

§

impl<T> LayoutRaw for T

§

fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError> ⓘ

Returns the layout of the type.

§

impl<T, N1, N2> Niching<NichedOption<T, N1>> for N2
where T: SharedNiching<N1, N2>, N1: Niching<T>, N2: Niching<T>,

§

unsafe fn is_niched(niched: *const NichedOption<T, N1>) -> bool

Returns whether the given value has been niched. Read more

§

fn resolve_niched(out: Place<NichedOption<T, N1>>)

Writes data to out indicating that a T is niched.

§

Creates owned data from borrowed data, usually by cloning. Read more

Source §

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

Uses borrowed data to replace owned data, usually by cloning. Read more

§

impl<T, U> ToSample for T
where U: FromSample<T>,

§

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more

§

impl<S, T> Duplex<S> for T
where T: FromSample<S> + ToSample<S>,

§

Struct StackCopy item path

§Methods

Implementations§

impl<T: Default, const CAP: usize> Stack<T, CAP, u8, Bare>

§Stack resize.

pub fn resize_default<const NEW_CAP: usize>( self, ) -> Result<Stack<T, NEW_CAP, u8, Bare>, IndexOutOfBounds> ⓘ

§Errors

§Examples

pub fn resize_default_truncate<const NEW_CAP: usize>( self, ) -> Stack<T, NEW_CAP, u8, Bare>

§Examples

impl<T: Default, const CAP: usize> Stack<T, CAP, u8, Boxed>

pub fn resize_default<const NEW_CAP: usize>( self, ) -> Result<Stack<T, NEW_CAP, u8, Boxed>, IndexOutOfBounds> ⓘ

§Errors

§Examples

pub fn resize_default_truncate<const NEW_CAP: usize>( self, ) -> Stack<T, NEW_CAP, u8, Boxed>

§Examples

impl<T: ConstDefault + Copy, const CAP: usize> Stack<T, CAP, u8, Bare>

pub const fn own_resize_default<const NEW_CAP: usize>( self, ) -> Own<Result<Stack<T, NEW_CAP, u8, Bare>, IndexOutOfBounds>, ()>

§Errors

§Examples

pub const fn own_resize_default_truncate<const NEW_CAP: usize>( self, ) -> Own<Stack<T, NEW_CAP, u8, Bare>, ()>

§Examples

impl<T, const CAP: usize> Stack<T, CAP, u8, Bare>

§Stack index-size conversion.

pub fn to_idx_u8(self) -> Result<Stack<T, CAP, u8, Bare>, NotEnoughSpace> ⓘ

§Errors

§Examples

pub fn to_idx_u16(self) -> Result<Stack<T, CAP, u16, Bare>, NotEnoughSpace> ⓘ

§Errors

§Examples

pub fn to_idx_u32(self) -> Result<Stack<T, CAP, u32, Bare>, NotEnoughSpace> ⓘ

§Errors

§Examples

pub fn to_idx_usize(self) -> Result<Stack<T, CAP, usize, Bare>, NotEnoughSpace> ⓘ

§Errors

§Examples

impl<T, const CAP: usize> Stack<T, CAP, u8, Boxed>

pub fn to_idx_u8(self) -> Result<Stack<T, CAP, u8, Boxed>, NotEnoughSpace> ⓘ

§Errors

§Examples

pub fn to_idx_u16(self) -> Result<Stack<T, CAP, u16, Boxed>, NotEnoughSpace> ⓘ

§Errors

§Examples

pub fn to_idx_u32(self) -> Result<Stack<T, CAP, u32, Boxed>, NotEnoughSpace> ⓘ

§Errors

§Examples

pub fn to_idx_usize(self) -> Result<Stack<T, CAP, usize, Boxed>, NotEnoughSpace> ⓘ

§Errors

§Examples

impl<T: Copy, const CAP: usize> Stack<T, CAP, u8, Bare>

pub const fn own_to_idx_u8( self, ) -> Own<Result<Stack<T, CAP, u8, Bare>, NotEnoughSpace>, ()>

§Errors

§Examples

pub const fn own_to_idx_u16( self, ) -> Own<Result<Stack<T, CAP, u16, Bare>, NotEnoughSpace>, ()>

§Errors

§Examples

pub const fn own_to_idx_u32( self, ) -> Own<Result<Stack<T, CAP, u32, Bare>, NotEnoughSpace>, ()>

§Errors

§Examples

pub const fn own_to_idx_usize( self, ) -> Own<Result<Stack<T, CAP, usize, Bare>, NotEnoughSpace>, ()>

§Errors

§Examples

impl<T: Default, const CAP: usize> Stack<T, CAP, u16, Bare>

§Stack resize.

pub fn resize_default<const NEW_CAP: usize>( self, ) -> Result<Stack<T, NEW_CAP, u16, Bare>, IndexOutOfBounds> ⓘ

§Errors

§Examples

pub fn resize_default_truncate<const NEW_CAP: usize>( self, ) -> Stack<T, NEW_CAP, u16, Bare>

§Examples

impl<T: Default, const CAP: usize> Stack<T, CAP, u16, Boxed>

pub fn resize_default<const NEW_CAP: usize>( self, ) -> Result<Stack<T, NEW_CAP, u16, Boxed>, IndexOutOfBounds> ⓘ

§Errors

§Examples

pub fn resize_default_truncate<const NEW_CAP: usize>( self, ) -> Stack<T, NEW_CAP, u16, Boxed>

§Examples

impl<T: ConstDefault + Copy, const CAP: usize> Stack<T, CAP, u16, Bare>

pub const fn own_resize_default<const NEW_CAP: usize>( self, ) -> Own<Result<Stack<T, NEW_CAP, u16, Bare>, IndexOutOfBounds>, ()>

§Errors

§Examples

pub const fn own_resize_default_truncate<const NEW_CAP: usize>( self, ) -> Own<Stack<T, NEW_CAP, u16, Bare>, ()>

Struct Stack