`pub struct Number { /* private fields */ }`

## Expand description

Represents a JSON number, whether integer or floating point.

## Implementations§

Source§### impl Number

### impl Number

Source#### pub fn is_i64(&self) -> bool

#### pub fn is_i64(&self) -> bool

Returns true if the `Number`

is an integer between `i64::MIN`

and
`i64::MAX`

.

For any Number on which `is_i64`

returns true, `as_i64`

is guaranteed to
return the integer value.

```
let big = i64::MAX as u64 + 10;
let v = json!({ "a": 64, "b": big, "c": 256.0 });
assert!(v["a"].is_i64());
// Greater than i64::MAX.
assert!(!v["b"].is_i64());
// Numbers with a decimal point are not considered integers.
assert!(!v["c"].is_i64());
```

Source#### pub fn is_u64(&self) -> bool

#### pub fn is_u64(&self) -> bool

Returns true if the `Number`

is an integer between zero and `u64::MAX`

.

For any Number on which `is_u64`

returns true, `as_u64`

is guaranteed to
return the integer value.

```
let v = json!({ "a": 64, "b": -64, "c": 256.0 });
assert!(v["a"].is_u64());
// Negative integer.
assert!(!v["b"].is_u64());
// Numbers with a decimal point are not considered integers.
assert!(!v["c"].is_u64());
```

Source#### pub fn is_f64(&self) -> bool

#### pub fn is_f64(&self) -> bool

Returns true if the `Number`

can be represented by f64.

For any Number on which `is_f64`

returns true, `as_f64`

is guaranteed to
return the floating point value.

Currently this function returns true if and only if both `is_i64`

and
`is_u64`

return false but this is not a guarantee in the future.

```
let v = json!({ "a": 256.0, "b": 64, "c": -64 });
assert!(v["a"].is_f64());
// Integers.
assert!(!v["b"].is_f64());
assert!(!v["c"].is_f64());
```

Source#### pub fn as_i64(&self) -> Option<i64>

#### pub fn as_i64(&self) -> Option<i64>

If the `Number`

is an integer, represent it as i64 if possible. Returns
None otherwise.

```
let big = i64::MAX as u64 + 10;
let v = json!({ "a": 64, "b": big, "c": 256.0 });
assert_eq!(v["a"].as_i64(), Some(64));
assert_eq!(v["b"].as_i64(), None);
assert_eq!(v["c"].as_i64(), None);
```

Source#### pub fn as_u64(&self) -> Option<u64>

#### pub fn as_u64(&self) -> Option<u64>

If the `Number`

is an integer, represent it as u64 if possible. Returns
None otherwise.

```
let v = json!({ "a": 64, "b": -64, "c": 256.0 });
assert_eq!(v["a"].as_u64(), Some(64));
assert_eq!(v["b"].as_u64(), None);
assert_eq!(v["c"].as_u64(), None);
```

Source#### pub fn as_f64(&self) -> Option<f64>

#### pub fn as_f64(&self) -> Option<f64>

Represents the number as f64 if possible. Returns None otherwise.

```
let v = json!({ "a": 256.0, "b": 64, "c": -64 });
assert_eq!(v["a"].as_f64(), Some(256.0));
assert_eq!(v["b"].as_f64(), Some(64.0));
assert_eq!(v["c"].as_f64(), Some(-64.0));
```

Source#### pub fn from_f64(f: f64) -> Option<Number>

#### pub fn from_f64(f: f64) -> Option<Number>

Converts a finite `f64`

to a `Number`

. Infinite or NaN values are not JSON
numbers.

```
assert!(Number::from_f64(256.0).is_some());
assert!(Number::from_f64(f64::NAN).is_none());
```

Source#### pub fn as_str(&self) -> &str

#### pub fn as_str(&self) -> &str

Returns the exact original JSON representation that this Number was parsed from.

For numbers constructed not via parsing, such as by `From<i32>`

, returns
the JSON representation that serde_json would serialize for this
number.

```
for value in [
"7",
"12.34",
"34e-56789",
"0.0123456789000000012345678900000001234567890000123456789",
"343412345678910111213141516171819202122232425262728293034",
"-343412345678910111213141516171819202122232425262728293031",
] {
let number: Number = serde_json::from_str(value).unwrap();
assert_eq!(number.as_str(), value);
}
```

