refining-int 0.1.0

Refining integers.
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

//! Predicates for bytes.

use core::{fmt, marker::PhantomData};

use refining_core::{logical::Not, predicate::Predicate};

use crate::{internals::predicate, predicates::u8};

/// Represents the null byte.
pub const NULL: u8 = b'\0';

/// Checks whether the byte is [`NULL`].
pub struct ByteNull {
    private: PhantomData<()>,
}

/// The `null byte` literal.
pub const NULL_MESSAGE: &str = "null byte";

/// The `byte::null` literal.
pub const NULL_CODE: &str = "byte::null";

impl Predicate<u8> for ByteNull {
    fn check(value: &u8) -> bool {
        Self::check_value(*value)
    }

    fn check_value(value: u8) -> bool {
        value == NULL
    }

    fn expect(formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter.write_str(NULL_MESSAGE)
    }

    fn expect_code(formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter.write_str(NULL_CODE)
    }
}

/// Checks whether the byte is non-[`NULL`].
pub type ByteNonNull = Not<ByteNull>;

predicate! {
    Name = ByteAscii,
    Method = is_ascii,
    Doc = "Checks whether the given byte is within the ASCII range.",
    Expected = "ascii byte",
    Code = byte::ascii,
}

predicate! {
    Name = ByteAsciiAlphabetic,
    Method = is_ascii_alphabetic,
    Doc = "Checks whether the given byte is an ASCII alphabetic character.",
    Expected = "ascii alphabetic byte",
    Code = byte::ascii::alphabetic,
}

predicate! {
    Name = ByteAsciiAlphanumeric,
    Method = is_ascii_alphanumeric,
    Doc = "Checks whether the given byte is an ASCII alphanumeric character.",
    Expected = "ascii alphanumeric byte",
    Code = byte::ascii::alphanumeric,
}

predicate! {
    Name = ByteAsciiControl,
    Method = is_ascii_control,
    Doc = "Checks whether the given byte is an ASCII control character.",
    Expected = "ascii control byte",
    Code = byte::ascii::control,
}

predicate! {
    Name = ByteAsciiDigit,
    Method = is_ascii_digit,
    Doc = "Checks whether the given byte is an ASCII digit.",
    Expected = "ascii digit byte",
    Code = byte::ascii::digit,
}

predicate! {
    Name = ByteAsciiGraphic,
    Method = is_ascii_graphic,
    Doc = "Checks whether the given byte is an ASCII graphic character.",
    Expected = "ascii graphic byte",
    Code = byte::ascii::graphic,
}

predicate! {
    Name = ByteAsciiLowercase,
    Method = is_ascii_lowercase,
    Doc = "Checks whether the given byte is an ASCII lowercase character.",
    Expected = "ascii lowercase byte",
    Code = byte::ascii::lowercase,
}

predicate! {
    Name = ByteAsciiPunctuation,
    Method = is_ascii_punctuation,
    Doc = "Checks whether the given byte is an ASCII punctuation character.",
    Expected = "ascii punctuation byte",
    Code = byte::ascii::punctuation,
}

predicate! {
    Name = ByteAsciiUppercase,
    Method = is_ascii_uppercase,
    Doc = "Checks whether the given byte is an ASCII uppercase character.",
    Expected = "ascii uppercase byte",
    Code = byte::ascii::uppercase,
}

predicate! {
    Name = ByteAsciiWhitespace,
    Method = is_ascii_whitespace,
    Doc = "Checks whether the given byte is an ASCII whitespace character.",
    Expected = "ascii whitespace byte",
    Code = byte::ascii::whitespace,
}