Struct ArrayList 

pub struct ArrayList<T, const N: usize>
where
    Usize<N>: ChunkCapacity,
{ /* private fields */ }

A dynamic container that combines the characteristics of a Vec and a LinkedList.

Features

• Chunked Storage: Each chunk can hold up to N elements, reducing the overhead of individual allocations compared to a traditional linked list.
• Flexible Operations: Index based lookups and efficient insertions, deletions, and access at arbitrary positions.

Type Parameters

• T: The type of elements stored in the list.
• N: The maximum number of elements that each chunk can hold.

Example

use array_list::ArrayList;

let mut list: ArrayList<i64, 6> = ArrayList::new();
list.push_back(3);
list.push_front(1);
list.insert(1, 2);

assert!(!list.is_empty());
assert_eq!(list.len(), 3);

assert_eq!(list.pop_front(), Some(1));
assert_eq!(list.pop_front(), Some(2));
assert_eq!(list.pop_front(), Some(3));

Implementations

impl<T, const N: usize> ArrayList<T, N>

where Usize<N>: ChunkCapacity,

pub const fn new() -> Self

Creates a new, empty ArrayList with no elements and no allocated chunks.

Example

use array_list::ArrayList;

let list: ArrayList<i64, 6> = ArrayList::new();

assert!(list.is_empty());

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

Adds an element to the front of the ArrayList.

The element is inserted at the beginning of the list, shifting existing elements forward if necessary. If the first chunk is full, a new one will be allocated to accommodate the element.

Example

use array_list::ArrayList;

let mut list: ArrayList<i64, 6> = ArrayList::new();
list.push_front(10);
list.push_front(20);

assert_eq!(list.len(), 2);

assert_eq!(list.pop_front(), Some(20));
assert_eq!(list.pop_front(), Some(10));

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

Adds an element to the back of the ArrayList.

The element is inserted at the end of the list. If the last chunk is full, a new one will be allocated to accommodate the element.

Example

use array_list::ArrayList;

let mut list: ArrayList<i64, 6> = ArrayList::new();
list.push_back(10);
list.push_back(20);

assert_eq!(list.len(), 2);

assert_eq!(list.pop_back(), Some(20));
assert_eq!(list.pop_back(), Some(10));

pub fn insert(&mut self, index: usize, value: T)

Inserts an element at the specified index, shifting subsequent elements to the right. If the target chunk is full, a new one will be allocated to accommodate the element.

Panics

• Panics if the index is out of bounds (greater than the list’s current length).

Examples

use array_list::ArrayList;

let mut list: ArrayList<i64, 3> = ArrayList::new();
list.push_back(10);
list.push_back(30);
list.insert(1, 20);

assert_eq!(list.get(0), Some(&10));
assert_eq!(list.get(1), Some(&20));
assert_eq!(list.get(2), Some(&30));

pub fn append(&mut self, other: &mut Self)

Moves all elements from the other list to the end of this one.

This reuses all the chunks from other list and moves them into self. After this operation, other becomes empty.

Example

use array_list::ArrayList;

let mut list1: ArrayList<i32, 4> = ArrayList::new();
list1.push_back(1);
list1.push_back(2);

let mut list2: ArrayList<i32, 4> = ArrayList::new();
list2.push_back(3);
list2.push_back(4);

list1.append(&mut list2);

assert_eq!(list1.len(), 4);
assert_eq!(list1.get(0), Some(&1));
assert_eq!(list1.get(1), Some(&2));
assert_eq!(list1.get(2), Some(&3));
assert_eq!(list1.get(3), Some(&4));

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

Removes and returns the first element of the ArrayList, if any. If the list is empty, it returns None.

Examples

use array_list::ArrayList;

let mut list: ArrayList<i64, 4> = ArrayList::new();
list.push_front(10);
list.push_front(20);

assert_eq!(list.pop_front(), Some(20));
assert_eq!(list.pop_front(), Some(10));
assert_eq!(list.pop_front(), None);

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

Removes and returns the last element of the ArrayList, if any. If the list is empty, it returns None.

Examples

use array_list::ArrayList;

let mut list: ArrayList<i64, 4> = ArrayList::new();
list.push_back(10);
list.push_back(20);

