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
use core::ptr::Thin;
use crate::Bulk;
pub const trait AsBulk<'a>
{
type AsBulk: Bulk + 'a;
/// Creates a bulk from a reference.
///
/// See the [crate documentation](crate) for more.
///
/// # Examples
///
/// ```
/// use bulks::*;
///
/// let v = [1, 2, 3];
/// let bulk = v.bulk();
/// let u: [_; _] = bulk.collect();
///
/// assert_eq!(u, [&1, &2, &3]);
/// ```
fn bulk(&'a self) -> Self::AsBulk;
}
pub const trait AsBulkMut<'a>
{
type AsBulkMut: Bulk + 'a;
/// Creates a bulk from a mutable reference.
///
/// See the [crate documentation](crate) for more.
///
/// # Examples
///
/// ```
/// use bulks::*;
///
/// let mut v = [1, 2, 3];
/// let bulk = v.bulk_mut();
/// let u: [_; _] = bulk.map(|v| core::mem::replace(v, *v + 1))
/// .collect();
///
/// assert_eq!(v, [2, 3, 4]);
/// assert_eq!(u, [1, 2, 3]);
/// ```
fn bulk_mut(&'a mut self) -> Self::AsBulkMut;
}
const impl<'a, T> AsBulk<'a> for T
where
T: ?Sized + 'a,
&'a T: ~const IntoBulk
{
type AsBulk = <&'a T as IntoBulk>::IntoBulk;
fn bulk(&'a self) -> Self::AsBulk {
self.into_bulk()
}
}
const impl<'a, T> AsBulkMut<'a> for T
where
T: ?Sized + 'a,
&'a mut T: ~const IntoBulk
{
type AsBulkMut = <&'a mut T as IntoBulk>::IntoBulk;
fn bulk_mut(&'a mut self) -> Self::AsBulkMut {
self.into_bulk()
}
}
pub const trait IntoBulk: IntoIterator<Item: Thin, IntoIter: ExactSizeIterator>
{
/// Which kind of bulk are we turning this into?
type IntoBulk: ~const Bulk<Item = Self::Item, IntoIter = Self::IntoIter>;
/// Creates a bulk from a value.
///
/// See the [crate documentation](crate) for more.
///
/// # Examples
///
/// ```
/// use bulks::*;
///
/// let v = [1, 2, 3];
/// let mut bulk = v.into_bulk();
/// let u: [_; _] = bulk.collect();
///
/// assert_eq!(u, [1, 2, 3]);
/// ```
fn into_bulk(self) -> Self::IntoBulk;
}
const impl<T> IntoBulk for T
where
Self: ~const Bulk
{
type IntoBulk = Self;
fn into_bulk(self) -> Self::IntoBulk
{
self
}
}