Struct Slice

Source

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

Expand description

🍃 🛠️ Slice-related operations, most of them const.

^{📍 sys/mem/view}

It is designed as a utility namespace and does not hold or wrap data itself. Instead, it operates on slices provided directly as arguments to its static methods.

§Methods

methods namespaced from core::slice
- clone
- copy
- get (mut)
- from_ref (mut)
- from_raw_parts^⚠ (mut^⚠)
range* API methods:
- range_to (checked, unchecked^⚠, mut, mut_checked, mut_unchecked^⚠) ≈ &slice[..end]
- range_to_inclusive (checked, unchecked^⚠, mut, mut_checked, mut_unchecked^⚠) ≈ &slice[..=end]
- range_from, (checked, unchecked^⚠, mut, mut_checked, mut_unchecked^⚠) ≈ &slice[start..]
- range (checked, unchecked^⚠, mut, mut_checked, mut_unchecked^⚠) ≈ &slice[start..end]
- range_inclusive (checked, unchecked^⚠, mut, mut_checked, mut_unchecked^⚠) ≈ &slice[start..=end]
take* API methods:
- take_first (checked, unchecked^⚠, mut, mut_checked, mut_unchecked^⚠) ≈ &slice[..n]
- take_last (checked, unchecked^⚠, mut, mut_checked, mut_unchecked^⚠) ≈ &slice[len - n..]
- take_omit_last (checked, unchecked^⚠ mut, mut_checked, mut_unchecked^⚠) ≈ &slice[..len - n]
*split* API methods:
- lsplit (mut)
- rsplit (mut)
- msplit_left (mut)
- msplit_right (mut)
*chunk* API methods:
- chunks_exact (mut)
- chunk (mut)
specific methods for byte slices
eq methods for slices of (slices of) primitives

Implementations§

Source §

impl<T> Slice<T>

§`core::slice` namespaced methods.

Source

pub fn clone(dst: &mut [T], src: &[T])
where T: Clone,

Clones all elements from src into dst.

§Panics

Panics if src and dst slices have different lengths.

See core::slice::clone_from_slice.

Source

pub const fn copy(dst: &mut [T], src: &[T])
where T: Copy,

Copies all elements from src into dst using a memcpy.

§Panics

Panics if src and dst slices have different lengths.

See core::slice::copy_from_slice.

Source

pub const fn get(slice: &[T], index: usize) -> Option<&T> ⓘ

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

This is a stable const analogue just for single-element checked access.

See core::slice::get.

Source

pub const fn get_mut(slice: &mut [T], index: usize) -> Option<&mut T> ⓘ

Returns an exclusive reference to the element at index, or None if out of bounds.

This is a stable const analogue just for single-element checked access.

See core::slice::get_mut.

Source

pub const fn from_ref(s: &T) -> &[T] ⓘ

Converts a reference to T into a slice of length 1 (without copying).

See core::slice::from_ref.

Source

pub const fn from_mut(s: &mut T) -> &mut [T] ⓘ

Converts a reference to T into a slice of length 1 (without copying).

See core::slice::from_mut.

Source

pub const unsafe fn from_raw_parts<'a>(data: *const T, len: usize) -> &'a [T] ⓘ

Available on unsafe·· only.

Forms a shared slice from a pointer and a length.

§Safety

See core::slice::from_raw_parts

pub const unsafe fn from_raw_parts_mut<'a>( data: *mut T, len: usize, ) -> &'a mut [T] ⓘ

Available on unsafe·· only.

Forms an exclusive slice from a pointer and a length.

§Safety

See core::slice::from_raw_parts_mut.

See also Ptr::slice_from_raw_parts_mut.

Source §

impl<T> Slice<T>

§`range*` API methods for subslicing.

Source

pub const fn range_to(slice: &[T], end: usize) -> &[T] ⓘ

Returns a subslice up to the given end index.

Equivalent to &slice[..end].

§Panics

Panics if end > slice.len().

Source

pub const fn range_to_checked(slice: &[T], end: usize) -> Option<&[T]> ⓘ

Returns a subslice up to the given end index.

Equivalent to &slice[..end].

Returns None if end > slice.len().

Source

pub const unsafe fn range_to_unchecked(slice: &[T], end: usize) -> &[T] ⓘ

Available on crate feature unsafe_slice only.

Returns a subslice up to the given end index.

Equivalent to &slice[..end].

§Safety

Results in undefined behavior if end > slice.len().

Source

pub const fn range_to_mut(slice: &mut [T], end: usize) -> &mut [T] ⓘ

Returns an exclusive subslice up to the given end index.

Equivalent to &mut slice[..end].

§Panics

Panics if end > slice.len().

Source

pub const fn range_to_mut_checked( slice: &mut [T], end: usize, ) -> Option<&mut [T]> ⓘ

Returns an exclusive subslice up to the given end index.

Equivalent to &mut slice[..end].

Returns None if end > slice.len().

Source

pub const unsafe fn range_to_mut_unchecked( slice: &mut [T], end: usize, ) -> &mut [T] ⓘ

Available on crate feature unsafe_slice only.

Returns an exclusive subslice up to the given end index.

Equivalent to &mut slice[..end].

§Safety

Results in undefined behavior if end > slice.len().

Source

pub const fn range_to_inclusive(slice: &[T], end: usize) -> &[T] ⓘ

Returns a subslice up to and including the given end index.

Equivalent to &slice[..=end].

§Panics

Panics if end >= slice.len().

Source

pub const fn range_to_inclusive_checked(slice: &[T], end: usize) -> Option<&[T]> ⓘ

Returns a subslice up to and including the given end index.

Equivalent to &slice[..=end].

Returns None if end >= slice.len().

Source

pub const unsafe fn range_to_inclusive_unchecked( slice: &[T], end: usize, ) -> &[T] ⓘ

Available on crate feature unsafe_slice only.

Returns an inclusive subslice up to the given end index.

Equivalent to &slice[..=end].

§Safety

Results in undefined behavior if end >= slice.len().

Source

pub const fn range_to_inclusive_mut(slice: &mut [T], end: usize) -> &mut [T] ⓘ

Returns an exclusive subslice up to and including the given end index.

Equivalent to &slice[..=end].

§Panics

Panics if end >= slice.len().

Source

pub const fn range_to_inclusive_mut_checked( slice: &mut [T], end: usize, ) -> Option<&mut [T]> ⓘ

Returns an exclusive subslice up to and including the given end index.

Equivalent to &slice[..=end].

Returns None if end >= slice.len().

Source

pub const unsafe fn range_to_inclusive_mut_unchecked( slice: &mut [T], end: usize, ) -> &mut [T] ⓘ

