bulks/

bulk.rs

use core::{
    borrow::BorrowMut, cmp::Ordering, error::Error, fmt::Display, future::Ready, iter::Step, marker::Destruct, ops::{Add, ControlFlow, Deref, FromResidual, Mul, Residual, Try}, pin::Pin
};

use array_trait::length::{self, Length, LengthValue, Value};

use crate::{
    ArrayChunks, Chain, Cloned, CollectionAdapter, CollectionStrategy, Copied, DoubleEndedBulk, Enumerate, EnumerateFrom, FlatMap, Flatten, FromBulk, Inspect,
    Intersperse, IntersperseWith, IntoBulk, IntoContained, IntoContainedBy, Map, MapWindows, Merge, Mutate, Nearest, Pinned, Resize, ResizeWith, Rev, Skip, SplitBulk,
    StaticBulk, StepBy, Take, TryCollectionStrategy, Unpinned, Zip, util
};

#[cfg(feature = "async")]
use crate::{
    AllAsync, AnyAsync, CollectArrayAsync, CollectAsync, FindMapAsync, ForEachAsync, PositionAsync, ReduceAsync, TryCollectArrayAsync, TryCollectAsync, TryForEachAsync, TryReduceAsync, util::BufferableBulk
};

pub type BulkLength<B> = <<B as Bulk>::MinLength as Length>::Intersect<<B as Bulk>::MaxLength>;

//fn _assert_is_dyn_compatible(_: &dyn Bulk<Item = ()>) {}

