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

/// Coerces `reference` to a type that has a `const_eq` or `const_cmp` method.
///
/// # Behavior
///
/// This requires arguments to implement the [`ConstCmp`] trait.
///
/// When a type from the standard library is passed,
/// this wraps it inside a [`CmpWrapper`],
/// which declares `const_eq` and `const_cmp` methods for many standard library types.
///
/// When a user-defined type is used, this evaluates to a reference to the passed in value,
/// dereferencing it as necessary.
///
/// # Limitations
///
/// The parameter(s) must be concrete types, and have a fully inferred type.
/// eg: if you pass an integer literal it must have a suffix to indicate its type.
///
/// # Example
///
/// ```rust
/// use konst::cmp::{CmpWrapper, coerce_to_cmp, impl_cmp};
///
/// struct Unit;
///
/// impl_cmp!{
///     impl Unit;
///     
///     pub const fn const_eq(&self, other: &Self) -> bool {
///         true
///     }
/// }
///
/// let wrapper: &CmpWrapper<i32> = coerce_to_cmp!(0i32);
/// assert!( wrapper.const_eq(&0));
/// assert!(!wrapper.const_eq(&1));
///
/// let unit: &Unit = coerce_to_cmp!(Unit);
/// assert!( unit.const_eq(&Unit));
///
///
///
///
///
///
/// ```
///
/// [`ConstCmp`]: crate::cmp::ConstCmp
/// [`CmpWrapper`]: crate::cmp::CmpWrapper
///
#[cfg_attr(feature = "docsrs", doc(cfg(feature = "cmp")))]
pub use crate::__coerce_to_cmp as coerce_to_cmp;

#[doc(hidden)]
#[macro_export]
macro_rules! __coerce_to_cmp {
    ($reference:expr $(,)*) => {
        match $crate::__assert_const_cmp!(&$reference).reff {
            reference => {
                let marker = $crate::__::IsAConstCmp::NEW;
                if false {
                    _ = marker.infer_type(reference);
                }
                marker.coerce(reference)
            }
        }
    };
}

#[doc(hidden)]
#[macro_export]
macro_rules! __coerce_to_cmp2 {
    ($left:expr, $right:expr $(,)*) => {
        match ($left, $right) {
            (left, right) => {
                let l_marker = $crate::__::IsAConstCmp::NEW;
                let r_marker = $crate::__::IsAConstCmp::NEW;
                if false {
                    _ = l_marker.infer_type(left);
                    _ = r_marker.infer_type(right);
                }
                (l_marker.coerce(left), r_marker.unreference(right))
            }
        }
    };
}