Available on crate feature unsafe_slice only.

Returns an inclusive subslice up to the given end index.

Equivalent to &slice[..=end].

§Safety

Results in undefined behavior if end >= slice.len().

Source

pub const fn range_from(slice: &[T], start: usize) -> &[T] ⓘ

Returns a subslice starting from the given start index.

Equivalent to &slice[start..].

§Panics

Panics if start > slice.len().

Source

pub const fn range_from_checked(slice: &[T], start: usize) -> Option<&[T]> ⓘ

Returns a subslice starting from the given start index.

Equivalent to &slice[start..].

Returns None if start > slice.len().

Source

pub const unsafe fn range_from_unchecked(slice: &[T], start: usize) -> &[T] ⓘ

Available on crate feature unsafe_slice only.

Returns an exclusive subslice starting from the given start index.

Equivalent to &slice[start..].

§Safety

Results in undefined behavior if start > slice.len().

Source

pub const fn range_from_mut(slice: &mut [T], start: usize) -> &mut [T] ⓘ

Returns an exclusive subslice starting from the given start index.

Equivalent to &mut slice[start..].

§Panics

Panics if start > slice.len().

Source

pub const fn range_from_mut_checked( slice: &mut [T], start: usize, ) -> Option<&mut [T]> ⓘ

Returns an exclusive subslice starting from the given start index.

Equivalent to &mut slice[start..].

Returns None if start > slice.len().

Source

pub const unsafe fn range_from_mut_unchecked( slice: &mut [T], start: usize, ) -> &mut [T] ⓘ

Available on crate feature unsafe_slice only.

Returns an exclusive subslice starting from the given start index.

Equivalent to &mut slice[start..].

§Safety

Results in undefined behavior if start > slice.len().

Source

pub const fn range(slice: &[T], start: usize, end: usize) -> &[T] ⓘ

Returns a subslice from start (inclusive) to end (exclusive).

Equivalent to &slice[start..end].

§Panics

Panics if start > end or end > slice.len().

Source

pub const fn range_checked( slice: &[T], start: usize, end: usize, ) -> Option<&[T]> ⓘ

Returns a subslice from start (inclusive) to end (exclusive).

Equivalent to &slice[start..end].

Returns None if start > end or end > slice.len().

§Features

This method makes use of of the unsafe_slice feature is enabled.

Source

pub const unsafe fn range_unchecked( slice: &[T], start: usize, end: usize, ) -> &[T] ⓘ

Available on crate feature unsafe_slice only.

Returns a subslice from start (inclusive) to end (exclusive).

Equivalent to &slice[start..end].

§Safety

Results in undefined behavior if start > slice.len() or end > slice.len().

Source

pub const fn range_mut(slice: &mut [T], start: usize, end: usize) -> &mut [T] ⓘ

Returns an exclusive subslice from start (inclusive) to end (exclusive).

Equivalent to &mut slice[start..end].

§Panics

Panics if start > end or end > slice.len().

Source

pub const fn range_mut_checked( slice: &mut [T], start: usize, end: usize, ) -> Option<&mut [T]> ⓘ

Returns an exclusive subslice from start (inclusive) to end (exclusive).

Equivalent to &mut slice[start..end].

Returns None if start > end or end > slice.len().

§Features

This method makes use of of the unsafe_slice feature is enabled.

Source

pub const unsafe fn range_mut_unchecked( slice: &mut [T], start: usize, end: usize, ) -> &mut [T] ⓘ

Available on crate feature unsafe_slice only.

Returns an exclusive subslice from start (inclusive) to end (exclusive).

Equivalent to &mut slice[start..end].

§Safety

Results in undefined behavior if start > end or end > slice.len().

Source

pub const fn range_inclusive(slice: &[T], start: usize, end: usize) -> &[T] ⓘ

Returns a subslice from start (inclusive) to end (inclusive).

Equivalent to &slice[start..=end].

§Panics

Panics if start > end or end >= slice.len().

Source

pub const fn range_inclusive_checked( slice: &[T], start: usize, end: usize, ) -> Option<&[T]> ⓘ

Returns a subslice from start (inclusive) to end (inclusive).

Equivalent to &slice[start..=end].

Returns None if start > end or end >= slice.len().

§Features

This method makes use of the unsafe_slice feature if enabled.

Source

pub const unsafe fn range_inclusive_unchecked( slice: &[T], start: usize, end: usize, ) -> &[T] ⓘ

Available on crate feature unsafe_slice only.

Returns a subslice from start (inclusive) to end (inclusive).

Equivalent to &slice[start..=end].

§Safety

Results in undefined behavior if start > slice.len() or end >= slice.len().

Source

pub const fn range_inclusive_mut( slice: &mut [T], start: usize, end: usize, ) -> &mut [T] ⓘ

Returns a subslice from start (inclusive) to end (inclusive).

Equivalent to &mut slice[start..=end].

§Panics

Panics if start > end or end >= slice.len().

Source

pub const fn range_inclusive_mut_checked( slice: &mut [T], start: usize, end: usize, ) -> Option<&mut [T]> ⓘ

Returns a subslice from start (inclusive) to end (inclusive).

Equivalent to &mut slice[start..=end].

Returns None if start > end or end >= slice.len().

§Features

This method makes use of the unsafe_slice feature if enabled.

Source

pub const unsafe fn range_inclusive_mut_unchecked( slice: &mut [T], start: usize, end: usize, ) -> &mut [T] ⓘ

Available on crate feature unsafe_slice only.

Returns a subslice from start (inclusive) to end (inclusive).

Equivalent to &mut slice[start..=end].

§Safety

Results in undefined behavior if start > slice.len() or end >= slice.len().

Source §

impl<T> Slice<T>

§`take*` API methods for subslicing.

Source

pub const fn take_first(slice: &[T], n: usize) -> &[T] ⓘ

Returns the first n elements of the slice.

Equivalent to &slice[..n].

§Panics

Panics if n > slice.len().

Source

pub const fn take_first_checked(slice: &[T], n: usize) -> Option<&[T]> ⓘ

Returns the first n elements of the slice.

Equivalent to &slice[..n].

Returns None if n > slice.len().

Source

pub const unsafe fn take_first_unchecked(slice: &[T], n: usize) -> &[T] ⓘ

Available on crate feature unsafe_slice only.

Returns the first n elements of the slice.

Equivalent to &slice[..n].

§Safety

Results in undefined behavior if n > slice.len().

Source

pub const fn take_first_mut(slice: &mut [T], n: usize) -> &mut [T] ⓘ

Returns the first n elements of the exclusive slice.