/// A trait for dealing with bulks.
///
/// This is the main bulk trait. For more about the concept of bulks
/// generally, please see the [crate-level documentation](crate). In particular, you
/// may want to know how to [implement `Bulk`][crate#implementing-bulk].
#[rustc_on_unimplemented(
    on(Self = "core::ops::range::RangeTo<Idx>", note = "you might have meant to use a bounded `Range`"),
    on(Self = "core::ops::range::RangeToInclusive<Idx>", note = "you might have meant to use a bounded `RangeInclusive`"),
    label = "`{Self}` is not a bulk",
    message = "`{Self}` is not a bulk"
)]
#[doc(notable_trait)]
#[must_use = "bulks are lazy and do nothing unless consumed"]
pub const trait Bulk: [const] IntoBulk<IntoBulk = Self>
{
    type MinLength: Length<Elem = ()> + ?Sized = [(); 0];
    type MaxLength: Length<Elem = ()> + ?Sized = [()];

    /// Returns the exact length of the bulk.
    ///
    /// This function has the same safety guarantees as the
    /// [`Iterator::size_hint`] function.
    ///
    /// Similar to [`ExactSizeIterator::len`].
    ///
    /// # Examples
    ///
    /// Basic usage:
    ///
    /// ```
    /// use bulks::*;
    ///
    /// // a finite range knows exactly how many times it will iterate
    /// let mut range = (0..5).into_bulk();
    ///
    /// let len = range.len();
    ///
    /// assert_eq!(len, 5);
    /// ```
    #[track_caller]
    fn len(&self) -> usize;

    fn length(&self) -> Value<BulkLength<Self>>
    {
        let len = self.len();
        let length = length::value::or_len(len);
        assert!(length::value::len(length) == len);
        length
    }

    /// Returns `true` if the bulk is empty.
    ///
    /// This method has a default implementation using
    /// [`Bulk::len()`], so you don't need to implement it yourself.
    ///
    /// Similar to [`ExactSizeIterator::is_empty`].
    ///
    /// # Examples
    ///
    /// Basic usage:
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let one_element = bulks::once(0);
    /// assert!(!one_element.is_empty());
    /// ```
    #[inline]
    #[track_caller]
    fn is_empty(&self) -> bool
    {
        length::value::eq(self.length(), [(); 0])
    }

    /// Returns the first value, and discards the rest of the bulk.
    ///
    /// Returns [`None`] if the bulk is empty.
    ///
    /// # Examples
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [1, 2, 3];
    ///
    /// let bulk = a.bulk();
    ///
    /// let a1 = bulk.first();
    /// assert_eq!(a1, Some(&1));
    /// ```
    fn first(self) -> Option<Self::Item>
    where
        Self::Item: [const] Destruct,
        Self: Sized
    {
        const fn break_on_first<T>(x: T) -> ControlFlow<T>
        {
            ControlFlow::Break(x)
        }

        match self.try_for_each(break_on_first)
        {
            ControlFlow::Break(first) => Some(first),
            ControlFlow::Continue(()) => None
        }
    }

    /// Returns the last value, and discards the rest of the bulk.
    ///
    /// Returns [`None`] if the bulk is empty.
    ///
    /// # Examples
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [1, 2, 3];
    ///
    /// let bulk = a.bulk();
    ///
    /// let a1 = bulk.last();
    /// assert_eq!(a1, Some(&3));
    /// ```
    fn last(self) -> Option<Self::Item>
    where
        Self::Item: [const] Destruct,
        Self: Sized
    {
        const fn store<T>(_: T, x: T) -> T
        where
            T: [const] Destruct
        {
            x
        }

        self.reduce(store)
    }

    /// Returns the `n`-th value from the back, and discards the rest of the bulk.
    ///
    /// Returns [`None`] if index `n` is out of bounds.
    ///
    /// # Examples
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [1, 2, 3];
    ///
    /// let bulk = a.bulk();
    ///
    /// // The bulk is consumed, so it must be cloned each time. Don't actually do this.
    /// let a1 = bulk.clone().last();
    /// let a2 = bulk.clone().nth_back(1);
    /// let a3 = bulk.clone().nth_back(2);
    /// let a4 = bulk.clone().nth_back(3);
    ///
    /// assert_eq!(a1, Some(&3));
    /// assert_eq!(a2, Some(&2));
    /// assert_eq!(a3, Some(&1));
    /// assert_eq!(a4, None);
    /// ```
    fn nth_back<L>(self, n: L) -> Option<Self::Item>
    where
        Self: Sized + [const] DoubleEndedBulk,
        Self::Item: [const] Destruct,
        L: LengthValue
    {
        self.rev().skip(n).first()
    }

    /// Returns the `n`-th value, and discards the rest of the bulk.
    ///
    /// Returns [`None`] if index `n` is out of bounds.
    ///
    /// # Examples
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [1, 2, 3];
    ///
    /// let bulk = a.bulk();
    ///
    /// // The bulk is consumed, so it must be cloned each time. Don't actually do this.
    /// let a1 = bulk.clone().first();
    /// let a2 = bulk.clone().nth(1);
    /// let a3 = bulk.clone().nth(2);
    /// let a4 = bulk.clone().nth(3);
    ///
    /// assert_eq!(a1, Some(&1));
    /// assert_eq!(a2, Some(&2));
    /// assert_eq!(a3, Some(&3));
    /// assert_eq!(a4, None);
    /// ```
    fn nth<L>(self, n: L) -> Option<Self::Item>
    where
        Self: Sized,
        Self::Item: [const] Destruct,
        L: LengthValue
    {
        self.skip(n).first()
    }

    fn many<NN, const N: usize>(self, n: NN) -> [Option<Self::Item>; N]
    where
        Self: Sized,
        Self::Item: [const] Destruct,
        NN: [const] IntoBulk<Item = usize, IntoBulk: [const] Bulk + StaticBulk<Array<()> = [(); N]>>
    {
        struct Functor<'a, T, const N: usize>
        {
            done: usize,
            refs: &'a mut [Result<T, usize>; N]
        }
        impl<'a, T, const N: usize> Functor<'a, T, N>
        {
            const fn update(&mut self, i: usize, x: T)
            where
                T: [const] Destruct
            {
                const trait ManySpec: Sized
                {
                    fn update<const N: usize>(refs: &mut [Result<Self, usize>; N], k: &mut usize, i: usize, x: Self);
                }
                const impl<T> ManySpec for T
                where
                    T: [const] Destruct
                {
                    default fn update<const N: usize>(refs: &mut [Result<Self, usize>; N], k: &mut usize, i: usize, x: Self)
                    {
                        while *k < N
                        {
                            if let Err(j) = &refs[*k]
                            {
                                if *j == i
                                {
                                    refs[*k] = Ok(x);
                                    return;
                                }
                                else
                                {
                                    break;
                                }
                            }
                            *k += 1
                        }
                        let mut n = *k;
                        while n < N
                        {
                            if let Err(j) = &refs[n]
                                && *j == i
                            {
                                refs[n] = Ok(x);
                                return;
                            }
                            n += 1
                        }
                    }
                }
                const impl<T> ManySpec for T
                where
                    T: Copy + [const] Destruct
                {
                    fn update<const N: usize>(refs: &mut [Result<Self, usize>; N], k: &mut usize, i: usize, x: Self)
                    {
                        while *k < N
                        {
                            if let Err(j) = &refs[*k]
                            {
                                if *j == i { refs[*k] = Ok(x) } else { break }
                            }
                            *k += 1
                        }
                        let mut n = *k;
                        while n < N
                        {
                            if let Err(j) = &refs[n]
                                && *j == i
                            {
                                refs[n] = Ok(x)
                            }
                            n += 1
                        }
                    }
                }

                ManySpec::update(self.refs, &mut self.done, i, x);
            }
        }

        const impl<'a, T, const N: usize> FnOnce<((usize, T),)> for Functor<'a, T, N>
        where
            T: [const] Destruct
        {
            type Output = ();

            extern "rust-call" fn call_once(mut self, args: ((usize, T),)) -> Self::Output
            {
                self.call_mut(args)
            }
        }
        const impl<'a, T, const N: usize> FnMut<((usize, T),)> for Functor<'a, T, N>
        where
            T: [const] Destruct
        {
            extern "rust-call" fn call_mut(&mut self, ((i, x),): ((usize, T),)) -> Self::Output
            {
                self.update(i, x);
            }
        }

        let mut refs = n.into_bulk().map(Err).collect_array();

        self.enumerate().for_each(Functor { done: 0, refs: &mut refs });

        refs.map(Result::ok)
    }

    #[cfg(feature = "async")]
    fn par(self) -> Map<Self, impl Fn(Self::Item) -> Ready<Self::Item>>
    where
        Self: Sized
    {
        self.map(core::future::ready)
    }

    /// Calls a closure on each element of a bulk.
    ///
    /// This is equivalent to using a [`for`] loop on the bulk, although
    /// `break` and `continue` are not possible from a closure. It's generally
    /// more idiomatic to use a `for` loop, but `for_each` may be more legible
    /// when processing items at the end of longer iterator chains. In some
    /// cases `for_each` may also be faster than a loop, because it will use
    /// internal iteration on adapters like [`Chain`](crate::Chain).
    ///
    /// [`for`]: ../../book/ch03-05-control-flow.html#looping-through-a-collection-with-for
    ///
    /// # Examples
    ///
    /// Basic usage:
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [1, 2, 3, 4];
    /// let mut x0 = 0;
    /// a.into_bulk()
    ///     .for_each(|x| {
    ///         assert_eq!(x, x0 + 1);
    ///         x0 = x;
    ///     })
    /// ```
    fn for_each<F>(self, f: F)
    where
        Self: Sized,
        F: [const] FnMut(Self::Item) + [const] Destruct;

    /// Calls an asynchronous closure once on each element of a bulk
    /// in an arbitrary execution order.
    ///
    /// # Examples
    ///
    /// Basic usage:
    ///
    /// ```
    /// use bulks::*;
    /// use core::time::Duration;
    ///
    /// let a = [1024, 512, 256];
    ///
    /// # tokio::runtime::Builder::new_multi_thread().enable_all().build().unwrap().block_on(async {
    /// a.into_bulk()
    ///     .for_each_async(async |n| {
    ///         tokio::time::sleep(Duration::from_millis(n)).await;
    ///     })
    ///     .await
    /// # })
    /// ```
    #[cfg(feature = "async")]
    #[rustc_non_const_trait_method]
    fn for_each_async<F>(self, f: F) -> ForEachAsync<Self, F>
    where
        Self: BufferableBulk + Sized,
        F: FnMut<(Self::Item,), Output: Future<Output = ()>>
    {
        ForEachAsync::new(self, f)
    }

    /// A bulk method that applies a fallible function to each item in the
    /// bulk, stopping at the first error and returning that error.
    ///
    /// This can also be thought of as the fallible form of [`for_each()`](Bulk::for_each)
    /// or as the stateless version of [`try_fold()`](Bulk::try_fold).
    ///
    /// # Examples
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = ["1", "2", "3", "4", "wrong"];
    /// let mut x0 = 0;
    /// let res = a.into_bulk()
    ///     .try_for_each(|x| {
    ///         let x = x.parse::<u32>().map_err(|_| x)?;
    ///         assert_eq!(x, x0 + 1);
    ///         x0 = x;
    ///         Ok(())
    ///     });
    /// assert_eq!(res, Err("wrong"))
    /// ```
    fn try_for_each<F, R>(self, f: F) -> R
    where
        Self: Sized,
        Self::Item: [const] Destruct,
        F: [const] FnMut(Self::Item) -> R + [const] Destruct,
        R: [const] Try<Output = ()>;

    /// Applies a fallible asynchronous function once to each item
    /// in an arbitrary execution order.
    ///
    /// # Example
    ///
    /// ```
    /// use bulks::*;
    /// use core::time::Duration;
    ///
    /// let a = ["1024", "512", "256", "lol"];
    ///
    /// # tokio::runtime::Builder::new_multi_thread().enable_all().build().unwrap().block_on(async {
    /// let res = a.into_bulk()
    ///     .try_for_each_async(async |n| {
    ///         let n = n.parse::<u64>().map_err(|_| n)?;
    ///         tokio::time::sleep(Duration::from_millis(n)).await;
    ///
    ///         panic!("Tasks will be cancelled before this point.");
    ///
    ///         Ok(())
    ///     })
    ///     .await;
    /// assert_eq!(res, Err("lol"))
    /// # })
    /// ```
    #[cfg(feature = "async")]
    #[rustc_non_const_trait_method]
    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 = ()>>>
    {
        TryForEachAsync::new(self, f)
    }

    /// Folds every element into an accumulator by applying an operation,
    /// returning the final result.
    ///
    /// `fold()` takes two arguments: an initial value, and a closure with two
    /// arguments: an 'accumulator', and an element. The closure returns the value that
    /// the accumulator should have for the next iteration.
    ///
    /// The initial value is the value the accumulator will have on the first
    /// call.
    ///
    /// After applying this closure to every element of the iterator, `fold()`
    /// returns the accumulator.
    ///
    /// This operation is sometimes called 'reduce' or 'inject'.
    ///
    /// Folding is useful whenever you have a collection of something, and want
    /// to produce a single value from it.
    ///
    /// Note: [`reduce()`](Bulk::reduce) can be used to use the first element as the initial
    /// value, if the accumulator type and item type is the same.
    ///
    /// Note: `fold()` combines elements in a *left-associative* fashion. For associative
    /// operators like `+`, the order the elements are combined in is not important, but for non-associative
    /// operators like `-` the order will affect the final result.
    /// For a *right-associative* version of `fold()`, see [`DoubleEndedBulk::rfold()`].
    ///
    /// # Note to Implementors
    ///
    /// Several of the other (forward) methods have default implementations in
    /// terms of this one, so try to implement this explicitly if it can
    /// do something better than the default `for` loop implementation.
    ///
    /// In particular, try to have this call `fold()` on the internal parts
    /// from which this iterator is composed.
    ///
    /// # Examples
    ///
    /// Basic usage:
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [1, 2, 3];
    ///
    /// // the sum of all of the elements of the array
    /// let sum = a.bulk().fold(0, |acc, x| acc + x);
    ///
    /// assert_eq!(sum, 6);
    /// ```
    ///
    /// Let's walk through each step of the iteration here:
    ///
    /// | element | acc | x | result |
    /// |---------|-----|---|--------|
    /// |         | 0   |   |        |
    /// | 1       | 0   | 1 | 1      |
    /// | 2       | 1   | 2 | 3      |
    /// | 3       | 3   | 3 | 6      |
    ///
    /// And so, our final result, `6`.
    ///
    /// This example demonstrates the left-associative nature of `fold()`:
    /// it builds a string, starting with an initial value
    /// and continuing with each element from the front until the back:
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let numbers = [1, 2, 3, 4, 5];
    ///
    /// let zero = "0".to_string();
    ///
    /// let result = numbers.bulk().fold(zero, |acc, &x| {
    ///     format!("({acc} + {x})")
    /// });
    ///
    /// assert_eq!(result, "(((((0 + 1) + 2) + 3) + 4) + 5)");
    /// ```
    #[doc(alias = "inject", alias = "foldl")]
    #[inline]
    fn fold<B, F>(self, init: B, f: F) -> B
    where
        Self: Sized,
        B: [const] Destruct,
        F: [const] FnMut(B, Self::Item) -> B + [const] Destruct
    {
        struct Closure<'a, B, F>
        {
            z: &'a mut Option<B>,
            f: F
        }
        const impl<'a, B, F, T> FnOnce<(T,)> for Closure<'a, B, F>
        where
            B: [const] Destruct,
            F: [const] FnOnce(B, T) -> B
        {
            type Output = ();

            extern "rust-call" fn call_once(self, (x,): (T,)) -> Self::Output
            {
                let Self { z, f } = self;
                let zz = unsafe { z.take().unwrap_unchecked() };
                let _ = z.insert((f)(zz, x));
            }
        }
        const impl<'a, B, F, T> FnMut<(T,)> for Closure<'a, B, F>
        where
            B: [const] Destruct,
            F: [const] FnMut(B, T) -> B
        {
            extern "rust-call" fn call_mut(&mut self, (x,): (T,)) -> Self::Output
            {
                let Self { z, f } = self;
                let zz = unsafe { z.take().unwrap_unchecked() };
                let _ = z.insert((f)(zz, x));
            }
        }

        let mut z = Some(init);
        self.for_each(Closure { z: &mut z, f });

        unsafe { z.unwrap_unchecked() }
    }

    /// Reduces the bulks's elements to a single, final value, starting from the back.
    ///
    /// This is the reverse version of [`Bulk::fold()`]: it takes elements
    /// starting from the back of the bulk.
    ///
    /// `rfold()` takes two arguments: an initial value, and a closure with two
    /// arguments: an 'accumulator', and an element. The closure returns the value that
    /// the accumulator should have for the next iteration.
    ///
    /// The initial value is the value the accumulator will have on the first
    /// call.
    ///
    /// After applying this closure to every element of the iterator, `rfold()`
    /// returns the accumulator.
    ///
    /// This operation is sometimes called 'reduce' or 'inject'.
    ///
    /// Folding is useful whenever you have a collection of something, and want
    /// to produce a single value from it.
    ///
    /// Note: `rfold()` combines elements in a *right-associative* fashion. For associative
    /// operators like `+`, the order the elements are combined in is not important, but for non-associative
    /// operators like `-` the order will affect the final result.
    /// For a *left-associative* version of `rfold()`, see [`Bulk::fold()`].
    ///
    /// # Examples
    ///
    /// Basic usage:
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [1, 2, 3];
    ///
    /// // the sum of all of the elements of a
    /// let sum = a.bulk()
    ///            .rfold(0, |acc, &x| acc + x);
    ///
    /// assert_eq!(sum, 6);
    /// ```
    ///
    /// This example demonstrates the right-associative nature of `rfold()`:
    /// it builds a string, starting with an initial value
    /// and continuing with each element from the back until the front:
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let numbers = [1, 2, 3, 4, 5];
    ///
    /// let zero = "0".to_string();
    ///
    /// let result = numbers.bulk().rfold(zero, |acc, &x| {
    ///     format!("({x} + {acc})")
    /// });
    ///
    /// assert_eq!(result, "(1 + (2 + (3 + (4 + (5 + 0)))))");
    /// ```
    #[doc(alias = "foldr")]
    #[inline]
    fn rfold<B, F>(self, init: B, f: F) -> B
    where
        Self: Sized + [const] DoubleEndedBulk,
        B: [const] Destruct,
        F: [const] FnMut(B, Self::Item) -> B + [const] Destruct
    {
        struct Closure<'a, B, F>
        {
            z: &'a mut Option<B>,
            f: F
        }
        const impl<'a, B, F, T> FnOnce<(T,)> for Closure<'a, B, F>
        where
            B: [const] Destruct,
            F: [const] FnOnce(B, T) -> B
        {
            type Output = ();

            extern "rust-call" fn call_once(self, (x,): (T,)) -> Self::Output
            {
                let Self { z, f } = self;
                let zz = unsafe { z.take().unwrap_unchecked() };
                let _ = z.insert((f)(zz, x));
            }
        }
        const impl<'a, B, F, T> FnMut<(T,)> for Closure<'a, B, F>
        where
            B: [const] Destruct,
            F: [const] FnMut(B, T) -> B
        {
            extern "rust-call" fn call_mut(&mut self, (x,): (T,)) -> Self::Output
            {
                let Self { z, f } = self;
                let zz = unsafe { z.take().unwrap_unchecked() };
                let _ = z.insert((f)(zz, x));
            }
        }

        let mut z = Some(init);
        self.rev_for_each(Closure { z: &mut z, f });

        unsafe { z.unwrap_unchecked() }
    }

    fn try_fold<B, F, R>(self, init: B, f: F) -> R
    where
        B: [const] Destruct,
        Self: Sized,
        Self::Item: [const] Destruct,
        F: [const] FnMut(B, Self::Item) -> R + [const] Destruct,
        R: [const] Try<Output = B>
    {
        struct Closure<'a, B, F>
        {
            z: &'a mut Option<B>,
            f: F
        }
        const impl<'a, B, F, T, R> FnOnce<(T,)> for Closure<'a, B, F>
        where
            B: [const] Destruct,
            F: [const] FnOnce(B, T) -> R,
            R: [const] Try<Output = B>
        {
            type Output = ControlFlow<R::Residual, ()>;

            extern "rust-call" fn call_once(self, (x,): (T,)) -> Self::Output
            {
                let Self { z, f } = self;
                let zz = unsafe { z.take().unwrap_unchecked() };
                let _ = z.insert(f(zz, x).branch()?);
                ControlFlow::Continue(())
            }
        }
        const impl<'a, B, F, T, R> FnMut<(T,)> for Closure<'a, B, F>
        where
            B: [const] Destruct,
            F: [const] FnMut(B, T) -> R,
            R: [const] Try<Output = B>
        {
            extern "rust-call" fn call_mut(&mut self, (x,): (T,)) -> Self::Output
            {
                let Self { z, f } = self;
                let zz = unsafe { z.take().unwrap_unchecked() };
                let _ = z.insert(f(zz, x).branch()?);
                ControlFlow::Continue(())
            }
        }

        let mut z = Some(init);
        match self.try_for_each(Closure { z: &mut z, f })
        {
            ControlFlow::Break(residual) => R::from_residual(residual),
            ControlFlow::Continue(()) => R::from_output(unsafe { z.unwrap_unchecked() })
        }
    }

    fn try_rfold<B, F, R>(self, init: B, f: F) -> R
    where
        B: [const] Destruct,
        Self: Sized + [const] DoubleEndedBulk,
        Self::Item: [const] Destruct,
        F: [const] FnMut(B, Self::Item) -> R + [const] Destruct,
        R: [const] Try<Output = B>
    {
        struct Closure<'a, B, F>
        {
            z: &'a mut Option<B>,
            f: F
        }
        const impl<'a, B, F, T, R> FnOnce<(T,)> for Closure<'a, B, F>
        where
            B: [const] Destruct,
            F: [const] FnOnce(B, T) -> R,
            R: [const] Try<Output = B>
        {
            type Output = ControlFlow<R::Residual, ()>;

            extern "rust-call" fn call_once(self, (x,): (T,)) -> Self::Output
            {
                let Self { z, f } = self;
                let zz = unsafe { z.take().unwrap_unchecked() };
                let _ = z.insert(f(zz, x).branch()?);
                ControlFlow::Continue(())
            }
        }
        const impl<'a, B, F, T, R> FnMut<(T,)> for Closure<'a, B, F>
        where
            B: [const] Destruct,
            F: [const] FnMut(B, T) -> R,
            R: [const] Try<Output = B>
        {
            extern "rust-call" fn call_mut(&mut self, (x,): (T,)) -> Self::Output
            {
                let Self { z, f } = self;
                let zz = unsafe { z.take().unwrap_unchecked() };
                let _ = z.insert(f(zz, x).branch()?);
                ControlFlow::Continue(())
            }
        }

        let mut z = Some(init);
        match self.try_rev_for_each(Closure { z: &mut z, f })
        {
            ControlFlow::Break(residual) => R::from_residual(residual),
            ControlFlow::Continue(()) => R::from_output(unsafe { z.unwrap_unchecked() })
        }
    }

    /// Reduces the elements to a single one, by repeatedly applying a reducing
    /// operation.
    ///
    /// If the bulk is empty, returns [`None`]; otherwise, returns the
    /// result of the reduction.
    ///
    /// The reducing function is a closure with two arguments: an 'accumulator', and an element.
    /// For bulks with at least one element, this is the same as [`fold()`]
    /// with the first element of the bulk as the initial accumulator value, folding
    /// every subsequent element into it.
    ///
    /// [`fold()`]: Bulk::fold
    ///
    /// # Example
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let reduced: i32 = (1..10).into_bulk().reduce(|acc, e| acc + e).unwrap_or(0);
    /// assert_eq!(reduced, 45);
    ///
    /// // Which is equivalent to doing it with `fold`:
    /// let folded: i32 = (1..10).into_bulk().fold(0, |acc, e| acc + e);
    /// assert_eq!(reduced, folded);
    /// ```
    fn reduce<F>(self, f: F) -> Option<Self::Item>
    where
        Self: Sized,
        Self::Item: [const] Destruct,
        F: [const] FnMut(Self::Item, Self::Item) -> Self::Item + [const] Destruct
    {
        struct Closure<F>
        {
            f: F
        }
        const impl<F, T> FnOnce<(Option<T>, T)> for Closure<F>
        where
            F: [const] FnOnce(T, T) -> T + [const] Destruct
        {
            type Output = Option<T>;

            extern "rust-call" fn call_once(self, (z, x): (Option<T>, T)) -> Self::Output
            {
                let Self { f } = self;

                match z
                {
                    Some(z) => Some(f(z, x)),
                    None => Some(x)
                }
            }
        }
        const impl<F, T> FnMut<(Option<T>, T)> for Closure<F>
        where
            F: [const] FnMut(T, T) -> T
        {
            extern "rust-call" fn call_mut(&mut self, (z, x): (Option<T>, T)) -> Self::Output
            {
                let Self { f } = self;

                match z
                {
                    Some(z) => Some(f(z, x)),
                    None => Some(x)
                }
            }
        }

        self.fold(None, Closure { f })
    }

    /// Reduces the elements to a single one, by concurrently applying a reducing
    /// operation, by way of divide and conquer.
    ///
    /// If the bulk is empty, returns [`None`]; otherwise, returns the
    /// result of the reduction.
    ///
    /// # Example
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [1, 2, 3];
    ///
    /// # tokio::runtime::Builder::new_multi_thread().enable_all().build().unwrap().block_on(async {
    /// let n = a.into_bulk().reduce_async(async |a, b| a + b).await;
    ///
    /// assert_eq!(n, Some(1 + 2 + 3))
    /// # })
    /// ```
    #[cfg(feature = "async")]
    #[rustc_non_const_trait_method]
    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>>
    {
        ReduceAsync::new(self, f)
    }

    /// 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.
    ///
    /// The return type of this method depends on the return type of the closure. If the closure
    /// returns `Result<Self::Item, E>`, then this function will return `Result<Option<Self::Item>,
    /// E>`. If the closure returns `Option<Self::Item>`, then this function will return
    /// `Option<Option<Self::Item>>`.
    ///
    /// When called on an empty bulk, this function will return either `Some(None)` or
    /// `Ok(None)` depending on the type of the provided closure.
    ///
    /// For bulks with at least one element, this is essentially the same as calling
    /// [`try_fold()`] with the first element of the bulk as the initial accumulator value.
    ///
    /// [`try_fold()`]: Bulk::try_fold
    ///
    /// # Examples
    ///
    /// Safely calculate the sum of a series of numbers:
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let numbers: Vec<usize> = vec![10, 20, 5, 23, 0];
    /// let sum = numbers.into_bulk().try_reduce(|x, y| x.checked_add(y));
    /// assert_eq!(sum, Some(Some(58)));
    /// ```
    ///
    /// Determine when a reduction short circuited:
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let numbers = vec![1, 2, 3, usize::MAX, 4, 5];
    /// let sum = numbers.into_bulk().try_reduce(|x, y| x.checked_add(y));
    /// assert_eq!(sum, None);
    /// ```
    ///
    /// Determine when a reduction was not performed because there are no elements:
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let numbers: Vec<usize> = Vec::new();
    /// let sum = numbers.into_bulk().try_reduce(|x, y| x.checked_add(y));
    /// assert_eq!(sum, Some(None));
    /// ```
    ///
    /// Use a [`Result`] instead of an [`Option`]:
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let numbers = vec!["1", "2", "3", "4", "5"];
    /// let max: Result<Option<_>, <usize as std::str::FromStr>::Err> =
    ///     numbers.into_bulk().try_reduce(|x, y| {
    ///         if x.parse::<usize>()? > y.parse::<usize>()? { Ok(x) } else { Ok(y) }
    ///     });
    /// assert_eq!(max, Ok(Some("5")));
    /// ```
    fn try_reduce<F, R>(self, f: F) -> <R::Residual as Residual<Option<R::Output>>>::TryType
    where
        Self: Sized,
        Self::Item: [const] Destruct,
        F: [const] FnMut(Self::Item, Self::Item) -> R + [const] Destruct,
        R: [const] Try<Output = Self::Item, Residual: Residual<Option<Self::Item>, TryType: [const] Try> + [const] Destruct>
    {
        struct Closure<F>
        {
            f: F
        }
        const impl<F, T, R> FnOnce<(Option<T>, T)> for Closure<F>
        where
            F: [const] FnOnce(T, T) -> R + [const] Destruct,
            R: [const] Try<Output = T, Residual: [const] Destruct>
        {
            type Output = ControlFlow<R::Residual, Option<T>>;

            extern "rust-call" fn call_once(self, (z, x): (Option<T>, T)) -> Self::Output
            {
                let Self { f } = self;

                ControlFlow::Continue(Some(match z
                {
                    Some(z) => f(z, x).branch()?,
                    None => x
                }))
            }
        }
        const impl<F, T, R> FnMut<(Option<T>, T)> for Closure<F>
        where
            F: [const] FnMut(T, T) -> R,
            R: [const] Try<Output = T, Residual: [const] Destruct>
        {
            extern "rust-call" fn call_mut(&mut self, (z, x): (Option<T>, T)) -> Self::Output
            {
                let Self { f } = self;

                ControlFlow::Continue(Some(match z
                {
                    Some(z) => f(z, x).branch()?,
                    None => x
                }))
            }
        }

        match self.try_fold(None, Closure { f })
        {
            ControlFlow::Break(residual) => FromResidual::from_residual(residual),
            ControlFlow::Continue(output) => Try::from_output(output)
        }
    }

    #[cfg(feature = "async")]
    #[rustc_non_const_trait_method]
    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>>>
    {
        TryReduceAsync::new(self, f)
    }

    /// Tests if every element of the bulk matches a predicate.
    ///
    /// `all()` takes a closure that returns `true` or `false`. It applies
    /// this closure to each element of the bulk, and if they all return
    /// `true`, then so does `all()`. If any of them return `false`, it
    /// returns `false`.
    ///
    /// `all()` is short-circuiting; in other words, it will stop processing
    /// as soon as it finds a `false`, given that no matter what else happens,
    /// the result will also be `false`.
    ///
    /// An empty bulk returns `true`.
    ///
    /// # Examples
    ///
    /// Basic usage:
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [1, 2, 3];
    ///
    /// assert!(a.into_bulk().all(|x| x > 0));
    ///
    /// assert!(!a.into_bulk().all(|x| x > 2));
    /// ```
    fn all<F>(self, f: F) -> bool
    where
        Self: Sized,
        F: [const] FnMut(Self::Item) -> bool + [const] Destruct,
        Self::Item: [const] Destruct
    {
        struct Functor<F>(F);
        const impl<F, T> FnOnce<(T,)> for Functor<F>
        where
            F: [const] FnMut(T) -> bool + [const] Destruct
        {
            type Output = ControlFlow<()>;

            extern "rust-call" fn call_once(mut self, args: (T,)) -> Self::Output
            {
                self.call_mut(args)
            }
        }
        const impl<F, T> FnMut<(T,)> for Functor<F>
        where
            F: [const] FnMut(T) -> bool
        {
            extern "rust-call" fn call_mut(&mut self, (x,): (T,)) -> Self::Output
            {
                if self.0(x) { ControlFlow::Continue(()) } else { ControlFlow::Break(()) }
            }
        }

        self.try_for_each(Functor(f)) == ControlFlow::Continue(())
    }

    /// Tests if every element of the bulk matches an asynchronous predicate.
    ///
    /// `all()` takes a closure that returns `true` or `false`. It applies
    /// this closure to each element of the bulk in an unscpecified order,
    /// and if they all return `true`, then so does `all()`.
    /// If any of them return `false`, it returns `false`.
    ///
    /// `all()` is short-circuiting; in other words, it will stop processing
    /// as soon as it finds a `false`, given that no matter what else happens,
    /// the result will also be `false`.
    ///
    /// An empty bulk returns `true`.
    ///
    /// # Examples
    ///
    /// Basic usage:
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [1, 2, 3];
    ///
    /// # tokio::runtime::Builder::new_multi_thread().enable_all().build().unwrap().block_on(async {
    /// assert!(a.into_bulk().all_async(async |x| x > 0).await);
    ///
    /// assert!(!a.into_bulk().all_async(async |x| x > 2).await);
    /// # })
    /// ```
    #[cfg(feature = "async")]
    #[rustc_non_const_trait_method]
    fn all_async<F>(self, condition: F) -> AllAsync<Self, F>
    where
        Self: BufferableBulk + Sized,
        F: FnMut<(Self::Item,), Output: Future<Output = bool>>
    {
        AllAsync::new(self, condition)
    }

    /// Tests if any element of the bulk matches a predicate.
    ///
    /// `any()` takes a closure that returns `true` or `false`. It applies
    /// this closure to each element of the bulk, and if any of them return
    /// `true`, then so does `any()`. If they all return `false`, it
    /// returns `false`.
    ///
    /// `any()` is short-circuiting; in other words, it will stop processing
    /// as soon as it finds a `true`, given that no matter what else happens,
    /// the result will also be `true`.
    ///
    /// An empty bulk returns `false`.
    ///
    /// # Examples
    ///
    /// Basic usage:
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [1, 2, 3];
    ///
    /// assert!(a.into_bulk().any(|x| x > 0));
    ///
    /// assert!(!a.into_bulk().any(|x| x > 5));
    /// ```
    fn any<F>(self, f: F) -> bool
    where
        Self: Sized,
        F: [const] FnMut(Self::Item) -> bool + [const] Destruct,
        Self::Item: [const] Destruct
    {
        struct Functor<F>(F);
        const impl<F, T> FnOnce<(T,)> for Functor<F>
        where
            F: [const] FnMut(T) -> bool + [const] Destruct
        {
            type Output = ControlFlow<()>;

            extern "rust-call" fn call_once(mut self, args: (T,)) -> Self::Output
            {
                self.call_mut(args)
            }
        }
        const impl<F, T> FnMut<(T,)> for Functor<F>
        where
            F: [const] FnMut(T) -> bool
        {
            extern "rust-call" fn call_mut(&mut self, (x,): (T,)) -> Self::Output
            {
                if self.0(x) { ControlFlow::Break(()) } else { ControlFlow::Continue(()) }
            }
        }

        self.try_for_each(Functor(f)) == ControlFlow::Break(())
    }

    /// Tests if any element of the bulk matches an asynchronous predicate.
    ///
    /// `any()` takes a closure that returns `true` or `false`. It applies
    /// this closure to each element of the bulk in an unspecified order,
    /// and if any of them return `true`, then so does `any()`.
    /// If they all return `false`, it returns `false`.
    ///
    /// `any()` is short-circuiting; in other words, it will stop processing
    /// as soon as it finds a `true`, given that no matter what else happens,
    /// the result will also be `true`.
    ///
    /// An empty bulk returns `false`.
    ///
    /// # Examples
    ///
    /// Basic usage:
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [1, 2, 3];
    ///
    /// # tokio::runtime::Builder::new_multi_thread().enable_all().build().unwrap().block_on(async {
    /// assert!(a.into_bulk().any_async(async |x| x > 0).await);
    ///
    /// assert!(!a.into_bulk().any_async(async |x| x > 5).await);
    /// # })
    /// ```
    #[cfg(feature = "async")]
    #[rustc_non_const_trait_method]
    fn any_async<F>(self, condition: F) -> AnyAsync<Self, F>
    where
        Self: BufferableBulk + Sized,
        F: FnMut<(Self::Item,), Output: Future<Output = bool>>
    {
        AnyAsync::new(self, condition)
    }

    /// Searches for an element of a bulk that satisfies a predicate.
    ///
    /// `find()` takes a closure that returns `true` or `false`. It applies
    /// this closure to each element of the bulk, and if any of them return
    /// `true`, then `find()` returns [`Some(element)`]. If they all return
    /// `false`, it returns [`None`].
    ///
    /// `find()` is short-circuiting; in other words, it will stop processing
    /// as soon as the closure returns `true`.
    ///
    /// Because `find()` takes a reference, and many iterators iterate over
    /// references, this leads to a possibly confusing situation where the
    /// argument is a double reference. You can see this effect in the
    /// examples below, with `&&x`.
    ///
    /// If you need the index of the element, see [`position()`].
    ///
    /// [`Some(element)`]: Some
    /// [`position()`]: Bulk::position
    ///
    /// # Examples
    ///
    /// Basic usage:
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [1, 2, 3];
    ///
    /// assert_eq!(a.into_bulk().find(|&x| x == 2), Some(2));
    /// assert_eq!(a.into_bulk().find(|&x| x == 5), None);
    /// ```
    ///
    /// Iterating over references:
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [1, 2, 3];
    ///
    /// // `bulk()` yields references i.e. `&i32` and `find()` takes a
    /// // reference to each element.
    /// assert_eq!(a.bulk().find(|&&x| x == 2), Some(&2));
    /// assert_eq!(a.bulk().find(|&&x| x == 5), None);
    /// ```
    #[inline]
    fn find<P>(self, predicate: P) -> Option<Self::Item>
    where
        Self: Sized,
        Self::Item: [const] Destruct,
        P: [const] FnMut(&Self::Item) -> bool + [const] Destruct
    {
        struct Functor<P>
        {
            predicate: P
        }
        const impl<T, P> FnOnce<(T,)> for Functor<P>
        where
            P: [const] FnMut(&T) -> bool + [const] Destruct,
            T: [const] Destruct
        {
            type Output = ControlFlow<T>;

            extern "rust-call" fn call_once(mut self, args: (T,)) -> Self::Output
            {
                self.call_mut(args)
            }
        }
        const impl<T, P> FnMut<(T,)> for Functor<P>
        where
            P: [const] FnMut(&T) -> bool,
            T: [const] Destruct
        {
            extern "rust-call" fn call_mut(&mut self, (x,): (T,)) -> Self::Output
            {
                if (self.predicate)(&x) { ControlFlow::Break(x) } else { ControlFlow::Continue(()) }
            }
        }

        self.try_for_each(Functor { predicate }).break_value()
    }

    // TODO
    /*#[cfg(feature = "async")]
    #[rustc_non_const_trait_method]
    fn find_async<F, Y>(self, f: F) -> FindAsync<Self, F, Y>
    where
        Self: BufferableBulk + Sized,
        F: FnMut(&Self::Item) -> Y,
        Y: Future<Output = bool>
    {
        FindAsync::new(self, f)
    }*/

    /// Searches for an element of a bulk from the back that satisfies a predicate.
    ///
    /// `rfind()` takes a closure that returns `true` or `false`. It applies
    /// this closure to each element of the bulk, starting at the end, and if any
    /// of them return `true`, then `rfind()` returns [`Some(element)`]. If they all return
    /// `false`, it returns [`None`].
    ///
    /// `rfind()` is short-circuiting; in other words, it will stop processing
    /// as soon as the closure returns `true`.
    ///
    /// Because `rfind()` takes a reference, and many iterators iterate over
    /// references, this leads to a possibly confusing situation where the
    /// argument is a double reference. You can see this effect in the
    /// examples below, with `&&x`.
    ///
    /// [`Some(element)`]: Some
    ///
    /// # Examples
    ///
    /// Basic usage:
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [1, 2, 3];
    ///
    /// assert_eq!(a.into_bulk().rfind(|&x| x == 2), Some(2));
    /// assert_eq!(a.into_bulk().rfind(|&x| x == 5), None);
    /// ```
    ///
    /// Iterating over references:
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [1, 2, 3];
    ///
    /// // `bulk()` yields references i.e. `&i32` and `rfind()` takes a
    /// // reference to each element.
    /// assert_eq!(a.bulk().rfind(|&&x| x == 2), Some(&2));
    /// assert_eq!(a.bulk().rfind(|&&x| x == 5), None);
    /// ```
    #[inline]
    fn rfind<P>(self, predicate: P) -> Option<Self::Item>
    where
        Self: Sized + [const] DoubleEndedBulk,
        P: [const] FnMut(&Self::Item) -> bool + [const] Destruct,
        Self::Item: [const] Destruct
    {
        struct Functor<P>
        {
            predicate: P
        }
        const impl<T, P> FnOnce<((), T)> for Functor<P>
        where
            P: [const] FnMut(&T) -> bool + [const] Destruct,
            T: [const] Destruct
        {
            type Output = ControlFlow<T>;

            extern "rust-call" fn call_once(mut self, args: ((), T)) -> Self::Output
            {
                self.call_mut(args)
            }
        }
        const impl<T, P> FnMut<((), T)> for Functor<P>
        where
            P: [const] FnMut(&T) -> bool,
            T: [const] Destruct
        {
            extern "rust-call" fn call_mut(&mut self, ((), x): ((), T)) -> Self::Output
            {
                if (self.predicate)(&x) { ControlFlow::Break(x) } else { ControlFlow::Continue(()) }
            }
        }

        self.try_rfold((), Functor { predicate }).break_value()
    }

    /// Applies function to the elements of the bulk and returns
    /// the first non-none result.
    ///
    /// # Examples
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = ["lol", "NaN", "2", "5"];
    ///
    /// let first_number = a.bulk().find_map(|s| s.parse().ok());
    ///
    /// assert_eq!(first_number, Some(2));
    /// ```
    #[inline]
    fn find_map<B, F>(self, mapper: F) -> Option<B>
    where
        Self: Sized,
        Self::Item: [const] Destruct,
        F: [const] FnMut(Self::Item) -> Option<B> + [const] Destruct,
        B: [const] Destruct
    {
        struct Functor<P>
        {
            mapper: P
        }
        const impl<T, P, B> FnOnce<((), T)> for Functor<P>
        where
            P: [const] FnMut(T) -> Option<B> + [const] Destruct,
            T: [const] Destruct
        {
            type Output = ControlFlow<B>;

            extern "rust-call" fn call_once(mut self, args: ((), T)) -> Self::Output
            {
                self.call_mut(args)
            }
        }
        const impl<T, P, B> FnMut<((), T)> for Functor<P>
        where
            P: [const] FnMut(T) -> Option<B>,
            T: [const] Destruct
        {
            extern "rust-call" fn call_mut(&mut self, ((), x): ((), T)) -> Self::Output
            {
                if let Some(y) = (self.mapper)(x)
                {
                    ControlFlow::Break(y)
                }
                else
                {
                    ControlFlow::Continue(())
                }
            }
        }

        self.try_fold((), Functor { mapper }).break_value()
    }

    #[cfg(feature = "async")]
    #[rustc_non_const_trait_method]
    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>>>
    {
        FindMapAsync::new(self, f)
    }

    /// Applies function to the elements of the bulk and returns
    /// the first true result or the first error.
    ///
    /// The return type of this method depends on the return type of the closure.
    /// If you return `Result<bool, E>` from the closure, you'll get a `Result<Option<Self::Item>, E>`.
    /// If you return `Option<bool>` from the closure, you'll get an `Option<Option<Self::Item>>`.
    ///
    /// # Examples
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = ["1", "2", "lol", "NaN", "5"];
    ///
    /// let is_my_num = |s: &str, search: i32| -> Result<bool, std::num::ParseIntError> {
    ///     Ok(s.parse::<i32>()? == search)
    /// };
    ///
    /// let result = a.into_bulk().try_find(|&s| is_my_num(s, 2));
    /// assert_eq!(result, Ok(Some("2")));
    ///
    /// let result = a.into_bulk().try_find(|&s| is_my_num(s, 5));
    /// assert!(result.is_err());
    /// ```
    ///
    /// This also supports other types which implement [`Try`], not just [`Result`].
    ///
    /// ```
    /// use bulks::*;
    ///
    /// use std::num::NonZero;
    ///
    /// let a = [3, 5, 7, 4, 9, 0, 11u32];
    /// let result = a.into_bulk().try_find(|&x| NonZero::new(x).map(|y| y.is_power_of_two()));
    /// assert_eq!(result, Some(Some(4)));
    /// let result = a.into_bulk().take(3).try_find(|&x| NonZero::new(x).map(|y| y.is_power_of_two()));
    /// assert_eq!(result, Some(None));
    /// let result = a.into_bulk().rev().try_find(|&x| NonZero::new(x).map(|y| y.is_power_of_two()));
    /// assert_eq!(result, None);
    /// ```
    #[inline]
    fn try_find<F, R>(self, predicate: F) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
    where
        Self: Sized,
        Self::Item: [const] Destruct,
        F: [const] FnMut(&Self::Item) -> R + [const] Destruct,
        R: [const] Try<Output = bool, Residual: [const] Residual<Option<Self::Item>>>
    {
        struct Functor<P>
        {
            predicate: P
        }
        const impl<T, R, P> FnOnce<(T,)> for Functor<P>
        where
            P: [const] FnMut(&T) -> R + [const] Destruct,
            R: [const] Try<Output = bool, Residual: [const] Residual<Option<T>>>,
            T: [const] Destruct
        {
            type Output = ControlFlow<<R::Residual as Residual<Option<T>>>::TryType>;

            extern "rust-call" fn call_once(mut self, args: (T,)) -> Self::Output
            {
                self.call_mut(args)
            }
        }
        const impl<T, R, P> FnMut<(T,)> for Functor<P>
        where
            P: [const] FnMut(&T) -> R,
            R: [const] Try<Output = bool, Residual: [const] Residual<Option<T>>>,
            T: [const] Destruct
        {
            extern "rust-call" fn call_mut(&mut self, (x,): (T,)) -> Self::Output
            {
                match (self.predicate)(&x).branch()
                {
                    ControlFlow::Continue(false) => ControlFlow::Continue(()),
                    ControlFlow::Continue(true) => ControlFlow::Break(Try::from_output(Some(x))),
                    ControlFlow::Break(r) => ControlFlow::Break(FromResidual::from_residual(r))
                }
            }
        }

        match self.try_for_each(Functor { predicate })
        {
            ControlFlow::Break(x) => x,
            ControlFlow::Continue(()) => Try::from_output(None)
        }
    }

    // TODO
    /*#[cfg(feature = "async")]
    #[rustc_non_const_trait_method]
    fn try_find_async<F, R>(self, f: F) -> impl Future<Output = <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType>
    where
        Self: BufferableBulk + Sized,
        F: for<'a> FnMut<(&'a Self::Item,), Output: Future<Output = R>>,
        R: Try<Output = bool, Residual: Residual<Option<Self::Item>>>
    {
        async {
            match self
                .try_for_each_async(async |x| match f(&x).branch()
                {
                    ControlFlow::Continue(false) => ControlFlow::Continue(()),
                    ControlFlow::Continue(true) => ControlFlow::Break(Try::from_output(Some(x))),
                    ControlFlow::Break(r) => ControlFlow::Break(FromResidual::from_residual(r))
                })
                .await
            {
                ControlFlow::Break(x) => x,
                ControlFlow::Continue(()) => Try::from_output(None)
            }
        }
    }*/

    /// Searches for an element in a bulk, returning its index.
    ///
    /// `position()` takes a closure that returns `true` or `false`. It applies
    /// this closure to each element of the bulk, and if one of them
    /// returns `true`, then `position()` returns [`Some(index)`]. If all of
    /// them return `false`, it returns [`None`].
    ///
    /// `position()` is short-circuiting; in other words, it will stop
    /// processing as soon as it finds a `true`.
    ///
    /// # Overflow Behavior
    ///
    /// The method does no guarding against overflows, so if there are more
    /// than [`usize::MAX`] non-matching elements, it either produces the wrong
    /// result or panics. If overflow checks are enabled, a panic is
    /// guaranteed.
    ///
    /// # Panics
    ///
    /// This function might panic if the iterator has more than `usize::MAX`
    /// non-matching elements.
    ///
    /// [`Some(index)`]: Some
    ///
    /// # Examples
    ///
    /// Basic usage:
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [1, 2, 3];
    ///
    /// assert_eq!(a.into_bulk().position(|x| x == 2), Some(1));
    ///
    /// assert_eq!(a.into_bulk().position(|x| x == 5), None);
    /// ```
    #[inline]
    fn position<P>(self, predicate: P) -> Option<usize>
    where
        Self: Sized,
        Self::Item: [const] Destruct,
        P: [const] FnMut(Self::Item) -> bool + [const] Destruct
    {
        struct Functor<P>
        {
            predicate: P
        }
        const impl<T, P> FnOnce<(usize, T)> for Functor<P>
        where
            P: [const] FnMut(T) -> bool + [const] Destruct
        {
            type Output = ControlFlow<usize, usize>;

            #[rustc_inherit_overflow_checks]
            extern "rust-call" fn call_once(mut self, args: (usize, T)) -> Self::Output
            {
                self.call_mut(args)
            }
        }
        const impl<T, P> FnMut<(usize, T)> for Functor<P>
        where
            P: [const] FnMut(T) -> bool
        {
            #[rustc_inherit_overflow_checks]
            extern "rust-call" fn call_mut(&mut self, (i, x): (usize, T)) -> Self::Output
            {
                if (self.predicate)(x)
                {
                    ControlFlow::Break(i)
                }
                else
                {
                    ControlFlow::Continue(i + 1)
                }
            }
        }

        self.try_fold(0, Functor { predicate }).break_value()
    }

    #[cfg(feature = "async")]
    #[rustc_non_const_trait_method]
    fn position_async<F>(self, f: F) -> PositionAsync<Self, F>
    where
        Self: BufferableBulk + Sized,
        F: FnMut<(Self::Item,), Output: Future<Output = bool>>
    {
        PositionAsync::new(self, f)
    }

    /// Searches for an element in a bulk from the right, returning its
    /// index.
    ///
    /// `rposition()` takes a closure that returns `true` or `false`. It applies
    /// this closure to each element of the bulk, starting from the end,
    /// and if one of them returns `true`, then `rposition()` returns
    /// [`Some(index)`]. If all of them return `false`, it returns [`None`].
    ///
    /// `rposition()` is short-circuiting; in other words, it will stop
    /// processing as soon as it finds a `true`.
    ///
    /// [`Some(index)`]: Some
    ///
    /// # Examples
    ///
    /// Basic usage:
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [1, 2, 3];
    ///
    /// assert_eq!(a.into_bulk().rposition(|x| x == 3), Some(2));
    ///
    /// assert_eq!(a.into_bulk().rposition(|x| x == 5), None);
    /// ```
    #[inline]
    fn rposition<P>(self, predicate: P) -> Option<usize>
    where
        P: [const] FnMut(Self::Item) -> bool + [const] Destruct,
        Self::Item: [const] Destruct,
        Self: Sized + [const] DoubleEndedBulk
    {
        struct Functor<P>
        {
            predicate: P
        }
        const impl<T, P> FnOnce<(usize, T)> for Functor<P>
        where
            P: [const] FnMut(T) -> bool + [const] Destruct
        {
            type Output = ControlFlow<usize, usize>;

            extern "rust-call" fn call_once(mut self, args: (usize, T)) -> Self::Output
            {
                self.call_mut(args)
            }
        }
        const impl<T, P> FnMut<(usize, T)> for Functor<P>
        where
            P: [const] FnMut(T) -> bool
        {
            extern "rust-call" fn call_mut(&mut self, (mut i, x): (usize, T)) -> Self::Output
            {
                i -= 1;
                if (self.predicate)(x) { ControlFlow::Break(i) } else { ControlFlow::Continue(i) }
            }
        }

        let len = self.len();
        self.try_rfold(len, Functor { predicate }).break_value()
    }

    /// Returns the maximum element of a bulk.
    ///
    /// If several elements are equally maximum, the last element is
    /// returned. If the bulk is empty, [`None`] is returned.
    ///
    /// # Examples
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [1, 2, 3];
    /// let b: [u32; 0] = [];
    ///
    /// assert_eq!(a.into_bulk().max(), Some(3));
    /// assert_eq!(b.into_bulk().max(), None);
    /// ```
    #[inline]
    fn max(self) -> Option<Self::Item>
    where
        Self: Sized,
        Self::Item: [const] Ord + [const] Destruct
    {
        self.max_by(Ord::cmp)
    }

    // TODO
    /*#[cfg(feature = "async")]
    #[rustc_non_const_trait_method]
    fn max_async(self) -> MaxByAsync<Self, fn(&Self::Item, &Self::Item) -> Ordering>
    where
        Self: BufferableBulk + Sized,
        Self::Item: Ord
    {
        self.max_by_async(Ord::cmp as fn(_, _) -> _)
    }*/

    /// Returns the minimum element of a bulk.
    ///
    /// If several elements are equally minimum, the first element is returned.
    /// If the bulk is empty, [`None`] is returned.
    ///
    /// # Examples
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [1, 2, 3];
    /// let b: [u32; 0] = [];
    ///
    /// assert_eq!(a.into_bulk().min(), Some(1));
    /// assert_eq!(b.into_bulk().min(), None);
    /// ```
    #[inline]
    fn min(self) -> Option<Self::Item>
    where
        Self: Sized,
        Self::Item: [const] Ord + [const] Destruct
    {
        self.min_by(Ord::cmp)
    }

    // TODO
    /*#[cfg(feature = "async")]
    #[rustc_non_const_trait_method]
    fn min_async(self) -> MinByAsync<Self, fn(&Self::Item, &Self::Item) -> Ordering>
    where
        Self: BufferableBulk + Sized,
        Self::Item: Ord
    {
        self.min_by_async(Ord::cmp as fn(_, _) -> _)
    }*/

    /// Returns the element that gives the maximum value from the
    /// specified function.
    ///
    /// If several elements are equally maximum, the last element is
    /// returned. If the iterator is empty, [`None`] is returned.
    ///
    /// # Examples
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [-3_i32, 0, 1, 5, -10];
    /// assert_eq!(a.into_iter().max_by_key(|x| x.abs()).unwrap(), -10);
    /// ```
    fn max_by_key<B, F>(self, keygen: F) -> Option<Self::Item>
    where
        Self: Sized,
        Self::Item: [const] Destruct,
        F: [const] FnMut(&Self::Item) -> B + [const] Destruct,
        B: [const] Ord + [const] Destruct
    {
        struct Keygen<F>
        {
            keygen: F
        }
        const impl<T, F, K> FnOnce<(T,)> for Keygen<F>
        where
            F: [const] FnMut(&T) -> K + [const] Destruct
        {
            type Output = (K, T);

            extern "rust-call" fn call_once(mut self, args: (T,)) -> Self::Output
            {
                self.call_mut(args)
            }
        }
        const impl<T, F, K> FnMut<(T,)> for Keygen<F>
        where
            F: [const] FnMut(&T) -> K
        {
            extern "rust-call" fn call_mut(&mut self, (value,): (T,)) -> Self::Output
            {
                let key = (self.keygen)(&value);
                (key, value)
            }
        }

        const fn compare_keys<T, K>((lhs_key, _): &(K, T), (rhs_key, _): &(K, T)) -> Ordering
        where
            K: [const] Ord
        {
            lhs_key.cmp(rhs_key)
        }

        let (_, x) = self.map(Keygen { keygen }).max_by(compare_keys)?;
        Some(x)
    }

    // TODO
    /*fn max_async_by_key<B, F>(self, keygen: F) -> impl Future<Output = Option<Self::Item>>
    where
        Self: Sized,
        F: for<'a> FnMut<(&'a Self::Item,), Output: Future<Output = B>>,
        B: Ord
    {
        let (_, x) = self.map_async(async |x| (keygen(&x), x)).max_async_by(async |(a, _), (b, _)| a.cmp(b))?;
        Some(x)
    }*/

    /// Returns the element that gives the maximum value with respect to the
    /// specified comparison function.
    ///
    /// If several elements are equally maximum, the last element is
    /// returned. If the bulk is empty, [`None`] is returned.
    ///
    /// # Examples
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [-3_i32, 0, 1, 5, -10];
    /// assert_eq!(a.into_bulk().max_by(|x, y| x.cmp(y)).unwrap(), 5);
    /// ```
    fn max_by<F>(self, compare: F) -> Option<Self::Item>
    where
        Self: Sized,
        Self::Item: [const] Destruct,
        F: [const] FnMut(&Self::Item, &Self::Item) -> Ordering + [const] Destruct
    {
        struct Functor<F>
        {
            compare: F
        }
        const impl<F, T> FnOnce<(T, T)> for Functor<F>
        where
            F: [const] FnMut(&T, &T) -> Ordering + [const] Destruct,
            T: [const] Destruct
        {
            type Output = T;

            extern "rust-call" fn call_once(mut self, args: (T, T)) -> Self::Output
            {
                self.call_mut(args)
            }
        }
        const impl<F, T> FnMut<(T, T)> for Functor<F>
        where
            F: [const] FnMut(&T, &T) -> Ordering,
            T: [const] Destruct
        {
            extern "rust-call" fn call_mut(&mut self, (v1, v2): (T, T)) -> Self::Output
            {
                core::cmp::max_by(v1, v2, &mut self.compare)
            }
        }

        self.reduce(Functor { compare })
    }

    // TODO
    /*#[cfg(feature = "async")]
    #[rustc_non_const_trait_method]
    fn max_async_by<F>(self, mut compare: F) -> MaxAsyncBy<Self, F>
    where
        Self: Sized,
        F: for<'a> FnMut<(&'a Self::Item, &'a Self::Item), Output: Future<Output = Ordering>>
    {
        async fn max_async_by<T, Y: Future<Output = Ordering>, F: FnOnce(&T, &T) -> Y>(v1: T, v2: T, compare: F) -> T
        {
            if compare(&v1, &v2).await.is_gt() { v1 } else { v2 }
        }

        self.reduce_async(async |a, b| max_async_by(a, b, &mut compare).await)
    }*/

    /// Returns the element that gives the minimum value from the
    /// specified function.
    ///
    /// If several elements are equally minimum, the first element is
    /// returned. If the bulk is empty, [`None`] is returned.
    ///
    /// # Examples
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [-3_i32, 0, 1, 5, -10];
    /// assert_eq!(a.into_bulk().min_by_key(|x| x.abs()).unwrap(), 0);
    /// ```
    fn min_by_key<B, F>(self, keygen: F) -> Option<Self::Item>
    where
        Self: Sized,
        Self::Item: [const] Destruct,
        F: [const] FnMut(&Self::Item) -> B + [const] Destruct,
        B: [const] Ord + [const] Destruct
    {
        struct Keygen<F>
        {
            keygen: F
        }
        const impl<T, F, K> FnOnce<(T,)> for Keygen<F>
        where
            F: [const] FnMut(&T) -> K + [const] Destruct
        {
            type Output = (K, T);

            extern "rust-call" fn call_once(mut self, args: (T,)) -> Self::Output
            {
                self.call_mut(args)
            }
        }
        const impl<T, F, K> FnMut<(T,)> for Keygen<F>
        where
            F: [const] FnMut(&T) -> K
        {
            extern "rust-call" fn call_mut(&mut self, (value,): (T,)) -> Self::Output
            {
                let key = (self.keygen)(&value);
                (key, value)
            }
        }

        const fn compare_keys<T, K>((lhs_key, _): &(K, T), (rhs_key, _): &(K, T)) -> Ordering
        where
            K: [const] Ord
        {
            lhs_key.cmp(rhs_key)
        }

        let (_, x) = self.map(Keygen { keygen }).min_by(compare_keys)?;
        Some(x)
    }

    // TODO
    /*fn min_async_by_key<B, F>(self, keygen: F) -> impl Future<Output = Option<Self::Item>>
    where
        Self: Sized,
        F: for<'a> FnMut<(&'a Self::Item,), Output: Future<Output = B>>,
        B: Ord
    {
        let (_, x) = self.map(async |x| (keygen(&x), x)).min_async_by(async |(a, _), (b, _)| a.cmp(b))?;
        Some(x)
    }*/

    /// Returns the element that gives the minimum value with respect to the
    /// specified comparison function.
    ///
    /// If several elements are equally minimum, the first element is
    /// returned. If the bulk is empty, [`None`] is returned.
    ///
    /// # Examples
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [-3_i32, 0, 1, 5, -10];
    /// assert_eq!(a.into_bulk().min_by(|x, y| x.cmp(y)).unwrap(), -10);
    /// ```
    fn min_by<F>(self, compare: F) -> Option<Self::Item>
    where
        Self: Sized,
        Self::Item: [const] Destruct,
        F: [const] FnMut(&Self::Item, &Self::Item) -> Ordering + [const] Destruct
    {
        struct Functor<F>
        {
            compare: F
        }
        const impl<F, T> FnOnce<(T, T)> for Functor<F>
        where
            F: [const] FnMut(&T, &T) -> Ordering + [const] Destruct,
            T: [const] Destruct
        {
            type Output = T;

            extern "rust-call" fn call_once(mut self, args: (T, T)) -> Self::Output
            {
                self.call_mut(args)
            }
        }
        const impl<F, T> FnMut<(T, T)> for Functor<F>
        where
            F: [const] FnMut(&T, &T) -> Ordering,
            T: [const] Destruct
        {
            extern "rust-call" fn call_mut(&mut self, (v1, v2): (T, T)) -> Self::Output
            {
                core::cmp::min_by(v1, v2, &mut self.compare)
            }
        }

        self.reduce(Functor { compare })
    }

    // TODO
    /*fn min_async_by<F>(self, mut compare: F) -> impl Future<Output = Option<Self::Item>>
    where
        Self: Sized,
        F: for<'a> FnMut<(&'a Self::Item, &'a Self::Item), Output: Future<Output = Ordering>>
    {
        async fn min_async_by<T, Y: Future<Output = Ordering>, F: FnOnce(&T, &T) -> Y>(v1: T, v2: T, compare: F) -> T
        {
            if compare(&v1, &v2).await.is_le() { v1 } else { v2 }
        }

        self.reduce_async(async |a, b| min_async_by(a, b, &mut compare).await)
    }*/

    /// Creates a bulk starting at the same point, but stepping by
    /// the given amount at each iteration.
    ///
    /// Similar to [`Iterator::step_by`].
    ///
    /// # Panics
    ///
    /// The method will panic if the given step is `0`.
    ///
    /// # Examples
    ///
    /// ```
    /// # #![feature(generic_const_exprs)]
    /// use bulks::*;
    ///
    /// let a = [0, 1, 2, 3, 4, 5];
    ///
    /// let mut bulk = a.into_bulk().step_by([(); 2]);
    /// let a_even: [_; _] = bulk.collect();
    ///
    /// assert_eq!(a_even, [0, 2, 4]);
    ///
    /// let mut bulk = a.into_bulk().skip([(); 1]).step_by([(); 2]);
    /// let a_odd: [_; _] = bulk.collect();
    ///
    /// assert_eq!(a_odd, [1, 3, 5]);
    /// ```
    #[inline]
    #[track_caller]
    fn step_by<L>(self, step: L) -> StepBy<Self, L::Length<()>>
    where
        Self: Sized,
        L: LengthValue
    {
        StepBy::new(self, step)
    }

    /// Takes two bulks and creates a new bulk over both in sequence.
    ///
    /// In other words, it links two bulks together, in a chain. 🔗
    ///
    /// Similar to [`Iterator::chain`].
    ///
    /// # Examples
    ///
    /// Basic usage:
    ///
    /// ```
    /// # #![feature(generic_const_exprs)]
    /// use bulks::*;
    ///
    /// let s1 = b"abc";
    /// let s2 = b"def";
    ///
    /// let mut bulk = s1.into_bulk()
    ///     .chain(s2)
    ///     .copied();
    ///
    /// let s: [_; _] = bulk.collect();
    ///
    /// assert_eq!(s, *b"abcdef");
    /// ```
    ///
    /// Since the argument to [`chain()`](Bulk::chain) uses [`IntoBulk`], we can pass
    /// anything that can be converted into a [`Bulk`], not just a
    /// [`Bulk`] itself. For example, arrays (`[T; _]`) implement
    /// [`IntoBulk`], and so can be passed to [`chain()`](Bulk::chain) directly:
    ///
    /// ```
    /// # #![feature(generic_const_exprs)]
    /// use bulks::*;
    ///
    /// let a1 = [1, 2, 3];
    /// let a2 = [4, 5, 6];
    ///
    /// let mut bulk = a1.into_bulk()
    ///     .chain(a2);
    ///
    /// let a: [_; _] = bulk.collect();
    ///
    /// assert_eq!(a, [1, 2, 3, 4, 5, 6]);
    /// ```
    #[inline]
    #[track_caller]
    fn chain<U>(self, other: U) -> Chain<Self, U::IntoBulk>
    where
        Self: Sized,
        U: [const] IntoBulk<Item = Self::Item>
    {
        Chain::new(self, other.into_bulk())
    }

    /// 'Zips up' two bulks or iterators into a single bulk of pairs. One of them must be a bulk.
    ///
    /// Similar to [`Iterator::zip`].
    ///
    /// # Examples
    ///
    /// Basic usage:
    ///
    /// ```
    /// # #![feature(generic_const_exprs)]
    /// use bulks::*;
    ///
    /// let s1 = b"abc".into_bulk().copied();
    /// let s2 = b"def".into_bulk().copied();
    ///
    /// let mut bulk = s1.zip(s2);
    ///
    /// let s: [_; _] = bulk.collect();
    ///
    /// assert_eq!(s, [(b'a', b'd'), (b'b', b'e'), (b'c', b'f')]);
    /// ```
    ///
    /// Since the argument to [`zip()`](Bulk::zip) uses [`IntoBulk`], we can pass
    /// anything that can be converted into a [`Bulk`], not just a
    /// [`Bulk`] itself. For example, arrays (`[T]`) implement
    /// [`IntoBulk`], and so can be passed to [`zip()`](Bulk::zip) directly:
    ///
    /// ```
    /// # #![feature(generic_const_exprs)]
    /// use bulks::*;
    ///
    /// let a1 = [1, 2, 3];
    /// let a2 = [4, 5, 6];
    ///
    /// let mut bulk = a1.into_bulk().zip(a2);
    ///
    /// let a: [_; _] = bulk.collect();
    ///
    /// assert_eq!(a, [(1, 4), (2, 5), (3, 6)]);
    /// ```
    ///
    /// `zip()` is often used to zip an infinite iterator to a finite one.
    /// This works because the finite iterator will eventually return [`None`],
    /// ending the zipper. Zipping with `(0..)` can look a lot like [`enumerate`]:
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let enumerate: [_; _] = (*b"foo").into_bulk().enumerate().collect();
    ///
    /// let zipper: Vec<_> = bulks::rzip(0.., *b"foo").collect();
    ///
    /// assert_eq!((0, b'f'), enumerate[0]);
    /// assert_eq!((0, b'f'), zipper[0]);
    ///
    /// assert_eq!((1, b'o'), enumerate[1]);
    /// assert_eq!((1, b'o'), zipper[1]);
    ///
    /// assert_eq!((2, b'o'), enumerate[2]);
    /// assert_eq!((2, b'o'), zipper[2]);
    /// ```
    ///
    /// It can be more readable to use [`bulks::zip`](crate::zip):
    ///
    /// ```
    /// # #![feature(generic_const_exprs)]
    /// use bulks::*;
    ///
    /// let a = [1, 2, 3];
    /// let b = [2, 3, 4];
    ///
    /// let mut zipped = bulks::zip(
    ///     a.into_bulk().map(|x| x * 2).skip([(); 1]),
    ///     b.into_bulk().map(|x| x * 2).skip([(); 1]),
    /// );
    ///
    /// let c: [_; _] = zipped.collect();
    ///
    /// assert_eq!(c, [(4, 6), (6, 8)]);
    /// ```
    ///
    /// compared to:
    ///
    /// ```
    /// # #![feature(generic_const_exprs)]
    /// # use bulks::*;
    /// #
    /// # let a = [1, 2, 3];
    /// # let b = [2, 3, 4];
    /// #
    /// let mut zipped = a.into_bulk()
    ///     .map(|x| x * 2)
    ///     .skip([(); 1])
    ///     .zip(b.into_bulk()
    ///         .map(|x| x * 2)
    ///         .skip([(); 1])
    ///     );
    /// #
    /// # let c: [_; _] = zipped.collect();
    /// # assert_eq!(c, [(4, 6), (6, 8)]);
    /// ```
    #[inline]
    #[track_caller]
    fn zip<U>(self, other: U) -> Zip<Self, <<U as IntoContained>::IntoContained as IntoBulk>::IntoBulk>
    where
        Self: Sized,
        U: [const] IntoContainedBy<Self>
    {
        crate::zip(self, other)
    }

    /// Merges two bulks or iterators into a single bulk using a merging function.
    ///
    /// Similar to [`Bulk::zip`], followed by [`Bulk::map`], but keeps the tail if the length of the two bulks differ.
    ///
    /// # Examples
    ///
    /// Basic usage:
    ///
    /// ```
    /// # #![feature(generic_const_exprs)]
    /// use bulks::*;
    ///
    /// use core::ops::Add;
    ///
    /// let s1 = b"abc".into_bulk().copied();
    /// let s2 = b"defg".into_bulk().copied();
    ///
    /// let mut bulk = s1.merge(s2, Add::add);
    ///
    /// let s: [_; _] = bulk.collect_array();
    ///
    /// assert_eq!(s, [b'a' + b'd', b'b' + b'e', b'c' + b'f', b'g']);
    /// ```
    #[inline]
    #[track_caller]
    fn merge<U, F, O>(self, other: U, merger: F) -> Merge<Self, U::IntoBulk, F>
    where
        Self: Sized,
        U: [const] IntoBulk,
        Self::Item: Into<O>,
        U::Item: Into<O>,
        F: FnMut(Self::Item, U::Item) -> O
    {
        crate::merge(self, other, merger)
    }

    /// Creates a new bulk which places a copy of `separator` between adjacent
    /// items of the original bulk.
    ///
    /// Similar to [`Iterator::intersperse`].
    ///
    /// In case `separator` does not implement [`Clone`](core::clone::Clone) or needs to be
    /// computed every time, use [`intersperse_with`](Bulk::intersperse_with).
    ///
    /// # Examples
    ///
    /// Basic usage:
    ///
    /// ```
    /// # #![feature(generic_const_exprs)]
    /// use bulks::*;
    ///
    /// let mut a: [_; _] = [0, 1, 2].into_bulk().intersperse(100).collect();
    ///
    /// assert_eq!(a, [0, 100, 1, 100, 2]);
    /// ```
    ///
    /// `intersperse` can be very useful to join a bulk's items using a common element:
    /// ```
    /// # #![feature(generic_const_exprs)]
    /// use bulks::*;
    ///
    /// let words = ["Hello", "World", "!"];
    /// let hello: String = words.into_bulk().intersperse(" ").collect();
    /// assert_eq!(hello, "Hello World !");
    /// ```
    #[inline]
    #[track_caller]
    fn intersperse(self, separator: Self::Item) -> Intersperse<Self>
    where
        Self: Sized,
        Self::Item: Clone
    {
        Intersperse::new(self, separator)
    }

    /// Creates a new bulk which places an item generated by `separator`
    /// between adjacent items of the original bulk.
    ///
    /// The closure will be called exactly once each time an item is placed
    /// between two adjacent items from the underlying bulk; specifically,
    /// the closure is not called if the underlying bulk has less than
    /// two items.
    ///
    /// Similar to [`Iterator::intersperse_with`].
    ///
    /// If the bulk's item implements [`Clone`](core::clone::Clone), it may be easier to use
    /// [`intersperse`](Bulk::intersperse).
    ///
    /// # Examples
    ///
    /// Basic usage:
    ///
    /// ```
    /// # #![feature(generic_const_exprs)]
    /// use bulks::*;
    ///
    /// #[derive(PartialEq, Debug)]
    /// struct NotClone(usize);
    ///
    /// let v = [NotClone(0), NotClone(1), NotClone(2)];
    /// let u: [_; _] = v.into_bulk().intersperse_with(|| NotClone(99)).collect();
    ///
    /// assert_eq!(u, [NotClone(0), NotClone(99), NotClone(1), NotClone(99), NotClone(2)]);
    /// ```
    ///
    /// [`intersperse_with`](Bulk::intersperse_with) can be used in situations where the separator needs
    /// to be computed:
    /// ```
    /// # #![feature(generic_const_exprs)]
    /// use bulks::*;
    ///
    /// let src = ["Hello", "to", "all", "people", "!!"].bulk().copied();
    ///
    /// // The closure mutably borrows its context to generate an item.
    /// let mut happy_emojis = [" ❤️ ", " 😀 "].into_iter();
    /// let separator = || happy_emojis.next().unwrap_or(" 🦀 ");
    ///
    /// let result: String = src.intersperse_with(separator).collect();
    ///
    /// assert_eq!(result, "Hello ❤️ to 😀 all 🦀 people 🦀 !!");
    /// ```
    #[inline]
    #[track_caller]
    fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
    where
        Self: Sized,
        G: FnMut() -> Self::Item
    {
        IntersperseWith::new(self, separator)
    }

    /// Takes a closure and creates a bulk which calls that closure on each
    /// element.
    ///
    /// [`map()`](Bulk::map) transforms one bulk into another, by means of its argument:
    /// something that implements [`FnMut`]. It produces a new bulk which
    /// calls this closure on each element of the original bulk.
    ///
    /// Similar to [`Iterator::map`].
    ///
    /// # Examples
    ///
    /// Basic usage:
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [1, 2, 3];
    ///
    /// let mut b: [_; _] = a.bulk().map(|x| 2 * x).collect();
    ///
    /// assert_eq!(b, [2, 4, 6]);
    /// ```
    ///
    /// If you're doing some sort of side effect, prefer [`for`] to [`map()`](Bulk::map):
    ///
    /// ```
    /// # #![allow(unused_must_use)]
    /// use bulks::*;
    ///
    /// // don't do this:
    /// (0..5).into_bulk().map(|x| println!("{x}"));
    ///
    /// // it won't even execute, as it is lazy. Rust will warn you about this.
    ///
    /// // Instead, use a for-loop:
    /// for x in (0..5).into_bulk()
    /// {
    ///     println!("{x}");
    /// }
    /// ```
    ///
    /// [`for`]: ../../book/ch03-05-control-flow.html#looping-through-a-collection-with-for
    #[inline]
    #[track_caller]
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
        Self: Sized,
        F: FnMut(Self::Item) -> B
    {
        Map::new(self, f)
    }

    /// Creates a bulk which gives the current index together with its values.
    ///
    /// The bulk returned yields pairs `(i, val)`, where `i` is the
    /// current index of iteration and `val` is its corresponding value.
    ///
    /// Similar to [`Iterator::enumerate`].
    ///
    /// [`enumerate()`](Bulk::enumerate) keeps its count as a [`usize`]. If you want to count by a
    /// different sized integer, use [`enumerate_from`](Bulk::enumerate_from) instead.
    ///
    /// # Overflow Behavior
    ///
    /// The method does no guarding against overflows, so enumerating more than
    /// [`usize::MAX`] elements either produces the wrong result or panics. If
    /// overflow checks are enabled, a panic is guaranteed.
    ///
    /// # Panics
    ///
    /// The returned bulk might panic if the to-be-returned index would
    /// overflow a [`usize`].
    ///
    /// # Examples
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = ['a', 'b', 'c'];
    ///
    /// let b = a.into_bulk()
    ///     .enumerate()
    ///     .collect_array();
    ///
    /// assert_eq!(b, [(0, 'a'), (1, 'b'), (2, 'c')]);
    /// ```
    #[inline]
    #[track_caller]
    fn enumerate(self) -> Enumerate<Self>
    where
        Self: Sized
    {
        Enumerate::new(self)
    }

    /// Creates a bulk which gives the current index counting from a given initial index together with its values.
    ///
    /// The bulk returned yields pairs `(i, val)`, where `i` is the
    /// current index of iteration and `val` is its corresponding value.
    ///
    /// This is similar to [`Bulk::enumerate`], except here a different type and initial value for counting can be used.
    /// For counting an [`usize`] from 0 and up, [`Bulk::enumerate`] is a better alternative.
    ///
    /// # Overflow Behavior
    ///
    /// The method does no guarding against overflows, so enumerating more elements than supported values of `U`
    /// either produces the wrong result or panics. If
    /// overflow checks are enabled, a panic will happen depending how [`Step::forward`] is implemented for `U`.
    ///
    /// # Panics
    ///
    /// The returned bulk might panic if the to-be-returned index would
    /// overflow.
    ///
    /// # Examples
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = ['a', 'b', 'c'];
    ///
    /// let b = a.into_bulk()
    ///     .enumerate_from(1)
    ///     .collect_array();
    ///
    /// assert_eq!(b, [(1, 'a'), (2, 'b'), (3, 'c')]);
    /// ```
    #[inline]
    #[track_caller]
    fn enumerate_from<U>(self, initial_count: U) -> EnumerateFrom<Self, U>
    where
        Self: Sized,
        U: Step + Copy
    {
        EnumerateFrom::new(self, initial_count)
    }

    /// Creates a bulk that skips the first `n` elements.
    ///
    /// Similar to [`Iterator::skip`].
    ///
    /// [`skip(n)`](Bulk::skip) skips elements until `n` elements are skipped or the end of the
    /// bulk is reached (whichever happens first). The returned bulk will yield the remaining elements.
    /// If the original bulk is too short, then the returned bulk is empty.
    ///
    /// # Examples
    ///
    /// ```
    /// # #![feature(generic_const_exprs)]
    /// use bulks::*;
    ///
    /// let a = [1, 2, 3];
    ///
    /// let b: [_; _] = a.into_bulk().skip([(); 2]).collect();
    /// let c: Vec<_> = a.into_bulk().skip(2).collect();
    ///
    /// assert_eq!(b, [3]);
    /// assert_eq!(c, [3]);
    /// ```
    #[inline]
    #[track_caller]
    fn skip<L>(self, n: L) -> Skip<Self, L::Length<()>>
    where
        Self: Sized,
        L: LengthValue
    {
        Skip::new(self, n)
    }

    /// Creates a bulk for the first `n` elements, or fewer
    /// if the underlying bulk/iterator is shorter.
    ///
    /// [`take(n)`](Bulk::take) yields elements until `n` elements are yielded or the end of the
    /// bulk is reached (whichever happens first).
    /// The returned bulk is a prefix of length `n` if the original bulk/iterator
    /// contains at least `n` elements, otherwise it contains all of the
    /// (fewer than `n`) elements of the original bulk/iterator.
    ///
    /// # Examples
    ///
    /// Basic usage:
    ///
    /// ```
    /// # #![feature(generic_const_exprs)]
    /// use bulks::*;
    ///
    /// let a = [1, 2, 3];
    ///
    /// let b: Vec<_> = a.into_bulk().take([(); 2]).collect();
    ///
    /// assert_eq!(b, [1, 2]);
    /// ```
    ///
    /// `take()` is often used with an infinite iterator, to make it finite:
    ///
    /// ```
    /// let a: Vec<_> = (0..).take(3).collect();
    ///
    /// assert_eq!(a, [0, 1, 2])
    /// ```
    ///
    /// If less than `n` elements are available,
    /// [`take`](Bulk::take) will limit itself to the size of the underlying bulk/iterator:
    ///
    /// ```
    /// # #![feature(generic_const_exprs)]
    /// use bulks::*;
    ///
    /// let v = [1, 2];
    /// let b: [_; _] = v.into_bulk().take([(); 5]).collect();
    ///
    /// assert_eq!(b, [1, 2])
    /// ```
    #[doc(alias = "limit")]
    #[inline]
    #[track_caller]
    fn take<L>(self, n: L) -> Take<Self, L::Length<()>>
    where
        Self: Sized,
        L: LengthValue
    {
        Take::new(self, n)
    }

    /// Creates a bulk that works like map, but flattens nested structure.
    ///
    /// The [`map`](Bulk::map) adapter is very useful, but only when the closure
    /// argument produces values. If it produces something iterable instead, there's
    /// an extra layer of indirection. [`flat_map()`](Bulk::flat_map) will remove this extra layer
    /// on its own.
    ///
    /// Similar to [`Iterator::flat_map`].
    ///
    /// You can think of `flat_map(f)` as the semantic equivalent
    /// of [`map`](Bulk::map)ping, and then [`flatten`](Bulk::flatten)ing as in `map(f).flatten()`.
    ///
    /// # Examples
    ///
    /// ```
    /// # #![feature(generic_const_exprs)]
    /// use bulks::*;
    ///
    /// let words = [b"alpha", b"beta ", b"gamma"];
    ///
    /// let merged: String = words.into_bulk()
    ///     .flat_map(|&s| s.into_bulk().map(|b| char::from(b)))
    ///     .collect();
    /// assert_eq!(merged, "alphabeta gamma");
    /// ```
    #[inline]
    #[track_caller]
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, F>
    where
        Self: Sized,
        U: IntoBulk<IntoBulk: StaticBulk>,
        F: FnMut(Self::Item) -> U
    {
        FlatMap::new(self, f)
    }

    /// Creates a bulk that flattens nested structure.
    ///
    /// This is useful when you have a bulk of bulk or a bulk of
    /// things that can be turned into bulks and you want to remove one
    /// level of indirection.
    ///
    /// Similar to [`Iterator::flatten`].
    ///
    /// # Examples
    ///
    /// Basic usage:
    ///
    /// ```
    /// # #![feature(generic_const_exprs)]
    /// use bulks::*;
    ///
    /// let data = [[1, 2, 3], [4, 5, 6]];
    /// let flattened: [_; _] = data.into_bulk().flatten().collect();
    /// assert_eq!(flattened, [1, 2, 3, 4, 5, 6]);
    /// ```
    ///
    /// Mapping and then flattening:
    ///
    /// ```
    /// # #![feature(generic_const_exprs)]
    /// use bulks::*;
    ///
    /// let words = [b"alpha", b"beta ", b"gamma"];
    ///
    /// let merged: String = words.into_bulk()
    ///     .map(|&s| s.into_bulk().map(|b| char::from(b)))
    ///     .flatten()
    ///     .collect();
    /// assert_eq!(merged, "alphabeta gamma");
    /// ```
    ///
    /// You can also rewrite this in terms of [`flat_map()`](Bulk::flat_map), which is preferable
    /// in this case since it conveys intent more clearly:
    ///
    /// ```
    /// # #![feature(generic_const_exprs)]
    /// use bulks::*;
    ///
    /// let words = [b"alpha", b"beta ", b"gamma"];
    ///
    /// let merged: String = words.into_bulk()
    ///     .flat_map(|&s| s.into_bulk().map(|b| char::from(b)))
    ///     .collect();
    /// assert_eq!(merged, "alphabeta gamma");
    /// ```
    ///
    /// Flattening only removes one level of nesting at a time:
    ///
    /// ```
    /// # #![feature(generic_const_exprs)]
    /// use bulks::*;
    ///
    /// let d3 = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]];
    ///
    /// let d2: [_; _] = d3.into_bulk().flatten().collect();
    /// assert_eq!(d2, [[1, 2], [3, 4], [5, 6], [7, 8]]);
    ///
    /// let d1: [_; _] = d3.into_bulk().flatten().flatten().collect();
    /// assert_eq!(d1, [1, 2, 3, 4, 5, 6, 7, 8]);
    /// ```
    ///
    /// Here we see that [`flatten()`](Bulk::flatten) does not perform a "deep" flatten.
    /// Instead, only one level of nesting is removed. That is, if you
    /// [`flatten()`](Bulk::flatten) a three-dimensional array, the result will be
    /// two-dimensional and not one-dimensional. To get a one-dimensional
    /// structure, you have to [`flatten()`](Bulk::flatten) again.
    #[inline]
    #[track_caller]
    fn flatten(self) -> Flatten<Self>
    where
        Self: Sized,
        Self::Item: IntoBulk<IntoBulk: StaticBulk>
    {
        Flatten::new(self)
    }

    /// 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.
    ///
    /// Similar to [`Iterator::map_windows`].
    ///
    /// In the following example, the closure is called three times with the
    /// arguments `&['a', 'b']`, `&['b', 'c']` and `&['c', 'd']` respectively.
    ///
    /// ```
    /// # #![feature(generic_const_exprs)]
    /// use bulks::*;
    ///
    /// let strings: [_; _] = b"abcd".bulk()
    ///     .map(|&c| char::from(c))
    ///     .map_windows(|[x, y]| format!("{}+{}", x, y))
    ///     .collect();
    ///
    /// assert_eq!(strings, ["a+b", "b+c", "c+d"]);
    /// ```
    ///
    /// Note that the const parameter `N` is usually inferred by the
    /// destructured argument in the closure.
    ///
    /// The returned bulk yields 𝑘 − `N` + 1 items (where 𝑘 is the number of
    /// items yielded by `self`). If 𝑘 is less than `N`, this method yields an
    /// empty bulk.
    ///
    /// # Panics
    ///
    /// Panics if `N` is zero.
    ///
    /// ```should_panic
    /// use bulks::*;
    ///
    /// let bulk = [0].into_bulk().map_windows(|&[]| ());
    /// ```
    ///
    /// # Examples
    ///
    /// Building the sums of neighboring numbers.
    ///
    /// ```
    /// # #![feature(generic_const_exprs)]
    /// use bulks::*;
    ///
    /// let w: [_; _] = [1, 3, 8, 1].bulk()
    ///     .map_windows(|&[a, b]| a + b)
    ///     .collect();
    ///
    /// assert_eq!(w, [1 + 3, 3 + 8, 8 + 1]);
    /// ```
    ///
    /// Since the elements in the following example implement [`Copy`], we can
    /// just copy the array and get a bulk of the windows.
    ///
    /// ```
    /// # #![feature(generic_const_exprs)]
    /// use bulks::*;
    ///
    /// let w: [[_; _]; _] = b"ferris".bulk()
    ///     .map_windows(|w: &[_; 3]| w.bulk()
    ///         .copied()
    ///         .copied()
    ///         .collect())
    ///     .collect();
    ///
    /// assert_eq!(w, [[b'f', b'e', b'r'], [b'e', b'r', b'r'], [b'r', b'r', b'i'], [b'r', b'i', b's']]);
    /// ```
    ///
    /// You can also use this function to check the sortedness of a bulk.
    /// For the simple case, rather use [`Bulk::is_sorted`].
    ///
    /// ```
    /// # #![feature(generic_const_exprs)]
    /// use bulks::*;
    ///
    /// let w: [_; _] = [0.5, 1.0, 3.5, 3.0, 8.5, 8.5, f32::NAN].bulk()
    ///     .map_windows(|[a, b]| a <= b)
    ///     .collect();
    ///
    /// assert_eq!(w, [true, true, false, true, true, false]);
    /// ```
    #[inline]
    #[track_caller]
    fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
    where
        Self: Sized,
        F: FnMut(&[Self::Item; N]) -> R
    {
        MapWindows::new(self, f)
    }

    /// Does something with each element of a bulk, passing the value on.
    ///
    /// When using bulks, you'll often chain several of them together.
    /// While working on such code, you might want to check out what's
    /// happening at various parts in the pipeline. To do that, insert
    /// a call to [`inspect()`](Bulk::inspect).
    ///
    /// Similar to [`Iterator::inspect`].
    ///
    /// # Examples
    ///
    /// Basic usage:
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [1, 4, 2, 3];
    ///
    /// // this iterator sequence is complex.
    /// let sum = a.bulk()
    ///     .cloned()
    ///     .map(|x| if x % 2 == 0 {Some(x)} else {None})
    ///     .fold(0, |sum, i| sum + i.unwrap_or(0));
    ///
    /// println!("{sum}");
    ///
    /// // let's add some inspect() calls to investigate what's happening
    /// let sum = a.bulk()
    ///     .cloned()
    ///     .inspect(|x| println!("about to filter: {x}"))
    ///     .map(|x| if x % 2 == 0 {Some(x)} else {None})
    ///     .inspect(|x| if let Some(x) = x {println!("made it through filter: {x}")})
    ///     .fold(0, |sum, i| sum + i.unwrap_or(0));
    ///
    /// println!("{sum}");
    /// ```
    ///
    /// This will print:
    ///
    /// ```text
    /// 6
    /// about to filter: 1
    /// about to filter: 4
    /// made it through filter: 4
    /// about to filter: 2
    /// made it through filter: 2
    /// about to filter: 3
    /// 6
    /// ```
    ///
    /// Logging errors before discarding them:
    ///
    /// ```
    /// let lines = ["1", "2", "a"];
    ///
    /// let sum: i32 = lines
    ///     .iter()
    ///     .map(|line| line.parse::<i32>())
    ///     .inspect(|num| {
    ///         if let Err(ref e) = *num {
    ///             println!("Parsing error: {e}");
    ///         }
    ///     })
    ///     .filter_map(Result::ok)
    ///     .sum();
    ///
    /// println!("Sum: {sum}");
    /// ```
    ///
    /// This will print:
    ///
    /// ```text
    /// Parsing error: invalid digit found in string
    /// Sum: 3
    /// ```
    #[inline]
    #[track_caller]
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
        Self: Sized,
        F: FnMut(&Self::Item)
    {
        Inspect::new(self, f)
    }

    /// Mutates with each element of a bulk, passing the value on.
    ///
    /// # Examples
    ///
    /// Basic usage:
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [1, 4, 2, 3];
    ///
    /// // this iterator sequence is complex.
    /// let b: [_; _] = a.into_bulk()
    ///     .mutate(|x| *x += 1)
    ///     .collect();
    ///
    /// assert_eq!(b, [2, 5, 3, 4]);
    /// ```
    #[inline]
    #[track_caller]
    fn mutate<F>(self, f: F) -> Mutate<Self, F>
    where
        Self: Sized,
        F: FnMut(&mut Self::Item)
    {
        Mutate::new(self, f)
    }

    /// Transforms a bulk into a collection.
    ///
    /// [`collect()`](Bulk::collect) can take anything bulkable, and turn it into a relevant
    /// collection.
    ///
    /// Similar to [`Iterator::collect`].
    ///
    /// # Examples
    ///
    /// Basic usage:
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [1, 2, 3];
    ///
    /// let doubled: [i32; 3] = a.bulk()
    ///     .map(|x| x * 2)
    ///     .collect();
    ///
    /// assert_eq!(doubled, [2, 4, 6]);
    /// ```
    ///
    /// Note that we needed the `: [i32; 3]` on the left-hand side. This is because
    /// we could collect into, for example, a [`VecDeque<T>`](std::collections::VecDeque) instead:
    ///
    /// ```
    /// use std::collections::VecDeque;
    ///
    /// use bulks::*;
    ///
    /// let a = [1, 2, 3];
    ///
    /// let doubled: VecDeque<i32> = a.bulk()
    ///     .map(|x| x * 2)
    ///     .collect();
    ///
    /// assert_eq!(doubled[0], 2);
    /// assert_eq!(doubled[1], 4);
    /// assert_eq!(doubled[2], 6);
    /// ```
    ///
    /// Using the 'turbofish' instead of annotating `doubled`:
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [1, 2, 3];
    ///
    /// let doubled = a.bulk()
    ///     .map(|x| x * 2)
    ///     .collect::<[i32; 3], _>();
    ///
    /// assert_eq!(doubled, [2, 4, 6]);
    /// ```
    ///
    /// Because `collect()` only cares about what you're collecting into, you can
    /// still use a partial type hint, `_`, with the turbofish:
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [1, 2, 3];
    ///
    /// let doubled: [_; _] = a.bulk()
    ///     .map(|x| x * 2)
    ///     .collect();
    ///
    /// assert_eq!(doubled, [2, 4, 6]);
    /// ```
    ///
    /// Using `collect()` to make a [`String`](std::string::String):
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let chars = ['g', 'd', 'k', 'k', 'n'];
    ///
    /// let hello: String = chars.bulk()
    ///     .copied()
    ///     .map(|x| x as u8)
    ///     .map(|x| (x + 1) as char)
    ///     .collect();
    ///
    /// assert_eq!(hello, "hello");
    /// ```
    ///
    /// If you have a list of [`Result<T, E>`][`Result`]s, you can use `collect()` to
    /// see if any of them failed:
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let results = [Ok(1), Err("nope"), Ok(3), Err("bad")];
    ///
    /// let result: Result<[_; _], &str> = results.into_bulk().collect();
    ///
    /// // gives us the first error
    /// assert_eq!(result, Err("nope"));
    ///
    /// let results = [Ok(1), Ok(3)];
    ///
    /// let result: Result<[_; _], &str> = results.into_bulk().collect();
    ///
    /// // gives us the list of answers
    /// assert_eq!(result, Ok([1, 3]));
    /// ```
    #[inline]
    #[must_use = "if you really need to exhaust the bulk, consider `.for_each(drop)` instead"]
    fn collect<C, A>(self) -> C
    where
        Self: Sized,
        C: [const] FromBulk<A>,
        A: CollectionAdapter<Elem = Self::Item> + [const] CollectionStrategy<Self::MinLength, Self::MaxLength, C> + ?Sized
    {
        FromBulk::from_bulk(self)
    }

    #[cfg(feature = "async")]
    #[rustc_non_const_trait_method]
    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
    {
        CollectAsync::new(self)
    }

    /// Fallibly transforms a bulk into a collection, short circuiting if
    /// a failure is encountered.
    ///
    /// `try_collect()` is a variation of [`collect()`][`Bulk::collect`] that allows fallible
    /// conversions during collection. Its main use case is simplifying conversions from
    /// iterators yielding [`Option<T>`][`Option`] into `Option<Collection<T>>`, or similarly for other [`Try`]
    /// types (e.g. [`Result`]).
    ///
    /// Importantly, `try_collect()` doesn't require that the outer [`Try`] type also implements [`FromBulk`];
    /// only the inner type produced on `Try::Output` must implement it. Concretely,
    /// this means that collecting into `ControlFlow<_, Vec<i32>>` is valid because `Vec<i32>` implements
    /// [`FromBulk`], even though [`ControlFlow`] doesn't.
    ///
    /// Unlike with [`Iterator::try_collect`], the bulk is fully consumed even if it short-circuits.
    /// A short-circuit will cause the rest of the elements of the bulk to be dropped.
    ///
    /// # Examples
    ///
    /// Successfully collecting a bulk of `Option<i32>` into `Option<[i32; _]>`:
    /// ```
    /// use bulks::*;
    ///
    /// let u = [Some(1), Some(2), Some(3)];
    ///
    /// let v = u.into_bulk().try_collect::<[i32; _], _>();
    ///
    /// assert_eq!(v, Some([1, 2, 3]));
    /// ```
    ///
    /// Failing to collect in the same way:
    /// ```
    /// use bulks::*;
    ///
    /// let u = [Some(1), Some(2), None, Some(3)];
    ///
    /// let v = u.into_bulk().try_collect::<[i32; _], _>();
    ///
    /// assert_eq!(v, None);
    /// ```
    ///
    /// A similar example, but with `Result`:
    /// ```
    /// use bulks::*;
    ///
    /// let u: [Result<i32, ()>; _] = [Ok(1), Ok(2), Ok(3)];
    ///
    /// let v = u.into_bulk().try_collect::<[i32; _], _>();
    ///
    /// assert_eq!(v, Ok([1, 2, 3]));
    ///
    /// let u = [Ok(1), Ok(2), Err(()), Ok(3)];
    ///
    /// let v = u.into_bulk().try_collect::<[i32; _], _>();
    ///
    /// assert_eq!(v, Err(()));
    /// ```
    ///
    /// Finally, even [`ControlFlow`] works, despite the fact that it
    /// doesn't implement [`FromBulk`].
    ///
    /// ```
    /// # #![feature(generic_const_exprs)]
    /// use bulks::*;
    ///
    /// use core::ops::ControlFlow::{Break, Continue};
    ///
    /// let u = [Continue(1), Continue(2), Break(3), Continue(4), Continue(5)];
    ///
    /// let v = u.into_bulk().try_collect::<[_; _], _>();
    ///
    /// assert_eq!(v, Break(3));
    ///
    /// let v = u.into_bulk().take([(); 2])
    ///     .chain(u.into_bulk().skip([(); 3]))
    ///     .try_collect::<[_; _], _>();
    ///
    /// assert_eq!(v, Continue([1, 2, 4, 5]));
    /// ```
    #[inline]
    #[must_use = "if you really need to exhaust the bulk, consider `.for_each(drop)` instead"]
    fn try_collect<C, A>(self) -> <<Self::Item as Try>::Residual as Residual<C>>::TryType
    where
        Self: Sized,
        C: [const] FromBulk<A>,
        A: CollectionAdapter<Elem = <Self::Item as Try>::Output> + [const] TryCollectionStrategy<Self::MinLength, Self::MaxLength, C> + ?Sized,
        Self::Item: [const] Try<Residual: [const] Residual<C, TryType: [const] Try> + [const] Destruct> + [const] Destruct
    {
        FromBulk::<A>::try_from_bulk(self)
    }

    #[cfg(feature = "async")]
    #[rustc_non_const_trait_method]
    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>>>
    {
        TryCollectAsync::new(self)
    }

    fn collect_nearest(self) -> <BulkLength<Self> as Nearest>::NearestFrom<Self>
    where
        Self: Sized,
        BulkLength<Self>: [const] Nearest,
        Self::Item: [const] Destruct
    {
        self.collect::<<BulkLength<Self> as Nearest>::NearestFrom<Self>, <BulkLength<Self> as Nearest>::NearestStrategyFrom<Self>>()
    }

    #[allow(clippy::type_complexity)]
    #[cfg(feature = "async")]
    #[rustc_non_const_trait_method]
    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
    {
        self.collect_async()
    }

    fn try_collect_nearest(self) -> <<Self::Item as Try>::Residual as Residual<<BulkLength<Self> as Nearest>::TryNearestFrom<Self>>>::TryType
    where
        Self: Sized,
        BulkLength<Self>: [const] Nearest,
        Self::Item:
            [const] Try<Output: [const] Destruct, Residual: [const] Residual<<BulkLength<Self> as Nearest>::TryNearestFrom<Self>> + [const] Destruct> + [const] Destruct
    {
        self.try_collect::<<BulkLength<Self> as Nearest>::TryNearestFrom<Self>, <BulkLength<Self> as Nearest>::TryNearestStrategyFrom<Self>>()
    }

    #[allow(clippy::type_complexity)]
    #[cfg(feature = "async")]
    #[rustc_non_const_trait_method]
    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>>>>
    {
        self.try_collect_async()
    }

    /// Transforms a statically sized bulk into an array.
    /// The bulk must implement [`StaticBulk`].
    ///
    /// This is equivalent to [`collect()`](Bulk::collect), but the type does not need to be inferred.
    /// For types other than arrays, use [`collect()`](Bulk::collect).
    ///
    /// # Examples
    ///
    /// Basic usage:
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [1, 2, 3];
    ///
    /// let doubled = a.bulk()
    ///     .map(|x| x * 2)
    ///     .collect_array();
    ///
    /// assert_eq!(doubled, [2, 4, 6]);
    /// ```
    ///
    /// Alternatively, [`collect()`](Bulk::collect) can be used, but this requires us to specify the return type.
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [1, 2, 3];
    ///
    /// let doubled: [i32; 3] = a.bulk()
    ///     .map(|x| x * 2)
    ///     .collect();
    ///
    /// assert_eq!(doubled, [2, 4, 6]);
    /// ```
    #[must_use = "if you really need to exhaust the bulk, consider `.for_each(drop)` instead"]
    fn collect_array(self) -> <Self as StaticBulk>::Array<<Self as IntoIterator>::Item>
    where
        Self: StaticBulk
    {
        util::collect_array_with!(|f| self.for_each(f); for Self)
    }

    #[cfg(feature = "async")]
    #[rustc_non_const_trait_method]
    fn collect_array_async(self) -> CollectArrayAsync<Self>
    where
        Self: StaticBulk,
        Self::Item: Future
    {
        CollectArrayAsync::new(self)
    }

    /// Fallibly transforms a statically sized bulk into an array, short circuiting if
    /// a failure is encountered.
    /// The bulk must implement [`StaticBulk`].
    ///
    /// `try_collect_array()` is a variation of [`collect_array()`][`Bulk::collect_array`] that allows fallible
    /// conversions during collection. Its main use case is simplifying conversions from
    /// iterators yielding [`Option<T>`][`Option`] into `Option<Collection<T>>`, or similarly for other [`Try`]
    /// types (e.g. [`Result`]).
    ///
    /// Importantly, `try_collect()` doesn't require that the outer [`Try`] type also implements [`FromBulk`];
    /// only the inner type produced on `Try::Output` must implement it. Concretely,
    /// this means that collecting into `ControlFlow<_, Vec<i32>>` is valid because `Vec<i32>` implements
    /// [`FromBulk`], even though [`ControlFlow`] doesn't.
    ///
    /// This is equivalent to [`try_collect()`](Bulk::try_collect), but the type does not need to be inferred.
    /// For types other than arrays, use [`try_collect()`](Bulk::try_collect).
    ///
    /// Unlike with [`Iterator::try_collect`], the bulk is fully consumed even if it short-circuits.
    /// A short-circuit will cause the rest of the elements of the bulk to be dropped.
    ///
    /// # Examples
    ///
    /// Successfully collecting a bulk of `Option<i32>` into `Option<[i32; _]>`:
    /// ```
    /// use bulks::*;
    ///
    /// let u = [Some(1), Some(2), Some(3)];
    /// let v = u.into_bulk().try_collect_array();
    /// assert_eq!(v, Some([1, 2, 3]));
    /// ```
    ///
    /// Failing to collect in the same way:
    /// ```
    /// use bulks::*;
    ///
    /// let u = [Some(1), Some(2), None, Some(3)];
    /// let v = u.into_bulk().try_collect_array();
    /// assert_eq!(v, None);
    /// ```
    ///
    /// Alternatively, [`try_collect()`](Bulk::try_collect) can be used, but this requires us to specify the return type.
    /// ```
    /// use bulks::*;
    ///
    /// let u = [Some(1), Some(2), Some(3)];
    /// let v: Option<[i32; 3]> = u.into_bulk().try_collect();
    /// assert_eq!(v, Some([1, 2, 3]));
    /// ```
    ///
    /// A similar example, but with `Result`:
    /// ```
    /// use bulks::*;
    ///
    /// let u: [Result<i32, ()>; _] = [Ok(1), Ok(2), Ok(3)];
    /// let v = u.into_bulk().try_collect_array();
    /// assert_eq!(v, Ok([1, 2, 3]));
    ///
    /// let u = [Ok(1), Ok(2), Err(()), Ok(3)];
    /// let v = u.into_bulk().try_collect_array();
    /// assert_eq!(v, Err(()));
    /// ```
    ///
    /// Finally, even [`ControlFlow`] works, despite the fact that it
    /// doesn't implement [`FromBulk`].
    ///
    /// ```
    /// # #![feature(generic_const_exprs)]
    /// use core::ops::ControlFlow::{Break, Continue};
    ///
    /// use bulks::*;
    ///
    /// let u = [Continue(1), Continue(2), Break(3), Continue(4), Continue(5)];
    ///
    /// let v = u.into_bulk().try_collect_array();
    /// assert_eq!(v, Break(3));
    ///
    /// let v = u.into_bulk().take([(); 2])
    ///     .chain(u.into_bulk().skip([(); 3]))
    ///     .try_collect_array();
    /// assert_eq!(v, Continue([1, 2, 4, 5]));
    /// ```
    #[allow(clippy::type_complexity)]
    #[must_use = "if you really need to exhaust the bulk, consider `.for_each(drop)` instead"]
    fn try_collect_array(self) -> <<Self::Item as Try>::Residual as Residual<Self::Array<<Self::Item as Try>::Output>>>::TryType
    where
        Self: StaticBulk<
                Item: [const] Destruct
                          + [const] Try<Residual: Residual<Self::Array<<Self::Item as Try>::Output>, TryType: [const] Try> + [const] Destruct, Output: [const] Destruct>
            > + [const] Bulk
    {
        Try::from_output(util::try_collect_array_with!(|pusher| self.try_for_each(pusher); for Self))
    }

    #[cfg(feature = "async")]
    #[rustc_non_const_trait_method]
    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>>>>
    {
        TryCollectArrayAsync::new(self)
    }

    /// 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`.
    ///
    /// ```
    /// # #![feature(generic_const_exprs)]
    ///
    /// use bulks::*;
    ///
    /// let u = [1, 3, 3, 7];
    ///
    /// let v = u.into_bulk()
    ///     .resize([(); 6], 9)
    ///     .collect_array();
    /// assert_eq!(v, [1, 3, 3, 7, 9, 9]);
    /// ```
    fn resize<N>(self, n: N, element: Self::Item) -> Resize<Self, N::Length<()>>
    where
        Self: Sized,
        Self::Item: Copy,
        N: LengthValue
    {
        Resize::new(self, n, element)
    }

    /// 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`.
    ///
    /// ```
    /// # #![feature(generic_const_exprs)]
    ///
    /// use bulks::*;
    ///
    /// let u = [1, 3, 3, 7];
    ///
    /// let v = u.into_bulk()
    ///     .resize_with([(); 6], || 9)
    ///     .collect_array();
    /// assert_eq!(v, [1, 3, 3, 7, 9, 9]);
    /// ```
    fn resize_with<F, N>(self, n: N, padder: F) -> ResizeWith<Self, F, N::Length<()>>
    where
        Self: Sized,
        N: LengthValue,
        F: FnMut() -> Self::Item
    {
        ResizeWith::new(self, n, padder)
    }

    /// Reverses a bulks's direction.
    ///
    /// Usually, bulks span from left to right. After using `rev()`,
    /// a bulk will instead span from right to left.
    ///
    /// Similar to [`Iterator::rev`].
    ///
    /// # Examples
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [1, 2, 3];
    ///
    /// let b: [_; _] = a.into_bulk().rev().collect();
    ///
    /// assert_eq!(b, [3, 2, 1]);
    /// ```
    #[inline]
    #[track_caller]
    #[doc(alias = "reverse")]
    fn rev(self) -> Rev<Self>
    where
        Self: Sized,
        Self: DoubleEndedBulk
    {
        Rev::new(self)
    }

    /// Creates a bulk which copies all of its elements.
    ///
    /// This is useful when you have a bulk of `&T`, but you need a
    /// bulk of `T`.
    ///
    /// Similar to [`Iterator::copied`].
    ///
    /// # Examples
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [1, 2, 3];
    ///
    /// let v_copied: [_; _] = a.bulk().copied().collect();
    ///
    /// // copied is the same as .map(|&x| x)
    /// let v_map: [_; _] = a.bulk().map(|&x| x).collect();
    ///
    /// assert_eq!(v_copied, [1, 2, 3]);
    /// assert_eq!(v_map, [1, 2, 3]);
    /// ```
    #[inline]
    #[track_caller]
    fn copied<'a, T>(self) -> Copied<Self>
    where
        T: Copy + 'a,
        Self: Sized + [const] Bulk<Item = &'a T>
    {
        Copied::new(self)
    }

    /// Creates a bulk which [`clone`](Clone::clone)s all of its elements.
    ///
    /// This is useful when you have a bulk of `&T`, but you need a
    /// bulk of `T`.
    ///
    /// There is no guarantee whatsoever about the `clone` method actually
    /// being called *or* optimized away. So code should not depend on
    /// either.
    ///
    /// Similar to [`Iterator::cloned`].
    ///
    /// # Examples
    ///
    /// Basic usage:
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let a = [1, 2, 3];
    ///
    /// let v_cloned: [_; _] = a.bulk().cloned().collect();
    ///
    /// // cloned is the same as .map(|&x| x), for integers
    /// let v_map: [_; _] = a.bulk().map(|&x| x).collect();
    ///
    /// assert_eq!(v_cloned, [1, 2, 3]);
    /// assert_eq!(v_map, [1, 2, 3]);
    /// ```
    #[inline]
    #[track_caller]
    fn cloned<'a, T>(self) -> Cloned<Self>
    where
        T: Clone + 'a,
        Self: Sized + [const] Bulk<Item = &'a T>
    {
        Cloned::new(self)
    }

    /// # Safety
    ///
    /// Same safety conditions as [Pin::new_unchecked].
    #[inline]
    #[track_caller]
    unsafe fn pinned_unchecked(self) -> Pinned<Self>
    where
        Self: Sized,
        Self::Item: Deref
    {
        unsafe { Pinned::new_unchecked(self) }
    }
    #[inline]
    #[track_caller]
    fn pinned(self) -> Pinned<Self>
    where
        Self: Sized,
        Self::Item: Deref<Target: Unpin>
    {
        Pinned::new(self)
    }

    /// # Safety
    ///
    /// Same safety conditions as [Pin::into_inner_unchecked].
    #[inline]
    #[track_caller]
    unsafe fn unpinned_unchecked<T>(self) -> Unpinned<Self, T>
    where
        Self: Sized + [const] Bulk<Item = Pin<T>>,
        T: Deref
    {
        unsafe { Unpinned::new_unchecked(self) }
    }
    #[inline]
    #[track_caller]
    fn unpinned<T>(self) -> Unpinned<Self, T>
    where
        Self: Sized + [const] Bulk<Item = Pin<T>>,
        T: Deref<Target: Unpin>
    {
        Unpinned::new(self)
    }

    /// Returns a bulk of `N` elements of the bulk at a time.
    ///
    /// The chunks do not overlap. If `N` does not divide the length of the
    /// bulk, then the last up to `N-1` elements will be omitted or the remainder
    /// can then be retrieved from [`.into_remainder()`][crate::ArrayChunks::into_remainder]
    /// or [`.collect_with_remainder()`][crate::ArrayChunks::collect_with_remainder]
    ///
    /// Similar to [`Iterator::array_chunks`].
    ///
    /// # Panics
    ///
    /// Panics if `N` is zero.
    ///
    /// # Examples
    ///
    /// Basic usage:
    ///
    /// ```
    /// # #![feature(generic_const_exprs)]
    /// use bulks::*;
    ///
    /// let bulk = b"lorem".bulk()
    ///     .copied()
    ///     .array_chunks();
    ///
    /// let (c, r) = bulk.collect_with_remainder::<[_; _], _>();
    ///
    /// let r: Vec<_> = r.collect();
    ///
    /// assert_eq!(c, [[b'l', b'o'], [b'r', b'e']]);
    /// assert_eq!(r, [b'm']);
    /// ```
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let data = [1, 1, 2, -2, 6, 0, 3, 1];
    /// //          ^-----^  ^------^
    /// for [x, y, z] in data.bulk().array_chunks()
    /// {
    ///     assert_eq!(x + y + z, 4);
    /// }
    /// ```
    #[inline]
    #[track_caller]
    fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
    where
        Self: Sized
    {
        ArrayChunks::new(self)
    }

    /// Splits a bulk in two at a specified index.
    ///
    /// # Example
    ///
    /// ```
    /// # #![feature(generic_const_exprs)]
    /// use bulks::*;
    ///
    /// let a = b"leftright";
    ///
    /// let (a1, a2) = a.bulk()
    ///     .copied()
    ///     .split_at([(); 4]);
    ///
    /// let left: [_; _] = a1.collect();
    /// let right: [_; _] = a2.collect();
    ///
    /// assert_eq!(&left, b"left");
    /// assert_eq!(&right, b"right");
    /// ```
    #[track_caller]
    fn split_at<L>(self, n: L) -> (Self::Left, Self::Right)
    where
        Self: [const] SplitBulk<L> + Sized,
        L: LengthValue
    {
        SplitBulk::split_at(self, n)
    }

    /// Splits a bulk in two at a specified reversed index.
    ///
    /// # Example
    ///
    /// ```
    /// # #![feature(generic_const_exprs)]
    /// use bulks::*;
    ///
    /// let a = b"leftright";
    ///
    /// let (a1, a2) = a.bulk()
    ///     .copied()
    ///     .rsplit_at([(); 5]);
    ///
    /// let left: [_; _] = a1.collect();
    /// let right: [_; _] = a2.collect();
    ///
    /// assert_eq!(&left, b"left");
    /// assert_eq!(&right, b"right");
    /// ```
    #[track_caller]
    fn rsplit_at<L>(self, n: L) -> (Self::Left, Self::Right)
    where
        Self: [const] SplitBulk<length::value::SaturatingSub<<BulkLength<Self> as Length>::Value, L>> + Sized,
        L: LengthValue
    {
        let l = self.length();
        SplitBulk::split_at(self, length::value::saturating_sub(l, n))
    }

    /// Consumes the bulk, and swaps two elements of it. Items must be mutably dereferenceable.
    ///
    /// Panics if either index is out of bounds.
    ///
    /// # Example
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let mut a = *b"Com Truise";
    ///
    /// a.bulk_mut()
    ///     .swap::<u8>(0, 4);
    ///
    /// assert_eq!(&a, b"Tom Cruise");
    /// ```
    fn swap<S>(self, lhs: impl LengthValue, rhs: impl LengthValue)
    where
        Self: Sized,
        Self::Item: [const] BorrowMut<S> + [const] Destruct
    {
        match self.try_swap(lhs, rhs)
        {
            Ok(()) => (),
            Err(err) => err.halt()
        }
    }

    /// Consumes the bulk, and swaps two elements of it. Items must be mutably dereferenceable.
    ///
    /// Returns an error if either index is out of bounds.
    ///
    /// # Example
    ///
    /// ```
    /// use bulks::*;
    ///
    /// let mut a = *b"Com Truise";
    ///
    /// std::assert_matches!(
    ///     a.bulk_mut()
    ///         .try_swap::<u8>(0, 4),
    ///     Ok(())
    /// );
    /// std::assert_matches!(
    ///     a.bulk_mut()
    ///         .try_swap::<u8>(4, 10),
    ///     Err(OutOfRange { i: 10, len: 10 })
    /// );
    ///
    /// assert_eq!(&a, b"Tom Cruise");
    /// ```
    fn try_swap<S>(self, lhs: impl LengthValue, rhs: impl LengthValue) -> Result<(), OutOfRange>
    where
        Self: Sized,
        Self::Item: [const] BorrowMut<S> + [const] Destruct
    {
        let n = self.length();

        let j = length::value::min(lhs, rhs);
        let i = length::value::max(lhs, rhs);

        struct Closure<T>
        {
            first: Option<T>,
            last: Option<T>
        }
        const impl<T> FnOnce<(T,)> for Closure<T>
        where
            T: [const] Destruct
        {
            type Output = ();

            extern "rust-call" fn call_once(mut self, args: (T,)) -> Self::Output
            {
                self.call_mut(args)
            }
        }
        const impl<T> FnMut<(T,)> for Closure<T>
        where
            T: [const] Destruct
        {
            extern "rust-call" fn call_mut(&mut self, (x,): (T,)) -> Self::Output
            {
                if self.first.is_none() { self.first = Some(x) } else { self.last = Some(x) }
            }
        }

        let mut closure = Closure { first: None, last: None };

        self.take(length::value::add(i, [(); 1]))
            .skip(j)
            .step_by(length::value::sub(i, j))
            .for_each(&mut closure);

        match if length::value::ge(i, n)
        {
            Err(length::value::len(i))
        }
        else
        {
            match (closure.first, closure.last)
            {
                (Some(mut first), Some(mut last)) =>
                {
                    core::mem::swap(first.borrow_mut(), last.borrow_mut());
                    Ok(())
                }
                (Some(_), None) if length::value::eq(i, j) => Ok(()),
                (Some(_), None) => Err(length::value::len(j)),
                (None, None) | (None, Some(_)) => Err(length::value::len(i))
            }
        }
        {
            Ok(()) => Ok(()),
            Err(i) => Err(OutOfRange { i, len: length::value::len(n) })
        }
    }

    fn sum_from<T>(self, from: T) -> T
    where
        T: [const] Add<Self::Item, Output = T> + [const] Destruct,
        Self: Sized
    {
        self.fold(from, Add::add)
    }

    fn product_from<T>(self, from: T) -> T
    where
        T: [const] Mul<Self::Item, Output = T> + [const] Destruct,
        Self: Sized
    {
        self.fold(from, Mul::mul)
    }
}

