linearity 1.2.0

Library providing various operations commonly found in branchless programming
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

/*
  linearity: A library for branchless programming
    Copyright (C) 2024  advantageous-overtake

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/

//! Facilities for casting between primitive types in a generic fashion.
//!
//! See [`Cast`] for more information.

macro_rules! impl_castable {
    (
        $target_type:ty as
        $(
            $target_out:ty
        )+

        $(,)?
    ) => {
        $(
            impl Cast<$target_out> for $target_type {
                #[inline]
                fn cast(self) -> $target_out {
                    self as $target_out
                }
            }
        )+
    };
    (
        $(
            $target_type:ty
        )+

        $(,)?
    ) => {
        $(
            $crate::primitive::primitive_list!($crate::primitive::cast::impl_castable => $target_type);
        )+
    };
}

macro_rules! impl_tests {
    (
        $target_type:ty as
        $(
            $target_out:ty
        )+

        $(,)?
    ) => {
        $crate::primitive::item! {
            $(
                #[test]
                fn [< cast_ $target_type:snake _as_ $target_out:snake _ max >]() {
                    let target = <$target_type>::MAX;
                    let result: $target_out = target.cast();

                    assert_eq!(result, target as $target_out);
                }

                #[test]
                fn [< cast_ $target_type:snake _as_ $target_out:snake _ min >]() {
                    let target = <$target_type>::MIN;
                    let result: $target_out = target.cast();

                    assert_eq!(result, target as $target_out);
                }
            )+
        }
    };
    (
        $(
            $target_type:ty
        )+

        $(,)?
    ) => {
        #[cfg(test)]
        mod tests {
            use super::Cast;

            $(
                $crate::primitive::primitive_list!($crate::primitive::cast::impl_tests => $target_type);
            )+
        }
    };
}

pub(self) use impl_castable;
pub(self) use impl_tests;

use crate::primitive::primitive_list;

/// A trait for casting between primitive types.
// FIXME: Make this a sealed trait.
pub trait Cast<O> {
    /// Explicitly cast the value to the target type `O`.
    fn cast(self) -> O;
}

primitive_list!(impl_castable);

primitive_list!(impl_tests);