Equivalent to &mut slice[..n].

§Panics

Panics if n > slice.len().

Source

pub const fn take_first_mut_checked( slice: &mut [T], n: usize, ) -> Option<&mut [T]> ⓘ

Returns the first n elements of the exclusive slice.

Equivalent to &mut slice[..n].

Returns None if n > slice.len().

Source

pub const unsafe fn take_first_mut_unchecked( slice: &mut [T], n: usize, ) -> &mut [T] ⓘ

Available on crate feature unsafe_slice only.

Returns the first n elements of the exclusive slice.

Equivalent to &mut slice[..n].

§Safety

Results in undefined behavior if n > slice.len().

Source

pub const fn take_last(slice: &[T], n: usize) -> &[T] ⓘ

Returns the last n elements of the slice.

Equivalent to &slice[slice.len() - n..].

§Panics

Panics if n > slice.len().

Source

pub const fn take_last_checked(slice: &[T], n: usize) -> Option<&[T]> ⓘ

Returns the last n elements of the slice.

Equivalent to &slice[slice.len() - n..].

Returns None if n > slice.len().

§Features

This method makes use of of the unsafe_slice feature is enabled.

Source

pub const unsafe fn take_last_unchecked(slice: &[T], n: usize) -> &[T] ⓘ

Available on crate feature unsafe_slice only.

Returns the last n elements of the slice.

Equivalent to &slice[slice.len() - n..].

§Safety

Results in undefined behavior if n > slice.len().

Source

pub const fn take_last_mut(slice: &mut [T], n: usize) -> &mut [T] ⓘ

Returns the last n elements of the exclusive slice.

Equivalent to &mut slice[slice.len() - n..].

§Panics

Panics if n > slice.len().

Source

pub const fn take_last_mut_checked( slice: &mut [T], n: usize, ) -> Option<&mut [T]> ⓘ

Returns the last n elements of the exclusive slice.

Equivalent to &mut slice[slice.len() - n..].

Returns None if n > slice.len().

§Features

This method makes use of of the unsafe_slice feature is enabled.

Source

pub const unsafe fn take_last_mut_unchecked( slice: &mut [T], n: usize, ) -> &mut [T] ⓘ

Available on crate feature unsafe_slice only.

Returns the last n elements of the exclusive slice.

Equivalent to &mut slice[slice.len() - n..].

§Safety

Results in undefined behavior if n > slice.len().

Source

pub const fn take_omit_last(slice: &[T], n: usize) -> &[T] ⓘ

Returns the slice omitting the last n elements.

Equivalent to &slice[..slice.len() - n].

§Panics

Panics if n > slice.len().

Source

pub const fn take_omit_last_checked(slice: &[T], n: usize) -> Option<&[T]> ⓘ

Returns the slice omitting the last n elements.

Equivalent to &slice[..slice.len() - n].

Returns None if n > slice.len().

§Features

This method makes use of of the unsafe_slice feature is enabled.

Source

pub const fn take_omit_last_unchecked(slice: &[T], n: usize) -> &[T] ⓘ

Available on crate feature unsafe_slice only.

Returns the slice omitting the last n elements.

Equivalent to &slice[..slice.len() - n].

§Safety

Results in undefined behavior if n > slice.len().

Source

pub const fn take_omit_last_mut(slice: &mut [T], n: usize) -> &mut [T] ⓘ

Returns the exclusive slice omitting the last n elements.

Equivalent to &mut slice[..slice.len() - n].

§Panics

Panics if n > slice.len().

Source

pub const fn take_omit_last_mut_checked( slice: &mut [T], n: usize, ) -> Option<&mut [T]> ⓘ

Returns the exclusive slice omitting the last n elements.

Equivalent to &mut slice[..slice.len() - n].

Returns None if n > slice.len().

§Features

This method makes use of of the unsafe_slice feature is enabled.

Source

pub const fn take_omit_last_mut_unchecked(slice: &mut [T], n: usize) -> &mut [T] ⓘ

Available on crate feature unsafe_slice only.

Returns the exclusive slice omitting the last n elements.

Equivalent to &mut slice[..slice.len() - n].

§Safety

Results in undefined behavior if n > slice.len().

Source §

impl<T> Slice<T>

§`split` API methods for subslicing.

Source

pub const fn lsplit(slice: &[T], len: usize) -> &[T] ⓘ

Returns the leftmost sub-slice with the given maximum len.

If len > self.len() it returns the full slice.

§Examples

let v = [1, 2, 3, 4, 5, 6];
assert_eq!(Slice::lsplit(&v, 3), &[1, 2, 3]);
assert_eq!(Slice::lsplit(&v, 0), &[] as &[i32]);
assert_eq!(Slice::lsplit(&v, 10), &[1, 2, 3, 4, 5, 6]);

Source

pub const fn lsplit_mut(slice: &mut [T], len: usize) -> &mut [T] ⓘ

Returns the leftmost exclusive sub-slice with the given maximum len.

If left_len > slice.len() it returns the full slice.

§Examples

let mut v = [1, 2, 3, 4, 5, 6];
assert_eq!(Slice::lsplit_mut(&mut v, 3), &mut [1, 2, 3]);
assert_eq!(Slice::lsplit_mut(&mut v, 0), &mut [] as &mut [i32]);
assert_eq!(Slice::lsplit_mut(&mut v, 10), &mut [1, 2, 3, 4, 5, 6]);

pub const fn rsplit(slice: &[T], len: usize) -> &[T] ⓘ

Returns the rightmost sub-slice with the given maximum len.

If left_len > slice.len() it returns the full slice.

§Examples

let v = [1, 2, 3, 4, 5, 6];
assert_eq!(Slice::rsplit(&v, 3), &[4, 5, 6]);
assert_eq!(Slice::rsplit(&v, 0), &[] as &[i32]);
assert_eq!(Slice::rsplit(&v, 10), &[1, 2, 3, 4, 5, 6]);

Source

pub const fn rsplit_mut(slice: &mut [T], len: usize) -> &mut [T] ⓘ

Returns the rightmost exclusive sub-slice with the given maximum len.

If left_len > slice.len() it returns the full slice.

§Examples

let mut v = [1, 2, 3, 4, 5, 6];
assert_eq!(Slice::rsplit_mut(&mut v, 3), &mut [4, 5, 6]);
assert_eq!(Slice::rsplit_mut(&mut v, 0), &mut [] as &mut [i32]);
assert_eq!(Slice::rsplit_mut(&mut v, 10), &mut [1, 2, 3, 4, 5, 6]);

pub const fn msplit_left(slice: &[T], len: usize) -> &[T] ⓘ

