Struct VList

pub struct VList<T> { /* private fields */ }

A dynamic array implementation backed by a VList.

Example

use rust_dsa::VList;

// First, we create a new list.
let mut list = VList::new();

// Then we can push values.
list.push(4);
list.push(1);
list.push(3);

// We can get values.
assert_eq!(list.get(0), Some(&4));
assert_eq!(list.get(1), Some(&1));
assert_eq!(list.last(), Some(&3));

// And pop from them off.
assert_eq!(list.pop(), Some(3));
assert_eq!(list.pop(), Some(1));
assert_eq!(list.pop(), Some(4));

assert!(list.is_empty());

// We can also crate lists from arrays.
let list_a = VList::from(['v', 'l', 'i', 's', 't']);

// And iterators.
let list_b: VList<_> = "vlist".chars().collect();

// We can iterate over a list.
for (a, b) in std::iter::zip(list_a, list_b) {
    assert_eq!(a, b);
}

Implementations

impl<T> VList<T>

pub fn new() -> VList<T>

Creates an empty list.

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

Pushes a value onto the end of the list.

Example

use rust_dsa::VList;

let mut list = VList::new();

list.push(5);

assert_eq!(list.last(), Some(&5));

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

Removes and returns the value at the end of the list, or None if the list is empty.

Example

use rust_dsa::VList;

let mut list = VList::new();

list.push(5);

assert_eq!(list.pop(), Some(5));
assert_eq!(list.pop(), None);

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

Returns a reference to value at the end of the list, or None if the list is empty.

Example

use rust_dsa::VList;

let mut list = VList::from([5]);

assert_eq!(list.last(), Some(&5));

list.pop();

assert_eq!(list.last(), None);

pub fn get(&self, index: usize) -> Option<&T>

Returns a reference to the value at position index if one exists.

Example

use rust_dsa::VList;

let list = VList::from(['a', 'b', 'c', 'd']);

assert_eq!(list.get(0), Some(&'a'));
assert_eq!(list.get(1), Some(&'b'));
assert_eq!(list.get(2), Some(&'c'));
assert_eq!(list.get(3), Some(&'d'));
assert_eq!(list.get(4), None);

pub fn len(&self) -> usize

Returns the length of the list.

Example

use rust_dsa::VList;

let full: VList<_> = (0..10).collect();
assert_eq!(full.len(), 10);

let empty: VList<i32> = VList::new();
assert_eq!(empty.len(), 0);

pub fn is_empty(&self) -> bool

Returns true if the list is empty.

Example

use rust_dsa::VList;

let mut list = VList::from([5, 6, 4, 2, 8]);

assert!(!list.is_empty());

list.clear();

assert!(list.is_empty());

pub fn clear(&mut self)

Clears the list.

Example

use rust_dsa::VList;

let mut list = VList::from([5, 6, 4, 2, 8]);

assert!(!list.is_empty());

list.clear();

assert!(list.is_empty());

Trait Implementations

impl<T: Clone> Clone for VList<T>

fn clone(&self) -> VList<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for VList<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for VList<T>

fn default() -> VList<T>

Returns the “default value” for a type.

impl<T, const N: usize> From<[T; N]> for VList<T>

fn from(array: [T; N]) -> VList<T>

Converts to this type from the input type.

impl<T> FromIterator<T> for VList<T>

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> VList<T>

Example

use rust_dsa::VList;

let mut ints: VList<_> = (0..100_000).collect();

for i in (0..100_000).rev() {
    assert_eq!(ints.get(i), Some(&i));
    assert_eq!(ints.pop(), Some(i));
}

impl<'a, T> IntoIterator for &'a VList<T>

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

type Item = &'a T

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> IntoIterator for VList<T>

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

type Item = T

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> PartialEq for VList<T>

where T: PartialEq,

fn eq(&self, other: &VList<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Eq> Eq for VList<T>