Trait Array 

pub trait Array<T> {
    // Required methods
    fn at(&self, index: usize) -> Option<&T>;
    fn concat(&self, other: impl AsRef<[T]>) -> Vec<T>
       where T: Clone;
    fn entries<'a>(&'a self) -> impl Iterator<Item = (usize, &'a T)>
       where T: 'a;
    fn every(&self, predicate: impl FnMut(&T) -> bool) -> bool;
    fn find(&self, predicate: impl FnMut(&T) -> bool) -> Option<&T>;
    fn find_index(&self, predicate: impl FnMut(&T) -> bool) -> Option<usize>;
    fn find_last(&self, predicate: impl FnMut(&T) -> bool) -> Option<&T>;
    fn find_last_index(
        &self,
        predicate: impl FnMut(&T) -> bool,
    ) -> Option<usize>;
    fn filter(&self, predicate: impl FnMut(&T) -> bool) -> Vec<T>
       where T: Clone;
    fn flat(&self) -> Vec<T::Item>
       where T: Clone + IntoIterator;
    fn flat_map<O, I>(&self, mapper: impl FnMut(&T) -> I) -> Vec<O>
       where I: IntoIterator<Item = O>;
    fn for_each(&self, cb: impl FnMut(&T));
    fn includes(&self, value: &T) -> bool
       where T: PartialEq;
    fn index_of(&self, value: &T) -> Option<usize>
       where T: PartialEq;
    fn is_empty(&self) -> bool;
    fn join(&self, separator: &str) -> Result<String, Error>
       where T: Display;
    fn keys(&self) -> impl Iterator<Item = usize>;
    fn last_index_of(&self, value: &T) -> Option<usize>
       where T: PartialEq;
    fn len(&self) -> usize;
    fn map<O>(&self, mapper: impl FnMut(&T) -> O) -> Vec<O>;
    fn reduce<O>(&self, reducer: impl FnMut(O, &T) -> O, initial: O) -> O;
    fn reduce_right<O>(&self, reducer: impl FnMut(O, &T) -> O, initial: O) -> O;
    fn slice(&self, start: usize, end: Option<usize>) -> &[T];
    fn some(&self, predicate: impl FnMut(&T) -> bool) -> bool;
    fn subarray<const S: usize>(&self, index: usize) -> &[T; S];
    fn subarray_checked<const S: usize>(&self, index: usize) -> Option<&[T; S]>;
    unsafe fn subarray_unchecked<const S: usize>(&self, index: usize) -> &[T; S];
    fn values<'a>(&'a self) -> impl Iterator<Item = &'a T>
       where T: 'a;
}

Required Methods

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

Returns a reference to the element at the specified index, or None if the index is out of bounds.

Examples

use ps_util::Array;
let arr = [1, 2, 3];
assert_eq!(arr.at(0), Some(&1));
assert_eq!(arr.at(5), None);

fn concat(&self, other: impl AsRef<[T]>) -> Vec<T>

where T: Clone,

Concatenates this array with another slice and returns a new vector.

Examples

use ps_util::Array;
let arr = [1, 2];
let result = arr.concat(&[3, 4]);
assert_eq!(result, vec![1, 2, 3, 4]);