Returns the middle sub-slice with the given maximum len and a left bias.

In case of a non-perfect middle split, it will have one element more on the left.

If len > slice.len() returns the full slice.

§Examples

let v = [1, 2, 3, 4, 5, 6];
assert_eq!(Slice::msplit_left(&v, 0), &[] as &[i32]);
assert_eq!(Slice::msplit_left(&v, 1), &[3]);
assert_eq!(Slice::msplit_left(&v, 2), &[3, 4]);
assert_eq!(Slice::msplit_left(&v, 3), &[2, 3, 4]);
assert_eq!(Slice::msplit_left(&v, 4), &[2, 3, 4, 5]);
assert_eq!(Slice::msplit_left(&v, 5), &[1, 2, 3, 4, 5]);
assert_eq!(Slice::msplit_left(&v, 10), &[1, 2, 3, 4, 5, 6]);

pub const fn msplit_left_mut(slice: &mut [T], len: usize) -> &mut [T] ⓘ

Returns the middle exclusive sub-slice with the given maximum len and a left bias.

In case of a non-perfect middle split, it will have one element more on the left.

If len > slice.len() returns the full slice.

§Examples

let mut v = [1, 2, 3, 4, 5, 6];
assert_eq!(Slice::msplit_left_mut(&mut v, 0), &mut [] as &mut [i32]);
assert_eq!(Slice::msplit_left_mut(&mut v, 1), &mut [3]);
assert_eq!(Slice::msplit_left_mut(&mut v, 2), &mut [3, 4]);
assert_eq!(Slice::msplit_left_mut(&mut v, 3), &mut [2, 3, 4]);
assert_eq!(Slice::msplit_left_mut(&mut v, 4), &mut [2, 3, 4, 5]);
assert_eq!(Slice::msplit_left_mut(&mut v, 5), &mut [1, 2, 3, 4, 5]);
assert_eq!(Slice::msplit_left_mut(&mut v, 10), &mut [1, 2, 3, 4, 5, 6]);

pub const fn msplit_right(slice: &[T], len: usize) -> &[T] ⓘ

Returns the middle sub-slice with the given maximum len and a right bias.

In case of a non-perfect middle split, it will have one element more on the right.

If len > slice.len() returns the full slice.

§Examples

let v = [1, 2, 3, 4, 5, 6];
assert_eq!(Slice::msplit_right(&v, 0), &[] as &[i32]);
assert_eq!(Slice::msplit_right(&v, 1), &[4]);
assert_eq!(Slice::msplit_right(&v, 2), &[3, 4]);
assert_eq!(Slice::msplit_right(&v, 3), &[3, 4, 5]);
assert_eq!(Slice::msplit_right(&v, 4), &[2, 3, 4, 5]);
assert_eq!(Slice::msplit_right(&v, 5), &[2, 3, 4, 5, 6]);
assert_eq!(Slice::msplit_right(&v, 10), &[1, 2, 3, 4, 5, 6]);

pub const fn msplit_right_mut(slice: &mut [T], len: usize) -> &mut [T] ⓘ

Returns the middle exclusive sub-slice with the given maximum len and a right bias.

In case of a non-perfect middle split, it will have one element more on the right.

If len > slice.len() returns the full slice.

§Examples

let mut v = [1, 2, 3, 4, 5, 6];
assert_eq!(Slice::msplit_right_mut(&mut v, 0), &mut [] as &mut[i32]);
assert_eq!(Slice::msplit_right_mut(&mut v, 1), &mut [4]);
assert_eq!(Slice::msplit_right_mut(&mut v, 2), &mut [3, 4]);
assert_eq!(Slice::msplit_right_mut(&mut v, 3), &mut [3, 4, 5]);
assert_eq!(Slice::msplit_right_mut(&mut v, 4), &mut [2, 3, 4, 5]);
assert_eq!(Slice::msplit_right_mut(&mut v, 5), &mut [2, 3, 4, 5, 6]);
assert_eq!(Slice::msplit_right_mut(&mut v, 10), &mut [1, 2, 3, 4, 5, 6]);

impl<T> Slice<T>

§`chunk` API methods for subslicing.

Source

pub const fn chunks_exact<const N: usize>(slice: &[T]) -> (usize, &[T]) ⓘ

Returns the number of complete N-sized chunks in slice and the trailing remainder.

This is the fixed-step primitive for const-friendly traversal.

§Examples

let bytes = b"abcdefg";
let (count, rem) = Slice::chunks_exact::<3>(bytes);
assert_eq!(count, 2); // "abc", "def"
assert_eq!(rem, b"g");

Source

pub const fn chunks_exact_mut<const N: usize>( slice: &mut [T], ) -> (usize, &mut [T]) ⓘ

Mutable counterpart to chunks_exact.

Returns the number of complete N-sized chunks and a mutable remainder slice. The caller performs any iteration or stepping logic.

Source

pub const fn chunk<const N: usize>(slice: &[T], idx: usize) -> Option<&[T]> ⓘ

Returns the idx-th complete chunk of size N, or None if incomplete.

This offers direct, index-based access to fixed-width records. Bounds are checked; no iteration policy is imposed.

§Examples

let b = b"abcdefgh";
assert_eq!(Slice::chunk::<3>(b, 0), Some(&b"abc"[..]));
assert_eq!(Slice::chunk::<3>(b, 1), Some(&b"def"[..]));
assert_eq!(Slice::chunk::<3>(b, 2), None); // only "gh" remains, not enough for a full chunk

Source

pub const fn chunk_mut<const N: usize>( slice: &mut [T], idx: usize, ) -> Option<&mut [T]> ⓘ

Mutable counterpart to chunk.

Returns the idx-th complete chunk of size N as a mutable subslice, or None if the chunk is incomplete.

§Examples

let mut b = *b"abcdef";
if let Some(ch) = Slice::chunk_mut::<3>(&mut b, 1) {
    ch[0] = b'X';
}
assert_eq!(&b, b"abcXef");

Source §

impl Slice<u8>

§Methods for byte slices.

Source

pub const fn copy_into(dst: &mut [u8], dst_pos: usize, src: &[u8]) -> usize

Copies bytes from src into dst starting at dst_pos, up to the remaining capacity.

Returns the number of bytes copied (possibly less than src.len() if truncated).

§Examples

let mut buf = [0u8; 4];
assert_eq!(Slice::copy_into(&mut buf, 1, b"abc"), 3);
assert_eq!(&buf, b"\0abc");

Source

pub const fn copy_str_into(dst: &mut [u8], dst_pos: usize, src: &str) -> usize