assert_eq!(list.pop_back(), Some(20));
assert_eq!(list.pop_back(), Some(10));
assert_eq!(list.pop_back(), None);

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

Removes and returns the element at the specified index, shifting subsequent elements left.

Examples

use array_list::ArrayList;

let mut list: ArrayList<i64, 4> = ArrayList::new();
list.push_back(10);
list.push_back(20);
list.push_back(30);
list.push_back(40);
list.push_back(50);

assert_eq!(list.remove(1), Some(20));
assert_eq!(list.get(1), Some(&30));
assert_eq!(list.len(), 4);


assert_eq!(list.remove(10), None);

pub fn clear(&mut self)

Removes all elements from the ArrayList, effectively making it empty.

Example

use array_list::ArrayList;

let mut list: ArrayList<i32, 4> = ArrayList::new();
list.push_back(1);
list.push_back(2);
list.push_back(3);

assert_eq!(list.len(), 3);

list.clear();

assert_eq!(list.len(), 0);
assert!(list.is_empty());
assert_eq!(list.front(), None);
assert_eq!(list.back(), None);

pub fn front(&self) -> Option<&T>

Returns a reference to the first element of the ArrayList, if any.

Examples

use array_list::ArrayList;

let mut list: ArrayList<i64, 4> = ArrayList::new();
list.push_back(10);
list.push_back(20);

assert_eq!(list.front(), Some(&10));

list.pop_front();
assert_eq!(list.front(), Some(&20));

list.pop_front();
assert_eq!(list.front(), None);

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

Returns a mutable reference to the first element of the ArrayList, if any.

Examples

use array_list::ArrayList;

let mut list: ArrayList<i64, 4> = ArrayList::new();
list.push_back(10);
list.push_back(20);

assert_eq!(list.front_mut(), Some(&mut 10));

list.pop_front();
assert_eq!(list.front_mut(), Some(&mut 20));

list.pop_front();
assert_eq!(list.front_mut(), None);

pub fn back(&self) -> Option<&T>

Returns a reference to the last element of the ArrayList, if any.

Examples

use array_list::ArrayList;

let mut list: ArrayList<i64, 4> = ArrayList::new();
list.push_back(10);
list.push_back(20);

assert_eq!(list.back(), Some(&20));

list.pop_back();
assert_eq!(list.back(), Some(&10));

list.pop_back();
assert_eq!(list.back(), None);

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

Returns a mutable reference to the last element of the ArrayList, if any.

Examples

use array_list::ArrayList;

let mut list: ArrayList<i64, 4> = ArrayList::new();
list.push_back(10);
list.push_back(20);

assert_eq!(list.back_mut(), Some(&mut 20));

list.pop_back();
assert_eq!(list.back_mut(), Some(&mut 10));

list.pop_back();
assert_eq!(list.back_mut(), None);

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

Returns a reference to the element at the specified index, if any.

Examples

use array_list::ArrayList;

let mut list: ArrayList<i64, 4> = ArrayList::new();
list.push_back(10);
list.push_back(20);

assert_eq!(list.get(0), Some(&10));
assert_eq!(list.get(1), Some(&20));
assert_eq!(list.get(2), None); // Out of bounds

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

Returns a mutable reference to the element at the specified index, if any.

Examples

use array_list::ArrayList;

let mut list: ArrayList<i64, 4> = ArrayList::new();
list.push_back(10);
list.push_back(20);

assert_eq!(list.get_mut(0), Some(&mut 10));
assert_eq!(list.get_mut(1), Some(&mut 20));
assert_eq!(list.get_mut(2), None); // Out of bounds

pub const fn len(&self) -> usize

Returns the number of elements currently stored in the ArrayList.

Example

use array_list::ArrayList;

let mut list: ArrayList<i64, 6> = ArrayList::new();
list.push_back(1);
list.push_back(2);

assert_eq!(list.len(), 2);

pub const fn is_empty(&self) -> bool

Checks if the ArrayList is empty.

Example

use array_list::ArrayList;

let mut list: ArrayList<i64, 6> = ArrayList::new();
assert!(list.is_empty());

list.push_back(1);
assert!(!list.is_empty());

pub fn iter(&self) -> Iter<'_, T, N>

Provides an iterator over list’s elements.

