Struct Stack

pub struct Stack<T>(/* private fields */);

A growable stack implementing push/pop actions.

use ripin::Stack;

let mut stack = Stack::new();

stack.push(3);
stack.push(4);
stack.push(10);
assert_eq!(stack.len(), 3);

assert_eq!(stack.pop(), Some(10));
assert_eq!(stack.len(), 2);

Implementations

impl<T> Stack<T>

pub fn new() -> Stack<T>

Creates an empty VecDeque.

Examples

use ripin::Stack;

let mut stack: Stack<i32> = Stack::new();

pub fn with_capacity(capacity: usize) -> Stack<T>

Creates an empty VecDeque with space for at least n elements.

Examples

use ripin::Stack;

let mut stack: Stack<i32> = Stack::with_capacity(10);

pub fn len(&self) -> usize

Returns the number of elements in the set.

Examples

use ripin::Stack;

let mut stack = Stack::new();
stack.push(3);
assert_eq!(stack.len(), 1);

pub fn is_empty(&self) -> bool

Returns true if the set contains no elements.

Examples

use ripin::Stack;

let mut stack = Stack::new();
assert_eq!(stack.is_empty(), true);
stack.push(3);
assert_eq!(stack.is_empty(), false);

pub fn push(&mut self, value: T)

Appends an element to the back of the stack.

Panics

Panics if the number of elements in the stack overflows a usize.

Examples

use ripin::Stack;

let mut stack = Stack::new();
stack.push(3);
assert_eq!(stack.pop(), Some(3));
assert_eq!(stack.pop(), None);

Examples found in repository

examples/custom_expression.rs (line 98)

    fn evaluate(self, stack: &mut Stack<MyOperand>) -> Result<(), Self::Err> {
        let (a, b) = pop_two_operands(stack).ok_or(MyEvalErr::NotEnoughOperands)?;
        match self {
            MyEvaluator::Add => {
                match (a, b) {
                    (MyOperand::Number1, MyOperand::Number1) => {
                        Ok(stack.push(MyOperand::Number2))
                    },
                    _ => Err(MyEvalErr::CannotAddOperands(a, b)),
                }
            },
            MyEvaluator::Sub => {
                match (a, b) {
                    (MyOperand::Number2, MyOperand::Number1) => {
                        Ok(stack.push(MyOperand::Number1))
                    },
                    _ => Err(MyEvalErr::CannotSubOperands(a, b)),
                }
            }
            _ => unreachable!() // _Phantom
        }
    }

pub fn pop(&mut self) -> Option<T>

Removes the last element from the stack and returns it, or None if it is empty.

Examples

use ripin::Stack;

let mut stack = Stack::new();
stack.push(3);
stack.push(2);
assert_eq!(stack.pop(), Some(2));
assert_eq!(stack.pop(), Some(3));
assert_eq!(stack.pop(), None);