non-empty-str 0.13.0

Non-empty strings.
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

pub mod import {
    pub use core::{
        cmp::{Eq, Ord, Ordering, PartialEq, PartialOrd},
        option::Option,
        result::Result,
    };
}

macro_rules! total {
    ($type: ty => $method: ident) => {
        impl $crate::internals::import::PartialEq for $type {
            fn eq(&self, other: &Self) -> bool {
                self.$method() == other.$method()
            }
        }

        impl $crate::internals::import::Eq for $type {}

        impl $crate::internals::import::PartialOrd for $type {
            fn partial_cmp(
                &self,
                other: &Self,
            ) -> $crate::internals::import::Option<$crate::internals::import::Ordering> {
                Some(self.cmp(other))
            }
        }

        impl $crate::internals::import::Ord for $type {
            fn cmp(&self, other: &Self) -> $crate::internals::import::Ordering {
                self.$method().cmp(other.$method())
            }
        }
    };
}

pub(crate) use total;

macro_rules! partial {
    (
        $one_type: ty $(=> $one_method: ident)?,
        $two_type: ty $(=> $two_method: ident)? $(,)?
    ) => {
        impl $crate::internals::import::PartialEq<$two_type> for $one_type {
            fn eq(&self, other: &$two_type) -> bool {
                self$(.$one_method())? == other$(.$two_method())?
            }
        }

        impl $crate::internals::import::PartialEq<$one_type> for $two_type {
            fn eq(&self, other: &$one_type) -> bool {
                self$(.$two_method())? == other$(.$one_method())?
            }
        }

        impl $crate::internals::import::PartialOrd<$two_type> for $one_type {
            fn partial_cmp(
                &self, other: &$two_type
            ) -> $crate::internals::import::Option<$crate::internals::import::Ordering> {
                self$(.$one_method())?.partial_cmp(other$(.$two_method())?)
            }
        }

        impl $crate::internals::import::PartialOrd<$one_type> for $two_type {
            fn partial_cmp(
                &self, other: &$one_type
            ) -> $crate::internals::import::Option<$crate::internals::import::Ordering> {
                self$(.$two_method())?.partial_cmp(other$(.$one_method())?)
            }
        }
    };
}

pub(crate) use partial;

macro_rules! attempt {
    ($result: expr) => {
        match $result {
            $crate::internals::import::Result::Ok(value) => value,
            $crate::internals::import::Result::Err(err) => {
                return $crate::internals::import::Result::Err(err)
            }
        }
    };
}

pub(crate) use attempt;

macro_rules! map_error {
    ($result: expr => $map: expr) => {
        match $result {
            $crate::internals::import::Result::Ok(value) => {
                $crate::internals::import::Result::Ok(value)
            }
            $crate::internals::import::Result::Err(error) => {
                $crate::internals::import::Result::Err($map(error))
            }
        }
    };
}

pub(crate) use map_error;