konst 0.4.3

Const equivalents of std features: comparison, destructuring, iteration, and parsing
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
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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169

use typewit::{MakeTypeWitness, TypeEq, TypeWitnessTypeArg};

#[doc(hidden)]
#[macro_export]
macro_rules! __collect_const_hidden {
    (
        $Item:ty =>
        $($rem:tt)*
    ) => {{
        $crate::__collect_const_iter_with!{
            $Item ,
            {let item = $crate::__::MaybeUninit::new(item);},
            |array, length, item| array[length] = item,
            elem_length = 1,
            =>
            $($rem)*
        }

        __ARR81608BFNA5
    }}
}

/**
Collects an iterator constant into an array

# Drop behavior

The behavior regarding dropping iterators is
[documented here](crate::iter::ConstIntoIter#dropping).

# Iterator methods

This macro supports emulating iterator methods by expanding to equivalent code.

The supported iterator methods are documented in the [`iterator_dsl`] module,
because they are also supported by other `konst::iter` macros.

# Syntax

The syntax of this macro is:

```text
collect_const!(
    $Item:ty => $into_iterator:expr
        $(, $iterator_method:ident ($($method_args:tt)*) )*
        $(,)?
)
```
Where `$Item` is the type of the elements that'll be collected into an array.

Where `$into_iterator` is any type that can be converted into a const iterator, with
[`konst::iter::into_iter`](crate::iter::into_iter).

Where `$iterator_method` is any of the supported methods described in
the [`iterator_dsl`] module.

# Examples

### Iterating over a range

```rust
use konst::iter;

const ARR: [u64; 8] = iter::collect_const!(u64 =>
    10..,
        filter(|n| *n % 2 == 0),
        skip(5),
        take(8),
);

assert_eq!(ARR, [20, 22, 24, 26, 28, 30, 32, 34]);
```

### Iterating over an array

```rust
use konst::iter;

const ARR: [u8; 6] = iter::collect_const!(u8 =>
    [10, 20, 30],flat_map(|n| [n - 1, n + 1]),
);

assert_eq!(ARR, [9, 11, 19, 21, 29, 31]);
```



[`iterator_dsl`]: crate::iter::iterator_dsl
*/
#[doc(inline)]
pub use __collect_const_hidden as collect_const;

#[doc(hidden)]
#[macro_export]
macro_rules! __collect_const_iter_with {
    (
        $Item:ty,
        {$($reassign_item:tt)*},
        |$array:ident, $length:ident, $item:ident| $elem_initer:expr,
        elem_length = $elem_length:expr,
        =>
        $($rem:tt)*
    ) => {
        const fn __func_zxe7hgbnjs<Ret_KO9Y329U2U, const CAP_KO9Y329U2U: $crate::__::usize>(
            cmd: $crate::__::CollectorCmd<Ret_KO9Y329U2U, $Item, CAP_KO9Y329U2U>
        ) -> Ret_KO9Y329U2U {
            let mut $array = $crate::maybe_uninit::uninit_array::<_, CAP_KO9Y329U2U>();
            let mut $length = 0usize;

            $crate::iter::eval!{
                $($rem)*
                ,for_each(|$item| {
                    $($reassign_item)*
                    if let $crate::__::CollectorCmd::BuildArray(teq) = cmd {
                        teq.reachability_hint(());

                        $elem_initer
                    }

                    $length += $elem_length;
                })
            }

            match cmd {
                $crate::__::CollectorCmd::ComputeLength(teq) => {
                    $crate::__::forget($array);
                    teq.to_right($length)
                }
                $crate::__::CollectorCmd::BuildArray(teq) => {
                    $crate::__::assert!{
                        $length == CAP_KO9Y329U2U,
                        "initialization was skipped somehow",
                    }

                    // SAFETY: The above assert ensures that
                    // all of the array is initialized
                    let $array = unsafe{ $crate::maybe_uninit::array_assume_init($array) };
                    teq.to_right($array)
                }
            }
        }

        const __COUNT81608BFNA5: $crate::__::usize =
            __func_zxe7hgbnjs($crate::__::MakeTypeWitness::MAKE);

        const __ARR81608BFNA5: [$Item; __COUNT81608BFNA5] =
            __func_zxe7hgbnjs($crate::__::MakeTypeWitness::MAKE);


    };
}

#[doc(hidden)]
pub enum CollectorCmd<Ret, T, const CAP: usize> {
    ComputeLength(TypeEq<usize, Ret>),
    BuildArray(TypeEq<[T; CAP], Ret>),
}

impl<Ret, T, const CAP: usize> TypeWitnessTypeArg for CollectorCmd<Ret, T, CAP> {
    type Arg = Ret;
}

impl<T> MakeTypeWitness for CollectorCmd<usize, T, 0> {
    const MAKE: Self = Self::ComputeLength(TypeEq::NEW);
}

impl<T, const CAP: usize> MakeTypeWitness for CollectorCmd<[T; CAP], T, CAP> {
    const MAKE: Self = Self::BuildArray(TypeEq::NEW);
}