Trait slice_ops::SliceOps

source ·

pub trait SliceOps<T>: Slice<Item = T> {
    // Required methods
    fn split_len(&self, mid: usize) -> (usize, usize);
    fn rsplit_len(&self, mid: usize) -> (usize, usize);
    fn rsplit_at(&self, mid: usize) -> (&[T], &[T]);
    fn rsplit_at_mut(&mut self, mid: usize) -> (&mut [T], &mut [T]);
    fn split_array_ref2<const N: usize>(&self) -> (&[T; N], &[T]);
    fn split_array_mut2<const N: usize>(&mut self) -> (&mut [T; N], &mut [T]);
    fn rsplit_array_ref2<const N: usize>(&self) -> (&[T], &[T; N]);
    fn rsplit_array_mut2<const N: usize>(&mut self) -> (&mut [T], &mut [T; N]);
    fn spread_ref<const M: usize>(&self) -> [&[Padded<T, M>]; M];
    fn spread_mut<const M: usize>(&mut self) -> [&mut [Padded<T, M>]; M];
}

Required Methods§

source

fn split_array_ref2<const N: usize>(&self) -> (&[T; N], &[T])

Does the exact same as the method in the standard library in an identical way, but can be done at compile-time.

Divides one slice into an array and a remainder slice at an index.

The array will contain all indices from [0, N) (excluding the index N itself) and the slice will contain all indices from [N, len) (excluding the index len itself).

§Panics

Panics if N > len.

§Examples

#![feature(split_array)]
#![feature(const_slice_index)]
 
const V: [u8; 6] = [1, 2, 3, 4, 5, 6];

{
    const SPLIT: (&[u8; 0], &[u8]) = slice_ops::split_array_ref(V.as_slice());
    assert_eq!(SPLIT.0, &[]);
    assert_eq!(SPLIT.1, [1, 2, 3, 4, 5, 6]);
    assert_eq!(SPLIT, V.split_array_ref::<0>());
}

{
    const SPLIT: (&[u8; 2], &[u8]) = slice_ops::split_array_ref(V.as_slice());
    assert_eq!(SPLIT.0, &[1, 2]);
    assert_eq!(SPLIT.1, [3, 4, 5, 6]);
    assert_eq!(SPLIT, V.split_array_ref::<2>());
}

{
    const SPLIT: (&[u8; 6], &[u8]) = slice_ops::split_array_ref(V.as_slice());
    assert_eq!(SPLIT.0, &[1, 2, 3, 4, 5, 6]);
    assert_eq!(SPLIT.1, []);
    assert_eq!(SPLIT, V.split_array_ref::<6>());
}

source

fn split_array_mut2<const N: usize>(&mut self) -> (&mut [T; N], &mut [T])

source

fn rsplit_array_ref2<const N: usize>(&self) -> (&[T], &[T; N])

source

fn rsplit_array_mut2<const N: usize>(&mut self) -> (&mut [T], &mut [T; N])

source

fn spread_ref<const M: usize>(&self) -> [&[Padded<T, M>]; M]

Spreads elements equally across M slices. Slices will have equal length only if the operand slice’s length is divisible by M.

§Examples

Take, for instance, that we want to divide a slice into odd and even elements:

use slice_ops::SliceOps;
 
let arr = [1, 2, 3];
let slice = arr.as_slice();
 
let [odd, even] = slice.spread_ref();
 
assert_eq!(odd, [1, 3]);
assert_eq!(even, [2]);

source

fn spread_mut<const M: usize>(&mut self) -> [&mut [Padded<T, M>]; M]

Spreads elements equally across M mutable slices. Slices will have equal length only if the operand slice’s length is divisible by M.

§Examples

#![feature(generic_const_exprs)]
 
use slice_ops::SliceOps;
 
let mut arr = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15"];
let slice = arr.as_mut_slice();
 
let [_, _, fizz] = slice.spread_mut();
assert_eq!(fizz, ["3", "6", "9", "12", "15"]);
for fizz in fizz.iter_mut()
{
    **fizz = "fizz";
}
 
let [_, _, _, _, buzz] = slice.spread_mut();
assert_eq!(buzz, ["5", "10", "fizz"]);
for buzz in buzz.iter_mut()
{
    if **buzz == "fizz"
    {
        **buzz = "fizzbuzz";
        continue;
    }
    **buzz = "buzz";
}
 
assert_eq!(arr, ["1", "2", "fizz", "4", "buzz", "fizz", "7", "8", "fizz", "buzz", "11", "fizz", "13", "14", "fizzbuzz"]);