## Trait Implementations§

Source§### impl<'de> Deserialize<'de> for Number

### impl<'de> Deserialize<'de> for Number

Source§#### fn deserialize<D>(deserializer: D) -> Result<Number, D::Error>where
D: Deserializer<'de>,

#### fn deserialize<D>(deserializer: D) -> Result<Number, D::Error>where
D: Deserializer<'de>,

Source§### impl<'de, 'a> Deserializer<'de> for &'a Number

### impl<'de, 'a> Deserializer<'de> for &'a Number

Source§#### type Error = Error

#### type Error = Error

Source§#### fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

#### fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

`Deserializer`

to figure out how to drive the visitor based
on what data type is in the input. Read moreSource§#### fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

#### fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting an `i8`

value.Source§#### fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

#### fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting an `i16`

value.Source§#### fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

#### fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting an `i32`

value.Source§#### fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

#### fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting an `i64`

value.Source§#### fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

#### fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a `u8`

value.Source§#### fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

#### fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a `u16`

value.Source§#### fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

#### fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a `u32`

value.Source§#### fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

#### fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a `u64`

value.Source§#### fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

#### fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a `f32`

value.Source§#### fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

#### fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a `f64`

value.Source§#### fn deserialize_bool<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_bool<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a `bool`

value.Source§#### fn deserialize_char<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_char<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a `char`

value.Source§#### fn deserialize_str<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_str<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a string value and does
not benefit from taking ownership of buffered data owned by the
`Deserializer`

. Read moreSource§#### fn deserialize_string<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_string<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a string value and would
benefit from taking ownership of buffered data owned by the
`Deserializer`

. Read moreSource§#### fn deserialize_bytes<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_bytes<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a byte array and does not
benefit from taking ownership of buffered data owned by the
`Deserializer`

. Read moreSource§#### fn deserialize_byte_buf<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_byte_buf<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a byte array and would
benefit from taking ownership of buffered data owned by the
`Deserializer`

. Read moreSource§#### fn deserialize_option<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_option<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting an optional value. Read moreSource§#### fn deserialize_unit<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_unit<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a unit value.Source§#### fn deserialize_unit_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_unit_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a unit struct with a
particular name.Source§#### fn deserialize_newtype_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_newtype_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a newtype struct with a
particular name.Source§#### fn deserialize_seq<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_seq<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a sequence of values.Source§#### fn deserialize_tuple<V>(
self,
len: usize,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_tuple<V>(
self,
len: usize,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a sequence of values and
knows how many values there are without looking at the serialized data.Source§#### fn deserialize_tuple_struct<V>(
self,
name: &'static str,
len: usize,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_tuple_struct<V>(
self,
name: &'static str,
len: usize,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a tuple struct with a
particular name and number of fields.Source§#### fn deserialize_map<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_map<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a map of key-value pairs.Source§#### fn deserialize_struct<V>(
self,
name: &'static str,
fields: &'static [&'static str],
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_struct<V>(
self,
name: &'static str,
fields: &'static [&'static str],
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a struct with a particular
name and fields.Source§#### fn deserialize_enum<V>(
self,
name: &'static str,
variants: &'static [&'static str],
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_enum<V>(
self,
name: &'static str,
variants: &'static [&'static str],
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting an enum value with a
particular name and possible variants.Source§#### fn deserialize_identifier<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_identifier<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting the name of a struct
field or the discriminant of an enum variant.Source§#### fn deserialize_ignored_any<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_ignored_any<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type needs to deserialize a value whose type
doesn’t matter because it is ignored. Read moreSource§#### fn is_human_readable(&self) -> bool

#### fn is_human_readable(&self) -> bool

`Deserialize`

implementations should expect to
deserialize their human-readable form. Read moreSource§### impl<'de> Deserializer<'de> for Number

### impl<'de> Deserializer<'de> for Number

Source§#### type Error = Error

#### type Error = Error

Source§#### fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

#### fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

`Deserializer`

to figure out how to drive the visitor based
on what data type is in the input. Read moreSource§#### fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

#### fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting an `i8`

value.Source§#### fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

#### fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting an `i16`

value.Source§#### fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

#### fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting an `i32`

