    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

    use super::Value;
    use alloc::string::String;

    fn eq_i64(value: &Value, other: i64) -> bool {
        value.as_i64().map_or(false, |i| i == other)
    }

    fn eq_u64(value: &Value, other: u64) -> bool {
        value.as_u64().map_or(false, |i| i == other)
    }

    fn eq_f64(value: &Value, other: f64) -> bool {
        value.as_f64().map_or(false, |i| i == other)
    }

    fn eq_bool(value: &Value, other: bool) -> bool {
        value.as_bool().map_or(false, |i| i == other)
    }

    fn eq_str(value: &Value, other: &str) -> bool {
        value.as_str().map_or(false, |i| i == other)
    }

    impl PartialEq<str> for Value {
        fn eq(&self, other: &str) -> bool {
            eq_str(self, other)
        }
    }

    impl<'a> PartialEq<&'a str> for Value {
        fn eq(&self, other: &&str) -> bool {
            eq_str(self, *other)
        }
    }

    impl PartialEq<Value> for str {
        fn eq(&self, other: &Value) -> bool {
            eq_str(other, self)
        }
    }

    impl<'a> PartialEq<Value> for &'a str {
        fn eq(&self, other: &Value) -> bool {
            eq_str(other, *self)
        }
    }

    impl PartialEq<String> for Value {
        fn eq(&self, other: &String) -> bool {
            eq_str(self, other.as_str())
        }
    }

    impl PartialEq<Value> for String {
        fn eq(&self, other: &Value) -> bool {
            eq_str(other, self.as_str())
        }
    }

    macro_rules! partialeq_numeric {
        ($($eq:ident [$($ty:ty)*])*) => {
            $($(
                impl PartialEq<$ty> for Value {
                    fn eq(&self, other: &$ty) -> bool {
                        $eq(self, *other as _)
                    }
                }

                impl PartialEq<Value> for $ty {
                    fn eq(&self, other: &Value) -> bool {
                        $eq(other, *self as _)
                    }
                }

                impl<'a> PartialEq<$ty> for &'a Value {
                    fn eq(&self, other: &$ty) -> bool {
                        $eq(*self, *other as _)
                    }
                }

                impl<'a> PartialEq<$ty> for &'a mut Value {
                    fn eq(&self, other: &$ty) -> bool {
                        $eq(*self, *other as _)
                    }
                }
            )*)*
        }
    }

    partialeq_numeric! {
        eq_i64[i8 i16 i32 i64 isize]
        eq_u64[u8 u16 u32 u64 usize]
        eq_f64[f32 f64]
        eq_bool[bool]
    }