#[derive(Clone, Copy, Debug)]
pub struct OutOfRange
{
    pub i: usize,
    pub len: usize
}

impl OutOfRange
{
    const fn halt(self) -> !
    {
        fn rt(oor: OutOfRange) -> !
        {
            panic!("{oor}")
        }

        const fn ct(_: OutOfRange) -> !
        {
            panic!("Index out of bounds.")
        }

        core::intrinsics::const_eval_select((self,), ct, rt)
    }
}

impl Display for OutOfRange
{
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
    {
        let Self { i, len } = self;
        write!(f, "Index out of bounds. Index {i} can't be larger than {len}.")
    }
}
impl Error for OutOfRange {}

#[cfg(test)]
mod test
{
    use crate::*;

    #[test]
    fn test_reduce()
    {
        let a = [1, 5, -3, 7, 9, 3, -1, 3];

        let sum = a.into_bulk().reduce(|a, b| a + b).unwrap_or(0);
        let product = a.into_bulk().reduce(|a, b| a * b).unwrap_or(1);
        let min = a.into_bulk().reduce(|a, b| a.min(b)).unwrap();
        let max = a.into_bulk().reduce(|a, b| a.max(b)).unwrap();
        let mean = sum as f32 / a.len() as f32;
        let variance = a.into_bulk().map(|a| a as f32 - mean).map(|a| a * a).reduce(|a, b| a + b).unwrap_or(0.0).sqrt();

        println!("sum = {sum}");
        println!("product = {product}");
        println!("min = {min}");
        println!("max = {max}");

        println!("mean = {mean}");
        println!("variance = {variance}");
    }
}