Examples

use array_list::ArrayList;

let mut list: ArrayList<_, 2> = ArrayList::new();
list.push_back(0);
list.push_back(1);
list.push_back(2);

let mut iter = list.iter();
assert_eq!(iter.next(), Some(&0));
assert_eq!(iter.next(), Some(&1));
assert_eq!(iter.next(), Some(&2));
assert_eq!(iter.next(), None);

pub fn iter_mut(&mut self) -> IterMut<'_, T, N>

Provides a mutable iterator over list’s elements.

Examples

use array_list::ArrayList;

let mut list: ArrayList<_, 2> = ArrayList::new();
list.push_back(0);
list.push_back(1);
list.push_back(2);

let mut iter = list.iter();
assert_eq!(iter.next(), Some(&0));
assert_eq!(iter.next(), Some(&1));
assert_eq!(iter.next(), Some(&2));
assert_eq!(iter.next(), None);

pub fn cursor_front(&self) -> Cursor<'_, T, N>

Provides a cursor at the front element.

The cursor is pointing to the “ghost” non-element if the list is empty.

pub fn cursor_back(&self) -> Cursor<'_, T, N>

Provides a cursor at the back element.

The cursor is pointing to the “ghost” non-element if the list is empty.

pub fn cursor_front_mut(&mut self) -> CursorMut<'_, T, N>

Provides a cursor at the front element.

The cursor is pointing to the “ghost” non-element if the list is empty.

pub fn cursor_back_mut(&mut self) -> CursorMut<'_, T, N>

Provides a cursor at the back element.

The cursor is pointing to the “ghost” non-element if the list is empty.

Trait Implementations

impl<T: Clone, const N: usize> Clone for ArrayList<T, N>

where Usize<N>: ChunkCapacity,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, const N: usize> Debug for ArrayList<T, N>

where T: Debug, Usize<N>: ChunkCapacity,

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

Formats the value using the given formatter.

impl<T, const N: usize> Default for ArrayList<T, N>

where Usize<N>: ChunkCapacity,

fn default() -> Self

Returns the “default value” for a type.

impl<'a, T, const N: usize> Extend<&'a T> for ArrayList<T, N>

where T: Clone, Usize<N>: ChunkCapacity,

fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<T, const N: usize> Extend<T> for ArrayList<T, N>

where Usize<N>: ChunkCapacity,

fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

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

where Usize<N>: ChunkCapacity,

fn from(values: [T; M]) -> Self

Converts to this type from the input type.

impl<T, const N: usize> FromIterator<T> for ArrayList<T, N>

where Usize<N>: ChunkCapacity,

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

Creates a value from an iterator.

impl<T, const N: usize> Hash for ArrayList<T, N>

where T: Hash, Usize<N>: ChunkCapacity,

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a, T, const N: usize> IntoIterator for &'a ArrayList<T, N>

where Usize<N>: ChunkCapacity,

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T, N>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a mut ArrayList<T, N>

where Usize<N>: ChunkCapacity,

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T, N>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, const N: usize> IntoIterator for ArrayList<T, N>

where Usize<N>: ChunkCapacity,

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, N>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, const N: usize> Ord for ArrayList<T, N>

where T: Ord, Usize<N>: ChunkCapacity,

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T, const N: usize> PartialEq<&[T]> for ArrayList<T, N>

where T: PartialEq, Usize<N>: ChunkCapacity,

fn eq(&self, other: &&[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, const N: usize> PartialEq<[T]> for ArrayList<T, N>

where T: PartialEq, Usize<N>: ChunkCapacity,

fn eq(&self, other: &[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, const N: usize, const M: usize> PartialEq<[T; M]> for ArrayList<T, N>

where T: PartialEq, Usize<N>: ChunkCapacity,

fn eq(&self, other: &[T; M]) -> 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, const N: usize> PartialEq for ArrayList<T, N>

where T: PartialEq, Usize<N>: ChunkCapacity,

fn eq(&self, other: &Self) -> 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, const N: usize> PartialOrd for ArrayList<T, N>

where T: PartialOrd, Usize<N>: ChunkCapacity,

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, const N: usize> Eq for ArrayList<T, N>

where T: Eq, Usize<N>: ChunkCapacity,