Copies UTF-8 bytes from src into dst starting at dst_pos, truncating only at valid UTF-8 character boundaries.

Returns the number of bytes copied (never splits a character).

§Examples

// 'o' (1 byte) would fit, but 'ø' (2 bytes) must be dropped
let mut buf = [0u8; 5];
assert_eq!(Slice::copy_str_into(&mut buf, 0, "hellø"), 4);
assert_eq!(&buf[..4], b"hell");

Source

pub const fn copy_utf8_into(dst: &mut [u8], dst_pos: usize, src: &[u8]) -> usize

Copies bytes from a UTF-8–encoded slice into dst starting at dst_pos, truncating only at valid UTF-8 character boundaries.

Returns the number of bytes copied (never splits a UTF-8 sequence).

§Examples

// 'o' (1 byte) would fit, but 'ø' (2 bytes) must be dropped
let mut buf = [0u8; 5];
assert_eq!(Slice::copy_utf8_into(&mut buf, 0, "hellø".as_bytes()), 4);
assert_eq!(&buf[..4], b"hell");

Source

pub const fn copy_array<const N: usize>(dst: &mut [u8; N], src: &[u8; N])

Copies the src byte array into dst in compile-time.

§Features

Uses Ptr::copy_nonoverlapping when unsafe operations are allowed.

Source

pub const fn copy_array_at<const LEN: usize>( dst: &mut [u8; LEN], src: &[u8], offset: usize, )

Copies all elements from src into a fixed-size array starting at offset.

§Panics

Panics if src.len() + offset > LEN.

§Features

Uses Ptr::copy_nonoverlapping when unsafe operations are allowed.
Falls back to safe element-wise copy otherwise.

Source

pub const fn copied_array_at<const LEN: usize>( base: [u8; LEN], src: &[u8], offset: usize, ) -> [u8; LEN] ⓘ

A convenience wrapper over Slice::copy_array_at.

Source

pub const fn to_array<const LEN: usize>(src: &[u8]) -> [u8; LEN] ⓘ

Copies all elements from src into a new fixed-size array.

§Features

Uses Ptr::copy_nonoverlapping when unsafe operations are allowed
Falls back to safe element-wise copy otherwise

§Panics

Panics if src.len() != LEN.

Source

pub const fn replace_leading(slice: &mut [u8], old: u8, new: u8)

Replaces the old leading byte with a new byte.

Source

pub const fn trim_leading(slice: &[u8], byte: u8) -> &[u8] ⓘ

Returns a subslice without the given leading bytes.

§Examples

assert_eq!(Slice::trim_leading(b"000123", b'0'), b"123");

Source

pub const fn trim_leading_keep(slice: &[u8], byte: u8, keep: usize) -> &[u8] ⓘ

Returns a subslice without the given leading bytes, except of keep number of them.

§Examples

assert_eq!(Slice::trim_leading_keep(b"000123", b'0', 0), b"123");
assert_eq!(Slice::trim_leading_keep(b"000123", b'0', 2), b"00123");
assert_eq!(Slice::trim_leading_keep(b"000123", b'0', 10), b"000123");

Source

pub const fn trim_leading_min_len( slice: &[u8], byte: u8, min_len: usize, ) -> &[u8] ⓘ

Returns a subslice without the given leading bytes, ensuring the result has at least min_len bytes (if possible).

§Examples

assert_eq!(Slice::trim_leading_min_len(b"000000", b'0', 1), b"0");
assert_eq!(Slice::trim_leading_min_len(b"000123", b'0', 0), b"123");
assert_eq!(Slice::trim_leading_min_len(b"000123", b'0', 4), b"0123");
assert_eq!(Slice::trim_leading_min_len(b"000123", b'0', 10), b"000123");

Source

pub const fn trim_trailing(slice: &[u8], byte: u8) -> &[u8] ⓘ

Returns a subslice without the given trailing bytes.

§Examples

assert_eq!(Slice::trim_trailing(b"123000", b'0'), b"123");

Source

pub const fn trim_trailing_keep(slice: &[u8], byte: u8, keep: usize) -> &[u8] ⓘ

Returns a subslice without the given trailing bytes, except of keep number of them.

§Examples

assert_eq!(Slice::trim_trailing_keep(b"123000", b'0', 0), b"123");
assert_eq!(Slice::trim_trailing_keep(b"123000", b'0', 2), b"12300");
assert_eq!(Slice::trim_trailing_keep(b"123000", b'0', 10), b"123000");

Source

pub const fn trim_trailing_min_len( slice: &[u8], byte: u8, min_len: usize, ) -> &[u8] ⓘ

Returns a subslice without the given trailing bytes, ensuring the result has at least min_len bytes (if possible).

§Examples

assert_eq!(Slice::trim_trailing_min_len(b"000000", b'0', 1), b"0");
assert_eq!(Slice::trim_trailing_min_len(b"123000", b'0', 0), b"123");
assert_eq!(Slice::trim_trailing_min_len(b"123000", b'0', 4), b"1230");
assert_eq!(Slice::trim_trailing_min_len(b"123000", b'0', 10), b"123000");

Source

pub const fn trim_edges(slice: &[u8], byte: u8) -> &[u8] ⓘ

Returns a subslice without the given leading and trailing bytes.

§Examples

assert_eq!(Slice::trim_edges(b"000123000", b'0'), b"123");

Source

pub const fn trim_edges_keep(slice: &[u8], byte: u8, keep: usize) -> &[u8] ⓘ

Returns a subslice without the given leading and trailing bytes, except for keep number of them on each side.

§Examples

assert_eq!(Slice::trim_edges_keep(b"000123000", b'0', 0), b"123");
assert_eq!(Slice::trim_edges_keep(b"000123000", b'0', 1), b"01230");
assert_eq!(Slice::trim_edges_keep(b"000123000", b'0', 2), b"0012300");
assert_eq!(Slice::trim_edges_keep(b"000123000", b'0', 10), b"000123000");

Source

pub const fn trim_edges_min_len_left( slice: &[u8], byte: u8, min_len: usize, ) -> &[u8] ⓘ

Returns a subslice without the given leading and edges bytes, ensuring the result has at least min_len bytes (if possible), with a left bias.

§Examples

assert_eq!(Slice::trim_edges_min_len_left(b"000123000", b'0', 0), b"123");
assert_eq!(Slice::trim_edges_min_len_left(b"000123000", b'0', 4), b"0123");
assert_eq!(Slice::trim_edges_min_len_left(b"000123000", b'0', 5), b"01230");
assert_eq!(Slice::trim_edges_min_len_left(b"000123000", b'0', 6), b"001230");
assert_eq!(Slice::trim_edges_min_len_left(b"000123000", b'0', 7), b"0012300");
assert_eq!(Slice::trim_edges_min_len_left(b"000123000", b'0', 20), b"000123000");

