bulks 0.7.2

Amazing bulks! They are like iterators, but in bulk, and therefore support collection into arrays.
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

use core::borrow::{Borrow, BorrowMut};
use core::{marker::Destruct, ops::Residual};
use core::ops::{Index, IndexMut, Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive, Try};

use array_trait::AsSlice;

use crate::{AsBulk, Bulk, IntoBulk, StaticBulk};

pub(crate) const trait Collection<T> = ~const IntoBulk<Item = T, IntoBulk: ~const Bulk<Item = T>>
    + ~const AsBulk
    + ~const AsSlice<Elem = T>
    + ~const AsRef<[T]>
    + ~const AsMut<[T]>
    + ~const Borrow<[T]>
    + ~const BorrowMut<[T]>
    + ~const IndexMut<usize, Output = <[T] as Index<usize>>::Output>
    + ~const IndexMut<Range<usize>, Output = <[T] as Index<Range<usize>>>::Output>
    + ~const IndexMut<RangeInclusive<usize>, Output = <[T] as Index<RangeInclusive<usize>>>::Output>
    + ~const IndexMut<RangeFrom<usize>, Output = <[T] as Index<RangeFrom<usize>>>::Output>
    + ~const IndexMut<RangeTo<usize>, Output = <[T] as Index<RangeTo<usize>>>::Output>
    + ~const IndexMut<RangeToInclusive<usize>, Output = <[T] as Index<RangeToInclusive<usize>>>::Output>
    + ~const IndexMut<RangeFull, Output = <[T] as Index<RangeFull>>::Output>;

#[rustc_on_unimplemented(
    message = "an array cannot be collected from dynamically sized bulk `{Self}`",
    label = "an array cannot be collected from bulk"
)]
pub const trait CollectNearest: ~const Bulk
{
    #[allow(private_bounds)]
    type Nearest: ~const Collection<Self::Item>;
    #[allow(private_bounds)]
    type TryNearest: ~const Collection<<Self::Item as Try>::Output>
    where
        Self::Item: ~const Try;

    /// Collects into an array if possible, otherwise a vector
    #[must_use = "if you really need to exhaust the bulk, consider `.for_each(drop)` instead"]
    fn collect_nearest(self) -> Self::Nearest
    where
        Self: Sized;

    /// Fallibly collects into an array if possible, otherwise a vector
    #[must_use = "if you really need to exhaust the bulk, consider `.for_each(drop)` instead"]
    fn try_collect_nearest(self) -> <<Self::Item as Try>::Residual as Residual<Self::TryNearest>>::TryType
    where
        Self: Sized,
        <Self as IntoIterator>::Item: ~const Try + ~const Destruct,
        <<Self as IntoIterator>::Item as Try>::Output: ~const Destruct,
        <<Self as IntoIterator>::Item as Try>::Residual: ~const Residual<Self::TryNearest> + ~const Residual<()> + ~const Destruct;
}

#[cfg(feature = "alloc")]
impl<I> CollectNearest for I
where
    I: Bulk
{
    default type Nearest = alloc::vec::Vec<I::Item>;
    default type TryNearest = alloc::vec::Vec<<I::Item as Try>::Output>
    where
        Self::Item: Try;

    default fn collect_nearest(self) -> Self::Nearest
    {
        use array_trait::same::Same;

        self.collect::<alloc::vec::Vec<_>, _>().same().ok().unwrap()
    }
    default fn try_collect_nearest(self) -> <<Self::Item as Try>::Residual as Residual<Self::TryNearest>>::TryType
    where
        <Self as IntoIterator>::Item: Try,
        <<Self as IntoIterator>::Item as Try>::Residual: Residual<Self::TryNearest> + Residual<()>
    {
        vec_spec::CollectVecSpec::<Self::TryNearest>::try_collect_vec(self)
    }
}
impl<I> const CollectNearest for I
where
    I: ~const Bulk + StaticBulk
{
    type Nearest = I::Array<I::Item>;
    type TryNearest = I::Array<<I::Item as Try>::Output>
    where
        Self::Item: Try;

    fn collect_nearest(self) -> Self::Nearest
    where
        Self: Sized
    {
        self.collect_array()
    }
    fn try_collect_nearest(self) -> <<Self::Item as Try>::Residual as Residual<Self::TryNearest>>::TryType
    where
        Self: Sized,
        <Self as IntoIterator>::Item: ~const Try + ~const Destruct,
        <<Self as IntoIterator>::Item as Try>::Output: ~const Destruct,
        <<Self as IntoIterator>::Item as Try>::Residual: ~const Residual<Self::TryNearest> + ~const Residual<()> + ~const Destruct
    {
        self.try_collect_array()
    }
}

#[cfg(feature = "alloc")]
mod vec_spec
{
    use core::ops::{Residual, Try};

    use array_trait::same::Same;

    use crate::Bulk;

    pub(super) trait CollectVecSpec<C>: Bulk
    {
        fn try_collect_vec(bulk: Self) -> <<Self::Item as Try>::Residual as Residual<C>>::TryType
        where
            <Self as IntoIterator>::Item: Try,
            <<Self as IntoIterator>::Item as Try>::Residual: Residual<C> + Residual<()>;
    }

    impl<I, C> CollectVecSpec<C> for I
    where
        I: Bulk
    {
        default fn try_collect_vec(bulk: Self) -> <<Self::Item as Try>::Residual as Residual<C>>::TryType
        where
            <Self as IntoIterator>::Item: Try,
            <<Self as IntoIterator>::Item as Try>::Residual: Residual<C> + Residual<()>
        {
            let mut vec = alloc::vec::Vec::with_capacity(bulk.len());
            for item in bulk
            {
                vec.push(item?);
            }
            Try::from_output(vec.same().ok().unwrap())
        }
    }
    impl<I> CollectVecSpec<alloc::vec::Vec<<I::Item as Try>::Output>> for I
    where
        I: Bulk<Item: Try>
    {
        fn try_collect_vec(bulk: Self) -> <<Self::Item as Try>::Residual as Residual<alloc::vec::Vec<<I::Item as Try>::Output>>>::TryType
        where
            <Self as IntoIterator>::Item: Try,
            <<Self as IntoIterator>::Item as Try>::Residual: Residual<alloc::vec::Vec<<I::Item as Try>::Output>> + Residual<()>
        {
            bulk.try_collect::<alloc::vec::Vec<_>, _>()
        }
    }
}