value.Source§#### fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

#### fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting an `i64`

value.Source§#### fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

#### fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a `u8`

value.Source§#### fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

#### fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a `u16`

value.Source§#### fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

#### fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a `u32`

value.Source§#### fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

#### fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a `u64`

value.Source§#### fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

#### fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a `f32`

value.Source§#### fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

#### fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a `f64`

value.Source§#### fn deserialize_bool<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_bool<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a `bool`

value.Source§#### fn deserialize_char<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_char<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a `char`

value.Source§#### fn deserialize_str<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_str<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a string value and does
not benefit from taking ownership of buffered data owned by the
`Deserializer`

. Read moreSource§#### fn deserialize_string<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_string<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a string value and would
benefit from taking ownership of buffered data owned by the
`Deserializer`

. Read moreSource§#### fn deserialize_bytes<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_bytes<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a byte array and does not
benefit from taking ownership of buffered data owned by the
`Deserializer`

. Read moreSource§#### fn deserialize_byte_buf<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_byte_buf<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a byte array and would
benefit from taking ownership of buffered data owned by the
`Deserializer`

. Read moreSource§#### fn deserialize_option<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_option<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting an optional value. Read moreSource§#### fn deserialize_unit<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_unit<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a unit value.Source§#### fn deserialize_unit_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_unit_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a unit struct with a
particular name.Source§#### fn deserialize_newtype_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_newtype_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a newtype struct with a
particular name.Source§#### fn deserialize_seq<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_seq<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a sequence of values.Source§#### fn deserialize_tuple<V>(
self,
len: usize,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_tuple<V>(
self,
len: usize,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a sequence of values and
knows how many values there are without looking at the serialized data.Source§#### fn deserialize_tuple_struct<V>(
self,
name: &'static str,
len: usize,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_tuple_struct<V>(
self,
name: &'static str,
len: usize,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a tuple struct with a
particular name and number of fields.Source§#### fn deserialize_map<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_map<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a map of key-value pairs.Source§#### fn deserialize_struct<V>(
self,
name: &'static str,
fields: &'static [&'static str],
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_struct<V>(
self,
name: &'static str,
fields: &'static [&'static str],
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting a struct with a particular
name and fields.Source§#### fn deserialize_enum<V>(
self,
name: &'static str,
variants: &'static [&'static str],
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_enum<V>(
self,
name: &'static str,
variants: &'static [&'static str],
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting an enum value with a
particular name and possible variants.Source§#### fn deserialize_identifier<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_identifier<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type is expecting the name of a struct
field or the discriminant of an enum variant.Source§#### fn deserialize_ignored_any<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

#### fn deserialize_ignored_any<V>(
self,
visitor: V,
) -> Result<V::Value, <Self as Deserializer<'de>>::Error>where
V: Visitor<'de>,

`Deserialize`

type needs to deserialize a value whose type
doesn’t matter because it is ignored. Read moreSource§#### fn is_human_readable(&self) -> bool

#### fn is_human_readable(&self) -> bool

`Deserialize`

implementations should expect to
deserialize their human-readable form. Read more### impl Eq for Number

### impl StructuralPartialEq for Number

## Auto Trait Implementations§

### impl Freeze for Number

### impl RefUnwindSafe for Number

### impl Send for Number

### impl Sync for Number

### impl Unpin for Number

### impl UnwindSafe for Number

## Blanket Implementations§

Source§### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

Source§#### fn borrow_mut(&mut self) -> &mut T

#### fn borrow_mut(&mut self) -> &mut T

Source§### impl<T> CloneToUninit for Twhere
T: Clone,

### impl<T> CloneToUninit for Twhere
T: Clone,

Source§#### unsafe fn clone_to_uninit(&self, dst: *mut T)

#### unsafe fn clone_to_uninit(&self, dst: *mut T)

`clone_to_uninit`

)Source§### impl<Q, K> Equivalent<K> for Q

### impl<Q, K> Equivalent<K> for Q

Source§### impl<Q, K> Equivalent<K> for Q

### impl<Q, K> Equivalent<K> for Q

Source§#### fn equivalent(&self, key: &K) -> bool

#### fn equivalent(&self, key: &K) -> bool

`key`

and return `true`

if they are equal.