Source

pub const fn trim_edges_min_len_right( slice: &[u8], byte: u8, min_len: usize, ) -> &[u8] ⓘ

Returns a subslice without the given leading and edges bytes, ensuring the result has at least min_len bytes (if possible), with a right bias.

§Examples

assert_eq!(Slice::trim_edges_min_len_right(b"000123000", b'0', 0), b"123");
assert_eq!(Slice::trim_edges_min_len_right(b"000123000", b'0', 4), b"1230");
assert_eq!(Slice::trim_edges_min_len_right(b"000123000", b'0', 5), b"01230");
assert_eq!(Slice::trim_edges_min_len_right(b"000123000", b'0', 6), b"012300");
assert_eq!(Slice::trim_edges_min_len_right(b"000123000", b'0', 7), b"0012300");
assert_eq!(Slice::trim_edges_min_len_right(b"000123000", b'0', 20), b"000123000");

Source §

impl Slice<u8>

Source

pub const fn eq(a: &[u8], b: &[u8]) -> bool

Checks the equality of two slices of primitives in compile-time.

Source §

impl Slice<&[u8]>

Source

pub const fn eq(a: &[&[u8]], b: &[&[u8]]) -> bool

Checks the equality of two slices of slices of primitives in compile-time.

Source §

impl Slice<u16>

Source

pub const fn eq(a: &[u16], b: &[u16]) -> bool

Checks the equality of two slices of primitives in compile-time.

Source §

impl Slice<&[u16]>

Source

pub const fn eq(a: &[&[u16]], b: &[&[u16]]) -> bool

Checks the equality of two slices of slices of primitives in compile-time.

Source §

impl Slice<u32>

Source

pub const fn eq(a: &[u32], b: &[u32]) -> bool

Checks the equality of two slices of primitives in compile-time.

Source §

impl Slice<&[u32]>

Source

pub const fn eq(a: &[&[u32]], b: &[&[u32]]) -> bool

Checks the equality of two slices of slices of primitives in compile-time.

Source §

impl Slice<u64>

Source

pub const fn eq(a: &[u64], b: &[u64]) -> bool

Checks the equality of two slices of primitives in compile-time.

Source §

impl Slice<&[u64]>

Source

pub const fn eq(a: &[&[u64]], b: &[&[u64]]) -> bool

Checks the equality of two slices of slices of primitives in compile-time.

Source §

impl Slice<u128>

Source

pub const fn eq(a: &[u128], b: &[u128]) -> bool

Checks the equality of two slices of primitives in compile-time.

Source §

impl Slice<&[u128]>

Source

pub const fn eq(a: &[&[u128]], b: &[&[u128]]) -> bool

Checks the equality of two slices of slices of primitives in compile-time.

Source §

impl Slice<usize>

Source

pub const fn eq(a: &[usize], b: &[usize]) -> bool

Checks the equality of two slices of primitives in compile-time.

Source §

impl Slice<&[usize]>

Source

pub const fn eq(a: &[&[usize]], b: &[&[usize]]) -> bool

Checks the equality of two slices of slices of primitives in compile-time.

Source §

impl Slice<i8>

Source

pub const fn eq(a: &[i8], b: &[i8]) -> bool

Checks the equality of two slices of primitives in compile-time.

Source §

impl Slice<&[i8]>

Source

pub const fn eq(a: &[&[i8]], b: &[&[i8]]) -> bool

Checks the equality of two slices of slices of primitives in compile-time.

Source §

impl Slice<i16>

Source

pub const fn eq(a: &[i16], b: &[i16]) -> bool

Checks the equality of two slices of primitives in compile-time.

Source §

impl Slice<&[i16]>

Source

pub const fn eq(a: &[&[i16]], b: &[&[i16]]) -> bool

Checks the equality of two slices of slices of primitives in compile-time.

Source §

impl Slice<i32>

Source

pub const fn eq(a: &[i32], b: &[i32]) -> bool

Checks the equality of two slices of primitives in compile-time.

Source §

impl Slice<&[i32]>

Source

pub const fn eq(a: &[&[i32]], b: &[&[i32]]) -> bool

Checks the equality of two slices of slices of primitives in compile-time.

Source §

impl Slice<i64>

Source

pub const fn eq(a: &[i64], b: &[i64]) -> bool

Checks the equality of two slices of primitives in compile-time.

Source §

impl Slice<&[i64]>

Source

pub const fn eq(a: &[&[i64]], b: &[&[i64]]) -> bool

Checks the equality of two slices of slices of primitives in compile-time.

Source §

impl Slice<i128>

Source

pub const fn eq(a: &[i128], b: &[i128]) -> bool

Checks the equality of two slices of primitives in compile-time.

Source §

impl Slice<&[i128]>

Source

pub const fn eq(a: &[&[i128]], b: &[&[i128]]) -> bool

Checks the equality of two slices of slices of primitives in compile-time.

Source §

impl Slice<isize>

Source

pub const fn eq(a: &[isize], b: &[isize]) -> bool

Checks the equality of two slices of primitives in compile-time.

Source §

impl Slice<&[isize]>

Source

pub const fn eq(a: &[&[isize]], b: &[&[isize]]) -> bool

Checks the equality of two slices of slices of primitives in compile-time.

Source §

impl Slice<f32>

Source

pub const fn eq(a: &[f32], b: &[f32]) -> bool

Checks the equality of two slices of primitives in compile-time.

Source §

impl Slice<&[f32]>

Source

pub const fn eq(a: &[&[f32]], b: &[&[f32]]) -> bool

Checks the equality of two slices of slices of primitives in compile-time.

Source §

impl Slice<f64>

Source

pub const fn eq(a: &[f64], b: &[f64]) -> bool

Checks the equality of two slices of primitives in compile-time.

Source §

impl Slice<&[f64]>

Source

pub const fn eq(a: &[&[f64]], b: &[&[f64]]) -> bool

Checks the equality of two slices of slices of primitives in compile-time.

Source §

impl Slice<bool>

Source

pub const fn eq(a: &[bool], b: &[bool]) -> bool

Checks the equality of two slices of primitives in compile-time.

Source §

impl Slice<&[bool]>

Source

pub const fn eq(a: &[&[bool]], b: &[&[bool]]) -> bool

Checks the equality of two slices of slices of primitives in compile-time.

Source §

impl Slice<char>

Source

pub const fn eq(a: &[char], b: &[char]) -> bool

