jso 1.3.1

No-BS, no-bloat json library.
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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

use std::collections::HashMap;

use crate::Val::{self, *};

const fn variant_name(v: &Val) -> &'static str {
  match v {
    Null => "Null",
    Bool(..) => "Bool",
    Num(..) => "Num",
    Str(..) => "Str",
    Arr(..) => "Arr",
    Obj(..) => "Obj",
  }
}

macro_rules! impl_is {
  (
    $($fn:ident $variant:ident)*
  ) => {
    $(
      #[doc = "Returns `true` if the val is [`"]
      #[doc = ::core::stringify!($variant)]
      #[doc = "`]"]
      #[must_use]
      #[inline]
      pub fn $fn(&self) -> bool {
        matches!(self, $variant(..))
      }
    )*
  };
}

macro_rules! impl_unwrap {
  (
    $($fn:ident $variant:ident $ret:ty)*
  ) => {
    $(
      #[doc = "Returns the contained [`"]
      #[doc = ::core::stringify!($variant)]
      #[doc = "`] value, consuming the `self` value."]
      #[must_use]
      #[inline]
      pub fn $fn(self) -> $ret {
        if let $variant(x) = self {
          x
        } else {
          panic!(
            "called `Val::{}()` on a `{}` value",
            ::core::stringify!($fn),
            variant_name(&self),
          );
        }
      }
    )*
  };
}

macro_rules! impl_as {
  (
    $($fn:ident $variant:ident $ret:ty)*
  ) => {
    $(
      #[expect(missing_docs)]
      #[must_use]
      #[inline]
      pub fn $fn(&self) -> Option<&$ret> {
        if let $variant(x) = self {
          Some(x)
        } else {
          None
        }
      }
    )*
  };
}

macro_rules! impl_getter {
  (
    $($fn:ident $variant:ident $ret:ty)*
  ) => {
    $(
      #[expect(missing_docs)]
      #[must_use]
      #[inline]
      pub fn $fn(self) -> Option<$ret> {
        if let $variant(x) = self {
          Some(x)
        } else {
          None
        }
      }
    )*
  };
}

impl Val {
  /// Returns `true` if the val is [`Null`]
  #[must_use]
  #[inline]
  pub fn is_null(&self) -> bool {
    self == &Null
  }
  impl_is!(
    is_bool Bool
    is_num Num
    is_str Str
    is_arr Arr
    is_obj Obj
  );

  /// Returns the contained [`Null`] value, consuming the `self` value.
  #[inline]
  pub fn unwrap_null(self) {
    assert!(
      self == Null,
      "called `Val::unwrap_null()` on a `{}` value",
      variant_name(&self),
    );
  }
  impl_unwrap!(
    unwrap_bool Bool bool
    unwrap_num Num f64
    unwrap_str Str String
    unwrap_arr Arr Vec<Self>
    unwrap_obj Obj HashMap<String, Self>
  );

  #[expect(missing_docs)]
  #[must_use]
  #[inline]
  pub fn as_null(&self) -> Option<&()> {
    if let Null = self { Some(&()) } else { None }
  }
  impl_as!(
    as_bool Bool bool
    as_num Num f64
    as_str Str String
    as_arr Arr Vec<Self>
    as_obj Obj HashMap<String, Self>
  );

  #[expect(missing_docs)]
  #[must_use]
  #[inline]
  pub fn null(self) -> Option<()> {
    if let Null = self { Some(()) } else { None }
  }
  impl_getter!(
    bool Bool bool
    num Num f64
    str Str String
    arr Arr Vec<Self>
    obj Obj HashMap<String, Self>
  );
}