Struct BulkMut 

pub struct BulkMut<'a, T>
where
    T: 'a,
{ /* private fields */ }

Trait Implementations

impl<'a, T> Bulk for BulkMut<'a, T>

where T: 'a,

fn len(&self) -> usize

Returns the exact length of the bulk.

fn is_empty(&self) -> bool

Returns true if the bulk is empty.

fn first(self) -> Option<Self::Item>

where Self::Item:, Self: Sized,

Returns the first value, and discards the rest of the bulk.

fn nth<L>(self, n: L) -> Option<Self::Item>

where Self::Item:, Self: Sized, L: LengthValue,

Returns the n-th value, and discards the rest of the bulk.

fn for_each<F>(self, f: F)

where F: FnMut(&'a mut T),

Calls a closure on each element of a bulk.

fn try_for_each<F, R>(self, f: F) -> R

where &'a mut T:, F: FnMut(&'a mut T) -> R, R: Try<Output = ()>,

A bulk method that applies a fallible function to each item in the bulk, stopping at the first error and returning that error.

type MinLength = [(); 0]

type MaxLength = [()]

fn length(&self) -> Value<BulkLength<Self>>

fn last(self) -> Option<Self::Item>

where Self::Item:, Self: Sized,

Returns the last value, and discards the rest of the bulk.

fn nth_back<L>(self, n: L) -> Option<Self::Item>

where Self: Sized + DoubleEndedBulk, Self::Item:, L: LengthValue,

Returns the n-th value from the back, and discards the rest of the bulk.

fn many<NN, const N: usize>(self, n: NN) -> [Option<Self::Item>; N]

where Self: Sized, Self::Item:, NN: IntoBulk<Item = usize, IntoBulk: Bulk + StaticBulk<Array<()> = [(); N]>>,

fn par(self) -> Map<Self, impl Fn(Self::Item) -> Ready<Self::Item>>

where Self: Sized,

fn for_each_async<F>(self, f: F) -> ForEachAsync<Self, F>

where Self: BufferableBulk + Sized, F: FnMut<(Self::Item,), Output: Future<Output = ()>>,

Calls an asynchronous closure once on each element of a bulk in an arbitrary execution order.

fn try_for_each_async<F>(self, f: F) -> TryForEachAsync<Self, F>

where Self: BufferableBulk + Sized, F: FnMut<(Self::Item,), Output: Future<Output: Try<Output = ()>>>,

Applies a fallible asynchronous function once to each item in an arbitrary execution order.

fn fold<B, F>(self, init: B, f: F) -> B

where Self: Sized, B:, F: FnMut(B, Self::Item) -> B,

Folds every element into an accumulator by applying an operation, returning the final result.

fn rfold<B, F>(self, init: B, f: F) -> B

where Self: Sized + DoubleEndedBulk, B:, F: FnMut(B, Self::Item) -> B,

Reduces the bulks’s elements to a single, final value, starting from the back.

fn try_fold<B, F, R>(self, init: B, f: F) -> R

where B:, Self: Sized, Self::Item:, F: FnMut(B, Self::Item) -> R, R: Try<Output = B>,

fn try_rfold<B, F, R>(self, init: B, f: F) -> R

where B:, Self: Sized + DoubleEndedBulk, Self::Item:, F: FnMut(B, Self::Item) -> R, R: Try<Output = B>,

fn reduce<F>(self, f: F) -> Option<Self::Item>

where Self: Sized, Self::Item:, F: FnMut(Self::Item, Self::Item) -> Self::Item,

Reduces the elements to a single one, by repeatedly applying a reducing operation.

fn reduce_async<F>(self, f: F) -> ReduceAsync<Self, F>

where Self: BufferableBulk + Sized, F: FnMut<(Self::Item, Self::Item), Output: Future<Output = Self::Item>>,

Reduces the elements to a single one, by concurrently applying a reducing operation, by way of divide and conquer.

fn try_reduce<F, R>( self, f: F, ) -> <R::Residual as Residual<Option<R::Output>>>::TryType

where Self: Sized, Self::Item:, F: FnMut(Self::Item, Self::Item) -> R, R: Try<Output = Self::Item, Residual: Residual<Option<Self::Item>, TryType: Try>>,

Reduces the elements to a single one by repeatedly applying a reducing operation. If the closure returns a failure, the failure is propagated back to the caller immediately.

fn try_reduce_async<F, R>(self, f: F) -> TryReduceAsync<Self, F, R>

where Self: BufferableBulk + Sized, F: FnMut<(Self::Item, Self::Item), Output: Future<Output = R>>, R: Try<Output = Self::Item, Residual: Residual<Option<Self::Item>>>,

