bulks 0.10.1

Amazing bulks! They are like iterators, but in bulk, and therefore support collection into arrays.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

use core::{iter, marker::Destruct, ops::Deref, pin::Pin};

use crate::Bulk;

pub struct Pinned<B>
where
    B: Bulk<Item: Deref>
{
    bulk: B
}

impl<B> Pinned<B>
where
    B: Bulk<Item: Deref>
{
    pub(crate) const fn new(bulk: B) -> Self
    where
        <B::Item as Deref>::Target: Unpin
    {
        let _ = |x: B::Item| Pin::new(x);

        unsafe {Self::new_unchecked(bulk)}
    }

    pub(crate) const unsafe fn new_unchecked(bulk: B) -> Self
    {
        Self { bulk }
    }
}

const impl<B> IntoIterator for Pinned<B>
where
    B: Bulk<Item: Deref, IntoIter: [const] Iterator> + [const] IntoIterator
{
    type IntoIter = iter::Map<B::IntoIter, impl Fn(B::Item) -> Pin<B::Item>>;
    type Item = Pin<B::Item>;

    fn into_iter(self) -> Self::IntoIter
    {
        self.bulk.into_iter().map(Functor)
    }
}
const impl<B> Bulk for Pinned<B>
where
    B: [const] Bulk<Item: Deref + [const] Destruct>
{
    type MaxLength = B::MaxLength;
    type MinLength = B::MinLength;

    fn len(&self) -> usize
    {
        self.bulk.len()
    }

    fn length(&self) -> array_trait::length::Value<crate::BulkLength<Self>>
    {
        self.bulk.length()
    }

    fn for_each<F>(self, f: F)
    where
        Self: Sized,
        F: [const] FnMut(Self::Item) + [const] core::marker::Destruct
    {
        self.bulk.map(Functor).for_each(f);
    }

    fn try_for_each<F, R>(self, f: F) -> R
    where
        Self: Sized,
        Self::Item: [const] core::marker::Destruct,
        F: [const] FnMut(Self::Item) -> R + [const] core::marker::Destruct,
        R: [const] core::ops::Try<Output = (), Residual: [const] core::marker::Destruct>
    {
        self.bulk.map(Functor).try_for_each(f)
    }
}

struct Functor;
const impl<T> FnOnce<(T,)> for Functor
where
    T: Deref
{
    type Output = Pin<T>;

    extern "rust-call" fn call_once(self, args: (T,)) -> Self::Output
    {
        self.call(args)
    }
}
const impl<T> FnMut<(T,)> for Functor
where
    T: Deref
{
    extern "rust-call" fn call_mut(&mut self, args: (T,)) -> Self::Output
    {
        self.call(args)
    }
}
const impl<T> Fn<(T,)> for Functor
where
    T: Deref
{
    extern "rust-call" fn call(&self, (x,): (T,)) -> Self::Output
    {
        unsafe { Pin::new_unchecked(x) }
    }
}