const-it 0.2.0

Utilities for const evaluation; slicing, error handling
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

#![allow(clippy::bool_assert_comparison)]

use super::*;
use core::{
    cmp::Ordering,
    ops::{Range, RangeInclusive},
};

macro_rules! cmp_slice {
    ($t:ty, $item:expr, $index:expr) => {{
        const SLICED: $t = slice!($item, $index);
        assert_eq!(SLICED, &$item[$index]);

        const TRY_SLICED: Option<$t> = try_slice!($item, $index);
        assert_eq!(TRY_SLICED, Some(&$item[$index]));
    }};
}

macro_rules! slice_fail {
    ($t:ty, $item:expr, $index:expr) => {{
        const TRY_SLICED: Option<$t> = try_slice!($item, $index);
        assert_eq!(TRY_SLICED, None);
    }};
}

#[test]
fn str_slice() {
    cmp_slice!(&str, "abcde", 1..3);
    cmp_slice!(&str, "abcde", 1..=3);
    cmp_slice!(&str, "abcde", 1..);
    cmp_slice!(&str, "abcde", ..3);
    cmp_slice!(&str, "abcde", ..=3);
    cmp_slice!(&str, "abcde", ..);
    cmp_slice!(&str, "abcde", 3..3);
    cmp_slice!(&str, "abcde", 3..=3);
    cmp_slice!(&str, "✨💖", ..3);
    cmp_slice!(&str, "✨💖", 3..);

    slice_fail!(&str, "abcde", Range { start: 4, end: 3 });
    slice_fail!(&str, "abcde", RangeInclusive::new(4, 3));
    slice_fail!(&str, "✨", 1..);
    slice_fail!(&str, "✨", ..1);
}

#[test]
fn byte_slice() {
    cmp_slice!(&[u8], b"abcde", 1..3);
    cmp_slice!(&[u8], b"abcde", 1..=3);
    cmp_slice!(&[u8], b"abcde", 1..);
    cmp_slice!(&[u8], b"abcde", ..3);
    cmp_slice!(&[u8], b"abcde", ..=3);
    cmp_slice!(&[u8], b"abcde", ..);
    cmp_slice!(&[u8], b"abcde", 3..3);
    cmp_slice!(&[u8], b"abcde", 3..=3);

    slice_fail!(&[u8], b"abcde", Range { start: 4, end: 3 });
    slice_fail!(&[u8], b"abcde", RangeInclusive::new(4, 3));
}

#[test]
fn slice_split_at() {
    const SPLIT: (&str, &str) = slice_split_at!("abcde", 3);
    assert_eq!(SPLIT.0, "abc");
    assert_eq!(SPLIT.1, "de");

    const TRY_SPLIT: Option<(&str, &str)> = slice_try_split_at!("abcde", 9);
    assert_eq!(TRY_SPLIT, None);

    const TRY_SPLIT_2: Option<(&str, &str)> = slice_try_split_at!("✨💖", 2);
    assert_eq!(TRY_SPLIT_2, None);

    const SPLIT_2: (&str, &str) = slice_split_at!("✨💖", 3);
    assert_eq!(SPLIT_2, ("✨", "💖"));
}

#[test]
fn eq() {
    const EMPTY: bool = slice_eq!("", "");
    assert_eq!(EMPTY, true);

    const EQ: bool = slice_eq!("hi", "hi");
    assert_eq!(EQ, true);

    const NEQ: bool = slice_eq!("hi", "ho");
    assert_eq!(NEQ, false);

    const NEQ2: bool = slice_eq!("hi", "hello");
    assert_eq!(NEQ2, false);
}

#[test]
fn cmp() {
    const CMP1: Ordering = slice_cmp!("hi", "hi");
    assert_eq!(CMP1, Ordering::Equal);

    const CMP2: Ordering = slice_cmp!("hi", "ho");
    assert_eq!(CMP2, Ordering::Less);

    const CMP3: Ordering = slice_cmp!("ho", "hi");
    assert_eq!(CMP3, Ordering::Greater);

    const CMP4: Ordering = slice_cmp!("h", "hi");
    assert_eq!(CMP4, Ordering::Less);

    const CMP5: Ordering = slice_cmp!("hi", "h");
    assert_eq!(CMP5, Ordering::Greater);
}

#[test]
fn prefix() {
    const STARTS_WITH: bool = slice_starts_with!("abcde", "ab");
    assert_eq!(STARTS_WITH, true);

    const NOT_STARTS_WITH: bool = slice_starts_with!("abcde", "aba");
    assert_eq!(NOT_STARTS_WITH, false);

    const STRIPPED: Option<&str> = slice_strip_prefix!("abcde", "abc");
    assert_eq!(STRIPPED, Some("de"));

    const NOT_STRIPPED: Option<&str> = slice_strip_prefix!("abcde", "ace");
    assert_eq!(NOT_STRIPPED, None);
}

#[test]
fn suffix() {
    const ENDS_WITH: bool = slice_ends_with!("abcde", "de");
    assert_eq!(ENDS_WITH, true);

    const NOT_ENDS_WITH: bool = slice_ends_with!("abcde", "ee");
    assert_eq!(NOT_ENDS_WITH, false);

    const STRIPPED: Option<&str> = slice_strip_suffix!("abcde", "cde");
    assert_eq!(STRIPPED, Some("ab"));

    const NOT_STRIPPED: Option<&str> = slice_strip_suffix!("abcde", "cdf");
    assert_eq!(NOT_STRIPPED, None);
}