fn all<F>(self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> bool, Self::Item:,

Tests if every element of the bulk matches a predicate.

fn all_async<F>(self, condition: F) -> AllAsync<Self, F>

where Self: BufferableBulk + Sized, F: FnMut<(Self::Item,), Output: Future<Output = bool>>,

Tests if every element of the bulk matches an asynchronous predicate.

fn any<F>(self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> bool, Self::Item:,

Tests if any element of the bulk matches a predicate.

fn any_async<F>(self, condition: F) -> AnyAsync<Self, F>

where Self: BufferableBulk + Sized, F: FnMut<(Self::Item,), Output: Future<Output = bool>>,

Tests if any element of the bulk matches an asynchronous predicate.

fn find<P>(self, predicate: P) -> Option<Self::Item>

where Self: Sized, Self::Item:, P: FnMut(&Self::Item) -> bool,

Searches for an element of a bulk that satisfies a predicate.

fn rfind<P>(self, predicate: P) -> Option<Self::Item>

where Self: Sized + DoubleEndedBulk, P: FnMut(&Self::Item) -> bool, Self::Item:,

Searches for an element of a bulk from the back that satisfies a predicate.

fn find_map<B, F>(self, mapper: F) -> Option<B>

where Self: Sized, Self::Item:, F: FnMut(Self::Item) -> Option<B>, B:,

Applies function to the elements of the bulk and returns the first non-none result.

fn find_map_async<B, F>(self, f: F) -> FindMapAsync<Self, B, F>

where Self: BufferableBulk + Sized, F: FnMut<(Self::Item,), Output: Future<Output = Option<B>>>,

fn try_find<F, R>( self, predicate: F, ) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType

where Self: Sized, Self::Item:, F: FnMut(&Self::Item) -> R, R: Try<Output = bool, Residual: Residual<Option<Self::Item>>>,

Applies function to the elements of the bulk and returns the first true result or the first error.

fn position<P>(self, predicate: P) -> Option<usize>

where Self: Sized, Self::Item:, P: FnMut(Self::Item) -> bool,

Searches for an element in a bulk, returning its index.

fn position_async<F>(self, f: F) -> PositionAsync<Self, F>

where Self: BufferableBulk + Sized, F: FnMut<(Self::Item,), Output: Future<Output = bool>>,

fn rposition<P>(self, predicate: P) -> Option<usize>

where P: FnMut(Self::Item) -> bool, Self::Item:, Self: Sized + DoubleEndedBulk,

Searches for an element in a bulk from the right, returning its index.

fn max(self) -> Option<Self::Item>

where Self: Sized, Self::Item: Ord,

Returns the maximum element of a bulk.

fn min(self) -> Option<Self::Item>

where Self: Sized, Self::Item: Ord,

Returns the minimum element of a bulk.

fn max_by_key<B, F>(self, keygen: F) -> Option<Self::Item>

where Self: Sized, Self::Item:, F: FnMut(&Self::Item) -> B, B: Ord,

Returns the element that gives the maximum value from the specified function.

fn max_by<F>(self, compare: F) -> Option<Self::Item>

where Self: Sized, Self::Item:, F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the maximum value with respect to the specified comparison function.

fn min_by_key<B, F>(self, keygen: F) -> Option<Self::Item>

where Self: Sized, Self::Item:, F: FnMut(&Self::Item) -> B, B: Ord,

Returns the element that gives the minimum value from the specified function.

fn min_by<F>(self, compare: F) -> Option<Self::Item>

where Self: Sized, Self::Item:, F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the minimum value with respect to the specified comparison function.

fn step_by<L>(self, step: L) -> StepBy<Self, L::Length<()>>

where Self: Sized, L: LengthValue,

Creates a bulk starting at the same point, but stepping by the given amount at each iteration.

fn chain<U>(self, other: U) -> Chain<Self, U::IntoBulk>

where Self: Sized, U: IntoBulk<Item = Self::Item>,

Takes two bulks and creates a new bulk over both in sequence.

fn zip<U>( self, other: U, ) -> Zip<Self, <<U as IntoContained>::IntoContained as IntoBulk>::IntoBulk>

where Self: Sized, U: IntoContainedBy<Self>,

‘Zips up’ two bulks or iterators into a single bulk of pairs. One of them must be a bulk.

fn merge<U, F, O>(self, other: U, merger: F) -> Merge<Self, U::IntoBulk, F>

where Self: Sized, U: IntoBulk, Self::Item: Into<O>, U::Item: Into<O>, F: FnMut(Self::Item, U::Item) -> O,

Merges two bulks or iterators into a single bulk using a merging function.

fn intersperse(self, separator: Self::Item) -> Intersperse<Self>

where Self: Sized, Self::Item: Clone,

Creates a new bulk which places a copy of separator between adjacent items of the original bulk.

fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>

where Self: Sized, G: FnMut() -> Self::Item,

Creates a new bulk which places an item generated by separator between adjacent items of the original bulk.

fn map<B, F>(self, f: F) -> Map<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> B,

Takes a closure and creates a bulk which calls that closure on each element.

fn enumerate(self) -> Enumerate<Self>

where Self: Sized,

Creates a bulk which gives the current index together with its values.

fn enumerate_from<U>(self, initial_count: U) -> EnumerateFrom<Self, U>

where Self: Sized, U: Step + Copy,

Creates a bulk which gives the current index counting from a given initial index together with its values.

fn skip<L>(self, n: L) -> Skip<Self, L::Length<()>>

where Self: Sized, L: LengthValue,

Creates a bulk that skips the first n elements.

fn take<L>(self, n: L) -> Take<Self, L::Length<()>>

where Self: Sized, L: LengthValue,

Creates a bulk for the first n elements, or fewer if the underlying bulk/iterator is shorter.

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, F>

where Self: Sized, U: IntoBulk<IntoBulk: StaticBulk>, F: FnMut(Self::Item) -> U,

Creates a bulk that works like map, but flattens nested structure.

fn flatten(self) -> Flatten<Self>

where Self: Sized, Self::Item: IntoBulk<IntoBulk: StaticBulk>,

Creates a bulk that flattens nested structure.

fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>

where Self: Sized, F: FnMut(&[Self::Item; N]) -> R,

Calls the given function f for each contiguous window of size N over self and returns a bulk of the outputs of f. The windows during mapping will overlap.

fn inspect<F>(self, f: F) -> Inspect<Self, F>

where Self: Sized, F: FnMut(&Self::Item),

Does something with each element of a bulk, passing the value on.

fn mutate<F>(self, f: F) -> Mutate<Self, F>

where Self: Sized, F: FnMut(&mut Self::Item),

Mutates with each element of a bulk, passing the value on.

fn collect<C, A>(self) -> C

where Self: Sized, C: FromBulk<A>, A: CollectionAdapter<Elem = Self::Item> + CollectionStrategy<Self::MinLength, Self::MaxLength, C> + ?Sized,

Transforms a bulk into a collection.

fn collect_async<C, A>(self) -> CollectAsync<Self, C, A>

where Self: BufferableBulk + Sized, Self::Item: Future, C: FromBulk<A>, A: CollectionAdapter<Elem = <Self::Item as Future>::Output> + CollectionStrategy<Self::MinLength, Self::MaxLength, C> + ?Sized,

fn try_collect<C, A>( self, ) -> <<Self::Item as Try>::Residual as Residual<C>>::TryType

where Self: Sized, C: FromBulk<A>, A: CollectionAdapter<Elem = <Self::Item as Try>::Output> + TryCollectionStrategy<Self::MinLength, Self::MaxLength, C> + ?Sized, Self::Item: Try<Residual: Residual<C, TryType: Try>>,

Fallibly transforms a bulk into a collection, short circuiting if a failure is encountered.

fn try_collect_async<C, A>(self) -> TryCollectAsync<Self, C, A>

where Self: BufferableBulk + Sized, C: FromBulk<A>, A: CollectionAdapter<Elem = <<Self::Item as Future>::Output as Try>::Output> + TryCollectionStrategy<Self::MinLength, Self::MaxLength, C> + ?Sized, Self::Item: Future<Output: Try<Residual: Residual<C>>>,

fn collect_nearest(self) -> <BulkLength<Self> as Nearest>::NearestFrom<Self>

where Self: Sized, BulkLength<Self>: Nearest, Self::Item:,

fn collect_nearest_async( self, ) -> CollectAsync<Self, <BulkLength<Self> as Nearest>::NearestAsyncFrom<Self>, <BulkLength<Self> as Nearest>::NearestAsyncStrategyFrom<Self>>

where Self: BufferableBulk + Sized, BulkLength<Self>: Nearest, Self::Item: Future,

fn try_collect_nearest( self, ) -> <<Self::Item as Try>::Residual as Residual<<BulkLength<Self> as Nearest>::TryNearestFrom<Self>>>::TryType

where Self: Sized, BulkLength<Self>: Nearest, Self::Item: Try<Output, Residual: Residual<<BulkLength<Self> as Nearest>::TryNearestFrom<Self>>>,

fn try_collect_nearest_async( self, ) -> TryCollectAsync<Self, <BulkLength<Self> as Nearest>::TryNearestAsyncFrom<Self>, <BulkLength<Self> as Nearest>::TryNearestAsyncStrategyFrom<Self>>

where Self: BufferableBulk + Sized, BulkLength<Self>: Nearest, Self::Item: Future<Output: Try<Residual: Residual<<BulkLength<Self> as Nearest>::TryNearestAsyncFrom<Self>>>>,

fn collect_array( self, ) -> <Self as StaticBulk>::Array<<Self as IntoIterator>::Item>

where Self: StaticBulk,

Transforms a statically sized bulk into an array. The bulk must implement StaticBulk.

fn collect_array_async(self) -> CollectArrayAsync<Self>

where Self: StaticBulk, Self::Item: Future,

fn try_collect_array( self, ) -> <<Self::Item as Try>::Residual as Residual<Self::Array<<Self::Item as Try>::Output>>>::TryType

where Self: StaticBulk<Item: Try<Residual: Residual<Self::Array<<Self::Item as Try>::Output>, TryType: Try>, Output>> + Bulk,

Fallibly transforms a statically sized bulk into an array, short circuiting if a failure is encountered. The bulk must implement StaticBulk.

fn try_collect_array_async(self) -> TryCollectArrayAsync<Self>

where Self: StaticBulk, Self::Item: Future<Output: Try<Residual: Residual<Self::Array<<<Self::Item as Future>::Output as Try>::Output>>>>,

fn resize<N>(self, n: N, element: Self::Item) -> Resize<Self, N::Length<()>>

where Self: Sized, Self::Item: Copy, N: LengthValue,

Resizes a bulk, padding it with copies of a given value of element if too short, or truncating it if too long. The resuling bulk will have an exact length given by n.

fn resize_with<F, N>( self, n: N, padder: F, ) -> ResizeWith<Self, F, N::Length<()>>

where Self: Sized, N: LengthValue, F: FnMut() -> Self::Item,

Resizes a bulk, padding it with the output of padder if too short, or truncating it if too long. The resuling bulk will have an exact length given by n.

fn rev(self) -> Rev<Self>

where Self: Sized + DoubleEndedBulk,

Reverses a bulks’s direction.

fn copied<'a, T>(self) -> Copied<Self>

where T: Copy + 'a, Self: Sized + Bulk<Item = &'a T>,

Creates a bulk which copies all of its elements.

fn cloned<'a, T>(self) -> Cloned<Self>

where T: Clone + 'a, Self: Sized + Bulk<Item = &'a T>,

Creates a bulk which clones all of its elements.

unsafe fn pinned_unchecked(self) -> Pinned<Self>

where Self: Sized, Self::Item: Deref,

Safety

fn pinned(self) -> Pinned<Self>

where Self: Sized, Self::Item: Deref<Target: Unpin>,

unsafe fn unpinned_unchecked<T>(self) -> Unpinned<Self, T>

where Self: Sized + Bulk<Item = Pin<T>>, T: Deref,

Safety

fn unpinned<T>(self) -> Unpinned<Self, T>

where Self: Sized + Bulk<Item = Pin<T>>, T: Deref<Target: Unpin>,

fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>

where Self: Sized,

Returns a bulk of N elements of the bulk at a time.

fn split_at<L>(self, n: L) -> (Self::Left, Self::Right)

where Self: SplitBulk<L> + Sized, L: LengthValue,

Splits a bulk in two at a specified index.

fn rsplit_at<L>(self, n: L) -> (Self::Left, Self::Right)

where Self: SplitBulk<SaturatingSub<<BulkLength<Self> as Length>::Value, L>> + Sized, L: LengthValue,

Splits a bulk in two at a specified reversed index.

fn swap<S>(self, lhs: impl LengthValue, rhs: impl LengthValue)

where Self: Sized, Self::Item: BorrowMut<S>,

Consumes the bulk, and swaps two elements of it. Items must be mutably dereferenceable.

fn try_swap<S>( self, lhs: impl LengthValue, rhs: impl LengthValue, ) -> Result<(), OutOfRange>

where Self: Sized, Self::Item: BorrowMut<S>,

Consumes the bulk, and swaps two elements of it. Items must be mutably dereferenceable.

fn sum_from<T>(self, from: T) -> T

where T: Add<Self::Item, Output = T>, Self: Sized,

fn product_from<T>(self, from: T) -> T

where T: Mul<Self::Item, Output = T>, Self: Sized,

impl<'a, T> DoubleEndedBulk for BulkMut<'a, T>

fn rev_for_each<F>(self, f: F)

where F: FnMut(&'a mut T),

Calls a closure on each element of a bulk in reverse.

fn try_rev_for_each<F, R>(self, f: F) -> R

where &'a mut T:, F: FnMut(&'a mut T) -> R, R: Try<Output = ()>,

A bulk method that applies a fallible function to each item in the bulk in reverse, stopping at the first error and returning that error.

impl<'a, T> IntoIterator for BulkMut<'a, T>

where T: 'a, &'a mut [T]: IntoIterator,

type Item = <&'a mut [T] as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <&'a mut [T] as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T, L> SplitBulk<L> for BulkMut<'a, T>

where L: LengthValue,

type Left = BulkMut<'a, T>

type Right = BulkMut<'a, T>

fn split_at(bulk: Self, n: L) -> (Self::Left, Self::Right)

where Self: Sized,

Splits a bulk in two at a specified index.