Checks the equality of two slices of primitives in compile-time.

Source §

impl Slice<&[char]>

Source

pub const fn eq(a: &[&[char]], b: &[&[char]]) -> bool

Checks the equality of two slices of slices of primitives in compile-time.

Source §

impl Slice<f16>

Source

pub const fn eq(a: &[f16], b: &[f16]) -> bool

Checks the equality of two slices of primitives in compile-time.

Source §

impl Slice<&[f16]>

Source

pub const fn eq(a: &[&[f16]], b: &[&[f16]]) -> bool

Checks the equality of two slices of slices of primitives in compile-time.

Source §

impl Slice<f128>

Source

pub const fn eq(a: &[f128], b: &[f128]) -> bool

Checks the equality of two slices of primitives in compile-time.

Source §

impl Slice<&[f128]>

Source

pub const fn eq(a: &[&[f128]], b: &[&[f128]]) -> bool

Checks the equality of two slices of slices of primitives in compile-time.

Source §

impl Slice<&str>

§Methods for string slices.

Source

pub const fn eq(a: &str, b: &str) -> bool

Checks the equality of two string slices in compile-time.

Source §

impl Slice<&[&str]>

Source

pub const fn eq(a: &[&str], b: &[&str]) -> bool

Checks the equality of two slices of string slices in compile-time.

Trait Implementations§

Source §

impl<T: Debug> Debug for Slice<T>

Source §

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

Formats the value using the given formatter. Read more

Auto Trait Implementations§

§

impl<T> UnwindSafe for Slice<T>
where T: UnwindSafe,

Blanket Implementations§

Source §

impl<T> Any for T
where T: 'static + ?Sized,

Source §

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

Source §

impl<T> AnyExt for T
where T: Any + ?Sized,

Source §

fn type_id() -> TypeId

Returns the TypeId of Self. Read more

Source §

fn type_of(&self) -> TypeId

Returns the TypeId of self. Read more

Source §

fn type_name(&self) -> &'static str ⓘ

Returns the type name of self. Read more

Source §

fn type_is<T: 'static>(&self) -> bool

Returns true if Self is of type T. Read more

Source §

fn type_hash(&self) -> u64

Returns a deterministic hash of the TypeId of Self.

Source §

fn type_hash_with<H: Hasher>(&self, hasher: H) -> u64

Returns a deterministic hash of the TypeId of Self using a custom hasher.

Source §

fn as_any_ref(&self) -> &dyn Any
where Self: Sized,

Upcasts &self as &dyn Any. Read more

Source §

fn as_any_mut(&mut self) -> &mut dyn Any
where Self: Sized,

Upcasts &mut self as &mut dyn Any. Read more

Source §

fn as_any_box(self: Box<Self>) -> Box<dyn Any>
where Self: Sized,

Available on crate feature alloc only.

Upcasts Box<self> as Box<dyn Any>. Read more

Source §

fn downcast_ref<T: 'static>(&self) -> Option<&T> ⓘ

Available on crate feature unsafe_layout and non-crate feature safe_code only.

Returns some shared reference to the inner value if it is of type T. Read more

Source §

fn downcast_mut<T: 'static>(&mut self) -> Option<&mut T> ⓘ

Available on crate feature unsafe_layout and non-crate feature safe_code only.

Returns some exclusive reference to the inner value if it is of type T. Read more

Source §

impl<T> Borrow<T> for T
where T: ?Sized,

Source §

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

Source §

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source §

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

Source §

impl<T> ByteSized for T

Source §

const BYTE_ALIGN: usize = _

The alignment of this type in bytes.

Source §

const BYTE_SIZE: usize = _

The size of this type in bytes.

Source §

fn byte_align(&self) -> usize

Returns the alignment of this type in bytes.

Source §

fn byte_size(&self) -> usize

Returns the size of this type in bytes. Read more

Source §

fn ptr_size_ratio(&self) -> [usize; 2]

Returns the size ratio between Ptr::BYTES and BYTE_SIZE. Read more

Source §

impl<T> From<T> for T

Source §

fn from(t: T) -> T

Returns the argument unchanged.

Source §

impl<T> Hook for T

Source §

fn hook<F>(self, f: F) -> Self
where F: FnOnce(&mut Self),

Hooks a mutation step into the value and returns it. Read more

Source §

fn tap<F>(self, f: F) -> Self
where F: FnOnce(&Self),

Taps into the value for observation and returns it unchanged. Read more

Source §

impl<T, U> Into for T
where U: From<T>,

Source §

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source §

impl<T> MemExt for T
where T: ?Sized,

Source §

const NEEDS_DROP: bool = _

Know whether dropping values of this type matters, in compile-time.

Source §

fn mem_align_of<T>() -> usize

Returns the minimum alignment of the type in bytes. Read more

Source §

fn mem_align_of_val(&self) -> usize

Returns the alignment of the pointed-to value in bytes. Read more

Source §

fn mem_size_of<T>() -> usize

Returns the size of a type in bytes. Read more

Source §

fn mem_size_of_val(&self) -> usize

Returns the size of the pointed-to value in bytes. Read more

Source §

fn mem_copy(&self) -> Self
where Self: Copy,

Bitwise-copies a value. Read more

Source §

fn mem_needs_drop(&self) -> bool

Returns true if dropping values of this type matters. Read more

Source §

fn mem_drop(self)
where Self: Sized,

Drops self by running its destructor. Read more

Source §

fn mem_forget(self)
where Self: Sized,

Forgets about self without running its destructor. Read more

Source §

fn mem_replace(&mut self, other: Self) -> Self
where Self: Sized,

Replaces self with other, returning the previous value of self. Read more

Source §

fn mem_take(&mut self) -> Self
where Self: Default,

Replaces self with its default value, returning the previous value of self. Read more

Source §

fn mem_swap(&mut self, other: &mut Self)
where Self: Sized,

Swaps the value of self and other without deinitializing either one. Read more

Source §

unsafe fn mem_zeroed<T>() -> T

Available on crate feature unsafe_layout only.

Returns the value of type T represented by the all-zero byte-pattern. Read more

Source §

unsafe fn mem_transmute_copy<Src, Dst>(src: &Src) -> Dst

Available on crate feature unsafe_layout only.

Returns the value of type T represented by the all-zero byte-pattern. Read more

Source §

fn mem_as_bytes(&self) -> &[u8] ⓘ
where Self: Sync + Unpin,

Available on crate feature unsafe_slice only.

View a Sync + Unpin self as &[u8]. Read more

Source §

fn mem_as_bytes_mut(&mut self) -> &mut [u8] ⓘ
where Self: Sync + Unpin,