fn entries<'a>(&'a self) -> impl Iterator<Item = (usize, &'a T)>

where T: 'a,

Returns an iterator of (index, &T) tuples for each element.

Examples

use ps_util::Array;
let arr = ['a', 'b'];
let entries: Vec<_> = arr.entries().collect();
assert_eq!(entries, vec![(0, &'a'), (1, &'b')]);

fn every(&self, predicate: impl FnMut(&T) -> bool) -> bool

Tests whether all elements match the predicate.

Returns true if the predicate returns true for every element, or if the array is empty.

Examples

use ps_util::Array;
let arr = [2, 4, 6];
assert!(arr.every(|x| x % 2 == 0));
assert!(!arr.every(|x| x > &5));

fn find(&self, predicate: impl FnMut(&T) -> bool) -> Option<&T>

Returns a reference to the first element that matches the predicate.

Examples

use ps_util::Array;
let arr = [1, 2, 3, 4];
assert_eq!(arr.find(|x| x > &2), Some(&3));
assert_eq!(arr.find(|x| x > &10), None);

fn find_index(&self, predicate: impl FnMut(&T) -> bool) -> Option<usize>

Returns the index of the first element that matches the predicate.

Examples

use ps_util::Array;
let arr = [1, 2, 3, 4];
assert_eq!(arr.find_index(|x| x > &2), Some(2));
assert_eq!(arr.find_index(|x| x > &10), None);

fn find_last(&self, predicate: impl FnMut(&T) -> bool) -> Option<&T>

Returns a reference to the last element that matches the predicate.

Examples

use ps_util::Array;
let arr = [1, 2, 3, 4];
assert_eq!(arr.find_last(|x| x < &4), Some(&3));
assert_eq!(arr.find_last(|x| x > &10), None);

fn find_last_index(&self, predicate: impl FnMut(&T) -> bool) -> Option<usize>

Returns the index of the last element that matches the predicate.

Examples

use ps_util::Array;
let arr = [1, 2, 3, 4];
assert_eq!(arr.find_last_index(|x| x < &4), Some(2));
assert_eq!(arr.find_last_index(|x| x > &10), None);

fn filter(&self, predicate: impl FnMut(&T) -> bool) -> Vec<T>

where T: Clone,

Returns a vector containing all elements that match the predicate.

Examples

use ps_util::Array;
let arr = [1, 2, 3, 4];
assert_eq!(arr.filter(|x| x % 2 == 0), vec![2, 4]);

fn flat(&self) -> Vec<T::Item>

where T: Clone + IntoIterator,

Flattens a level of nesting in an array of iterables.

Examples

use ps_util::Array;
let arr = [vec![1, 2], vec![3, 4]];
assert_eq!(arr.flat(), vec![1, 2, 3, 4]);

fn flat_map<O, I>(&self, mapper: impl FnMut(&T) -> I) -> Vec<O>

where I: IntoIterator<Item = O>,

Maps each element to an iterable and flattens the result.

Examples

use ps_util::Array;
let arr = [1, 2, 3];
let result = arr.flat_map(|x| vec![*x, *x * 2]);
assert_eq!(result, vec![1, 2, 2, 4, 3, 6]);

fn for_each(&self, cb: impl FnMut(&T))

Applies a closure to each element for side effects.

Examples

use ps_util::Array;
let arr = [1, 2, 3];
arr.for_each(|x| println!("{}", x));

fn includes(&self, value: &T) -> bool

where T: PartialEq,

Checks whether the array contains the specified value.

Examples

use ps_util::Array;
let arr = [1, 2, 3];
assert!(arr.includes(&2));
assert!(!arr.includes(&5));

fn index_of(&self, value: &T) -> Option<usize>

where T: PartialEq,

Returns the index of the first occurrence of the specified value, or None if not found.

Examples

use ps_util::Array;
let arr = [1, 2, 3, 2];
assert_eq!(arr.index_of(&2), Some(1));
assert_eq!(arr.index_of(&5), None);

fn is_empty(&self) -> bool

Returns true if the array is empty.

Examples

use ps_util::Array;
assert!(Vec::<i32>::new().is_empty());
assert!(![1].is_empty());

fn join(&self, separator: &str) -> Result<String, Error>

where T: Display,

Concatenates all elements into a string, separated by the given separator.

Errors

Errors are passed from the std::fmt::Display implementation.

Examples

use ps_util::Array;
let arr = [1, 2, 3];
assert_eq!(arr.join(", ").unwrap(), "1, 2, 3");

fn keys(&self) -> impl Iterator<Item = usize>

Returns an iterator of indices (0, 1, 2, …).

Examples

use ps_util::Array;
let arr = ['a', 'b', 'c'];
let keys: Vec<_> = arr.keys().collect();
assert_eq!(keys, vec![0, 1, 2]);

fn last_index_of(&self, value: &T) -> Option<usize>

where T: PartialEq,

Returns the index of the last occurrence of the specified value, or None if not found.

Examples

use ps_util::Array;
let arr = [1, 2, 3, 2];
assert_eq!(arr.last_index_of(&2), Some(3));
assert_eq!(arr.last_index_of(&5), None);

fn len(&self) -> usize

Returns the number of elements in the array.

Examples

use ps_util::Array;
let arr = [1, 2, 3];
assert_eq!(arr.len(), 3);

fn map<O>(&self, mapper: impl FnMut(&T) -> O) -> Vec<O>

Transforms each element using the provided mapper function and returns a vector of the results.

Examples

use ps_util::Array;
let arr = [1, 2, 3u8];
assert_eq!(arr.as_slice().map(|x| x * 2), vec![2, 4, 6]);

fn reduce<O>(&self, reducer: impl FnMut(O, &T) -> O, initial: O) -> O

Reduces the array to a single value by applying a callback with an accumulator, starting from the left.

Examples

use ps_util::Array;
let arr = [1, 2, 3, 4];
let sum = arr.reduce(|acc, x| acc + x, 0);
assert_eq!(sum, 10);

fn reduce_right<O>(&self, reducer: impl FnMut(O, &T) -> O, initial: O) -> O

Reduces the array to a single value by applying a callback with an accumulator, starting from the right.

Examples

use ps_util::Array;
let arr = [1, 2, 3];
let result = arr.reduce_right(
    |acc, x| format!("{}{}", acc, x),
    String::new()
);
assert_eq!(result, "321");

fn slice(&self, start: usize, end: Option<usize>) -> &[T]

Returns a slice of the array from start to end (exclusive).

If end is None, slices to the end of the array. Indices are clamped to valid bounds; if start exceeds the array length, an empty slice is returned.

Examples

use ps_util::Array;
let arr = [1, 2, 3, 4];
assert_eq!(arr.slice(1, Some(3)), &[2, 3][..]);
assert_eq!(arr.slice(2, None), &[3, 4][..]);
assert_eq!(arr.slice(10, Some(20)), &[][..]);

fn some(&self, predicate: impl FnMut(&T) -> bool) -> bool

Tests whether any element matches the predicate.

Returns true if the predicate returns true for at least one element.

Examples

use ps_util::Array;
let arr = [1, 2, 3];
assert!(arr.some(|x| x > &2));
assert!(!arr.some(|x| x > &10));

fn subarray<const S: usize>(&self, index: usize) -> &[T; S]

Returns a fixed-size array reference starting at the given index.

Panics

Panics if there are not enough elements remaining in the array.

Examples

use ps_util::Array;
let arr = [1, 2, 3, 4];
assert_eq!(arr.subarray::<2>(1), &[2, 3]);

fn subarray_checked<const S: usize>(&self, index: usize) -> Option<&[T; S]>

Checked version of subarray. Returns None if bounds are exceeded.

Examples

use ps_util::Array;
let arr = [1, 2, 3];
assert_eq!(arr.subarray_checked::<2>(1), Some(&[2, 3]));
assert_eq!(arr.subarray_checked::<2>(2), None);

unsafe fn subarray_unchecked<const S: usize>(&self, index: usize) -> &[T; S]

Unchecked version of subarray. Undefined behavior if bounds are exceeded.

Safety

Caller must ensure that index + S <= self.len().

Examples

use ps_util::Array;
let arr = [1, 2, 3, 4];
unsafe {
    assert_eq!(arr.subarray_unchecked::<2>(1), &[2, 3]);
}

fn values<'a>(&'a self) -> impl Iterator<Item = &'a T>

where T: 'a,

Returns an iterator over references to the elements.

Examples

use ps_util::Array;
let arr = [1, 2, 3];
let values: Vec<_> = arr.values().collect();
assert_eq!(values, vec![&1, &2, &3]);

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<A, T> Array<T> for A

where A: AsRef<[T]>,