konst 0.3.17

Const equivalents of std functions, compile-time comparison, 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


#[doc(hidden)]
#[macro_export]
macro_rules! __array_map_by_val {
    ($array:expr, $($closure:tt)* ) => (
        $crate::__::__parse_closure_1!{
            ($crate::__array_map2__with_parsed_closure)
            ($array,)
            (array_map),
            $($closure)*
        }
    );
}

#[doc(hidden)]
#[macro_export]
macro_rules! __array_map2__with_parsed_closure {
    (
        $array:expr,
        ($($pattern:tt)*) $(-> $ret:ty)? $mapper:block $(,)?
    ) => (match $crate::array::ArrayConsumer::new($array) {
        mut consumer => {

            let mut builder = $crate::array::ArrayBuilder::new();

            builder.infer_length_from_consumer(&consumer);

            while let Some(elem) = consumer.next() {
                let elem = $crate::__::ManuallyDrop::into_inner(elem);
                let $($pattern)* = elem;
                let mapped $(: $ret)? = $mapper;
                builder.push(mapped);
            }
            $crate::__::mem::forget(consumer);

            builder.build()
        }
    })
}

#[doc(hidden)]
#[macro_export]
macro_rules! __array_from_fn2 {
    ($($args:tt)*) => ({
        $crate::__::__split_array_type_and_closure!{
            (($crate::__array_from_fn2__splitted_type_and_closure) ())
            ()
            ($($args)*)
        }
    });
}

#[doc(hidden)]
#[macro_export]
macro_rules! __array_from_fn2__splitted_type_and_closure {
    ($type:tt $($closure_unparsed:tt)*) => {
        $crate::__::__parse_closure_1!{
            ($crate::__array_from_fn_with_parsed_closure)
            ($type)
            (from_fn_),

            $($closure_unparsed)*
        }
    }
}

#[doc(hidden)]
#[macro_export]
macro_rules! __array_from_fn_with_parsed_closure {
    (
        ($($($type:tt)+)?)

        ($($pattern:tt)*) $(-> $ret:ty)? $mapper:block $(,)?
    ) => ({
        let mut i = 0usize;

        let arr $(: $crate::__::__unparenthesize_ty!($($type)*))? =
            $crate::__array_map2__with_parsed_closure!{
                $crate::__::unit_array(),
                (()) $(-> $ret)? {
                    let $($pattern)* = i;
                    i+=1;
                    $mapper
                }
            };

        arr
    });
}