Available on crate feature unsafe_slice only.

View a Sync + Unpin self as &mut [u8]. Read more

Source §

impl<T, R> Morph<R> for T
where T: ?Sized,

Source §

fn morph<F>(self, f: F) -> R
where F: FnOnce(Self) -> R, Self: Sized,

Morphs the value into a new one and returns it. Read more

Source §

fn morph_ref<F>(&self, f: F) -> R
where F: FnOnce(&Self) -> R,

Morphs the value by shared reference and returns the result. Read more

Source §

fn morph_mut<F>(&mut self, f: F) -> R
where F: FnOnce(&mut Self) -> R,

Morphs the value by exclusive reference and returns the result. Read more

Source §

impl<T, U> TryFrom for T
where U: Into<T>,

Source §

type Error = Infallible

The type returned in the event of a conversion error.

Source §

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error> ⓘ

Performs the conversion.

Source §

impl<T, U> TryInto for T
where U: TryFrom<T>,

Source §

type Error = >::Error

The type returned in the event of a conversion error.

Source §

fn try_into(self) -> Result<U, >::Error> ⓘ

Performs the conversion.

Struct Slice Copy item path

§Methods

Implementations§

impl<T> Slice<T>

§core::slice namespaced methods.

pub fn clone(dst: &mut [T], src: &[T])where T: Clone,

§Panics

pub const fn copy(dst: &mut [T], src: &[T])where T: Copy,

§Panics

pub const fn get(slice: &[T], index: usize) -> Option<&T> ⓘ

pub const fn get_mut(slice: &mut [T], index: usize) -> Option<&mut T> ⓘ

pub const fn from_ref(s: &T) -> &[T] ⓘ

pub const fn from_mut(s: &mut T) -> &mut [T] ⓘ

pub const unsafe fn from_raw_parts<'a>(data: *const T, len: usize) -> &'a [T] ⓘ

§Safety

pub const unsafe fn from_raw_parts_mut<'a>( data: *mut T, len: usize, ) -> &'a mut [T] ⓘ

§Safety

impl<T> Slice<T>

§range* API methods for subslicing.

pub const fn range_to(slice: &[T], end: usize) -> &[T] ⓘ

§Panics

pub const fn range_to_checked(slice: &[T], end: usize) -> Option<&[T]> ⓘ

pub const unsafe fn range_to_unchecked(slice: &[T], end: usize) -> &[T] ⓘ

§Safety

pub const fn range_to_mut(slice: &mut [T], end: usize) -> &mut [T] ⓘ

§Panics

pub const fn range_to_mut_checked( slice: &mut [T], end: usize, ) -> Option<&mut [T]> ⓘ

pub const unsafe fn range_to_mut_unchecked( slice: &mut [T], end: usize, ) -> &mut [T] ⓘ

§Safety

pub const fn range_to_inclusive(slice: &[T], end: usize) -> &[T] ⓘ

§Panics

pub const fn range_to_inclusive_checked(slice: &[T], end: usize) -> Option<&[T]> ⓘ

pub const unsafe fn range_to_inclusive_unchecked( slice: &[T], end: usize, ) -> &[T] ⓘ

§Safety

pub const fn range_to_inclusive_mut(slice: &mut [T], end: usize) -> &mut [T] ⓘ

§Panics

pub const fn range_to_inclusive_mut_checked( slice: &mut [T], end: usize, ) -> Option<&mut [T]> ⓘ

pub const unsafe fn range_to_inclusive_mut_unchecked( slice: &mut [T], end: usize, ) -> &mut [T] ⓘ

§Safety

pub const fn range_from(slice: &[T], start: usize) -> &[T] ⓘ

§Panics

pub const fn range_from_checked(slice: &[T], start: usize) -> Option<&[T]> ⓘ

pub const unsafe fn range_from_unchecked(slice: &[T], start: usize) -> &[T] ⓘ

§Safety

pub const fn range_from_mut(slice: &mut [T], start: usize) -> &mut [T] ⓘ

§Panics

pub const fn range_from_mut_checked( slice: &mut [T], start: usize, ) -> Option<&mut [T]> ⓘ

pub const unsafe fn range_from_mut_unchecked( slice: &mut [T], start: usize, ) -> &mut [T] ⓘ

§Safety

pub const fn range(slice: &[T], start: usize, end: usize) -> &[T] ⓘ

§Panics

pub const fn range_checked( slice: &[T], start: usize, end: usize, ) -> Option<&[T]> ⓘ

§Features

pub const unsafe fn range_unchecked( slice: &[T], start: usize, end: usize, ) -> &[T] ⓘ

§Safety

pub const fn range_mut(slice: &mut [T], start: usize, end: usize) -> &mut [T] ⓘ

§Panics

pub const fn range_mut_checked( slice: &mut [T], start: usize, end: usize, ) -> Option<&mut [T]> ⓘ

§Features

pub const unsafe fn range_mut_unchecked( slice: &mut [T], start: usize, end: usize, ) -> &mut [T] ⓘ

§Safety

pub const fn range_inclusive(slice: &[T], start: usize, end: usize) -> &[T] ⓘ

§Panics

pub const fn range_inclusive_checked( slice: &[T], start: usize, end: usize, ) -> Option<&[T]> ⓘ

§Features

pub const unsafe fn range_inclusive_unchecked( slice: &[T], start: usize, end: usize, ) -> &[T] ⓘ

§Safety

pub const fn range_inclusive_mut( slice: &mut [T], start: usize, end: usize, ) -> &mut [T] ⓘ

§Panics

pub const fn range_inclusive_mut_checked( slice: &mut [T], start: usize, end: usize, ) -> Option<&mut [T]> ⓘ

§Features

pub const unsafe fn range_inclusive_mut_unchecked( slice: &mut [T], start: usize, end: usize, ) -> &mut [T] ⓘ

§Safety

impl<T> Slice<T>

§take* API methods for subslicing.

pub const fn take_first(slice: &[T], n: usize) -> &[T] ⓘ

§Panics

pub const fn take_first_checked(slice: &[T], n: usize) -> Option<&[T]> ⓘ

pub const unsafe fn take_first_unchecked(slice: &[T], n: usize) -> &[T] ⓘ

§Safety

Struct Slice

§`core::slice` namespaced methods.

pub fn clone(dst: &mut [T], src: &[T])
where T: Clone,

pub const fn copy(dst: &mut [T], src: &[T])
where T: Copy,

§`range*` API methods for subslicing.

§`take*` API methods for subslicing.

§`split` API methods for subslicing.

§`chunk` API methods for subslicing.