# Struct serde_test::Compact

source · `pub struct Compact<T: ?Sized>(_);`

## Trait Implementations§

source§### impl<'de, T> Deserialize<'de> for Compact<T>where
T: Deserialize<'de>,

### impl<'de, T> Deserialize<'de> for Compact<T>where T: Deserialize<'de>,

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

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

Deserialize this value from the given Serde deserializer. Read more

source§### impl<'de, T> DeserializeSeed<'de> for Compact<T>where
T: DeserializeSeed<'de>,

### impl<'de, T> DeserializeSeed<'de> for Compact<T>where T: DeserializeSeed<'de>,

§#### type Value = <T as DeserializeSeed<'de>>::Value

#### type Value = <T as DeserializeSeed<'de>>::Value

The type produced by using this seed.

source§#### fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>where
D: Deserializer<'de>,

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

Equivalent to the more common

`Deserialize::deserialize`

method, except
with some initial piece of data (the seed) passed in.source§### impl<'de, D> Deserializer<'de> for Compact<D>where
D: Deserializer<'de>,

### impl<'de, D> Deserializer<'de> for Compact<D>where D: Deserializer<'de>,

§#### type Error = <D as Deserializer<'de>>::Error

#### type Error = <D as Deserializer<'de>>::Error

The error type that can be returned if some error occurs during
deserialization.

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

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

Require the

`Deserializer`

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

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

Hint that the

`Deserialize`

type is expecting a `bool`

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

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

Hint that the

`Deserialize`

type is expecting a `u8`

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

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

Hint that the

`Deserialize`

type is expecting a `u16`

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

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

Hint that the

`Deserialize`

type is expecting a `u32`

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

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

Hint that the

`Deserialize`

type is expecting a `u64`

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

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

Hint that the

`Deserialize`

type is expecting an `i8`

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

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

Hint that the

`Deserialize`

type is expecting an `i16`

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

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

Hint that the

`Deserialize`

type is expecting an `i32`

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

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

Hint that the

`Deserialize`

type is expecting an `i64`

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

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

Hint that the

`Deserialize`

type is expecting a `f32`

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

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

Hint that the

`Deserialize`

type is expecting a `f64`

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

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

Hint that the

`Deserialize`

type is expecting a `char`

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

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

Hint that the

`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, D::Error>where
V: Visitor<'de>,

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

Hint that the

`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, D::Error>where
V: Visitor<'de>,

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

Hint that the

`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, D::Error>where
V: Visitor<'de>,

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

Hint that the

`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, D::Error>where
V: Visitor<'de>,

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

Hint that the

`Deserialize`

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

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

Hint that the

`Deserialize`

type is expecting a unit value.source§#### fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, D::Error>where
V: Visitor<'de>,

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

Hint that the

`Deserialize`

type is expecting a sequence of values.source§#### fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, D::Error>where
V: Visitor<'de>,

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

Hint that the

`Deserialize`

type is expecting a map of key-value pairs.source§#### fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, D::Error>where
V: Visitor<'de>,

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

Hint that the

`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, D::Error>where
V: Visitor<'de>,

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

Hint that the

`Deserialize`

type needs to deserialize a value whose type
doesn’t matter because it is ignored. Read moresource§#### fn deserialize_unit_struct<V>(
self,
name: &'static str,
visitor: V
) -> Result<V::Value, D::Error>where
V: Visitor<'de>,

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

Hint that the

`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, D::Error>where
V: Visitor<'de>,

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

Hint that the

`Deserialize`

type is expecting a newtype struct with a
particular name.source§#### fn deserialize_tuple<V>(
self,
len: usize,
visitor: V
) -> Result<V::Value, D::Error>where
V: Visitor<'de>,

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

Hint that the

`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, D::Error>where
V: Visitor<'de>,

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

Hint that the

`Deserialize`

type is expecting a tuple struct with a
particular name and number of fields.source§#### fn deserialize_struct<V>(
self,
name: &'static str,
fields: &'static [&'static str],
visitor: V
) -> Result<V::Value, D::Error>where
V: Visitor<'de>,

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

Hint that the

`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, D::Error>where
V: Visitor<'de>,

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

Hint that the

`Deserialize`

type is expecting an enum value with a
particular name and possible variants.source§#### fn is_human_readable(&self) -> bool

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

Determine whether

`Deserialize`

implementations should expect to
deserialize their human-readable form. Read moresource§### impl<'de, D> EnumAccess<'de> for Compact<D>where
D: EnumAccess<'de>,

### impl<'de, D> EnumAccess<'de> for Compact<D>where D: EnumAccess<'de>,

§#### type Error = <D as EnumAccess<'de>>::Error

#### type Error = <D as EnumAccess<'de>>::Error

The error type that can be returned if some error occurs during
deserialization.

§#### type Variant = Compact<<D as EnumAccess<'de>>::Variant>

#### type Variant = Compact<<D as EnumAccess<'de>>::Variant>

The

`Visitor`

that will be used to deserialize the content of the enum
variant.source§#### fn variant_seed<V>(
self,
seed: V
) -> Result<(V::Value, Self::Variant), Self::Error>where
V: DeserializeSeed<'de>,

#### fn variant_seed<V>( self, seed: V ) -> Result<(V::Value, Self::Variant), Self::Error>where V: DeserializeSeed<'de>,

`variant`

is called to identify which variant to deserialize. Read moresource§### impl<'de, D> MapAccess<'de> for Compact<D>where
D: MapAccess<'de>,

### impl<'de, D> MapAccess<'de> for Compact<D>where D: MapAccess<'de>,

§#### type Error = <D as MapAccess<'de>>::Error

#### type Error = <D as MapAccess<'de>>::Error

The error type that can be returned if some error occurs during
deserialization.

source§#### fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, D::Error>where
K: DeserializeSeed<'de>,

#### fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, D::Error>where K: DeserializeSeed<'de>,

This returns

`Ok(Some(key))`

for the next key in the map, or `Ok(None)`

if there are no more remaining entries. Read moresource§#### fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, D::Error>where
V: DeserializeSeed<'de>,

#### fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, D::Error>where V: DeserializeSeed<'de>,

This returns a

`Ok(value)`

for the next value in the map. Read moresource§#### fn next_entry_seed<K, V>(
&mut self,
kseed: K,
vseed: V
) -> Result<Option<(K::Value, V::Value)>, D::Error>where
K: DeserializeSeed<'de>,
V: DeserializeSeed<'de>,

#### fn next_entry_seed<K, V>( &mut self, kseed: K, vseed: V ) -> Result<Option<(K::Value, V::Value)>, D::Error>where K: DeserializeSeed<'de>, V: DeserializeSeed<'de>,

This returns

`Ok(Some((key, value)))`

for the next (key-value) pair in
the map, or `Ok(None)`

if there are no more remaining items. Read moresource§#### fn size_hint(&self) -> Option<usize>

#### fn size_hint(&self) -> Option<usize>

Returns the number of entries remaining in the map, if known.

source§#### fn next_key<K>(&mut self) -> Result<Option<K>, Self::Error>where
K: Deserialize<'de>,

#### fn next_key<K>(&mut self) -> Result<Option<K>, Self::Error>where K: Deserialize<'de>,

This returns

`Ok(Some(key))`

for the next key in the map, or `Ok(None)`

if there are no more remaining entries. Read moresource§#### fn next_value<V>(&mut self) -> Result<V, Self::Error>where
V: Deserialize<'de>,

#### fn next_value<V>(&mut self) -> Result<V, Self::Error>where V: Deserialize<'de>,

This returns a

`Ok(value)`

for the next value in the map. Read moresource§#### fn next_entry<K, V>(&mut self) -> Result<Option<(K, V)>, Self::Error>where
K: Deserialize<'de>,
V: Deserialize<'de>,

#### fn next_entry<K, V>(&mut self) -> Result<Option<(K, V)>, Self::Error>where K: Deserialize<'de>, V: Deserialize<'de>,

This returns

`Ok(Some((key, value)))`

for the next (key-value) pair in
the map, or `Ok(None)`

if there are no more remaining items. Read moresource§### impl<T: PartialEq + ?Sized> PartialEq<Compact<T>> for Compact<T>

### impl<T: PartialEq + ?Sized> PartialEq<Compact<T>> for Compact<T>

source§### impl<T: PartialOrd + ?Sized> PartialOrd<Compact<T>> for Compact<T>

### impl<T: PartialOrd + ?Sized> PartialOrd<Compact<T>> for Compact<T>

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

#### fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl<'de, D> SeqAccess<'de> for Compact<D>where
D: SeqAccess<'de>,

### impl<'de, D> SeqAccess<'de> for Compact<D>where D: SeqAccess<'de>,

§#### type Error = <D as SeqAccess<'de>>::Error

#### type Error = <D as SeqAccess<'de>>::Error

The error type that can be returned if some error occurs during
deserialization.

source§#### fn next_element_seed<T>(
&mut self,
seed: T
) -> Result<Option<T::Value>, D::Error>where
T: DeserializeSeed<'de>,

#### fn next_element_seed<T>( &mut self, seed: T ) -> Result<Option<T::Value>, D::Error>where T: DeserializeSeed<'de>,

This returns

`Ok(Some(value))`

for the next value in the sequence, or
`Ok(None)`

if there are no more remaining items. Read moresource§#### fn size_hint(&self) -> Option<usize>

#### fn size_hint(&self) -> Option<usize>

Returns the number of elements remaining in the sequence, if known.

source§#### fn next_element<T>(&mut self) -> Result<Option<T>, Self::Error>where
T: Deserialize<'de>,

#### fn next_element<T>(&mut self) -> Result<Option<T>, Self::Error>where T: Deserialize<'de>,

This returns

`Ok(Some(value))`

for the next value in the sequence, or
`Ok(None)`

if there are no more remaining items. Read moresource§### impl<S> SerializeMap for Compact<S>where
S: SerializeMap,

### impl<S> SerializeMap for Compact<S>where S: SerializeMap,

§#### type Ok = <S as SerializeMap>::Ok

#### type Ok = <S as SerializeMap>::Ok

Must match the

`Ok`

type of our `Serializer`

.§#### type Error = <S as SerializeMap>::Error

#### type Error = <S as SerializeMap>::Error

Must match the

`Error`

type of our `Serializer`

.source§#### fn serialize_key<T>(&mut self, key: &T) -> Result<(), S::Error>where
T: Serialize + ?Sized,

#### fn serialize_key<T>(&mut self, key: &T) -> Result<(), S::Error>where T: Serialize + ?Sized,

Serialize a map key. Read more

source§#### fn serialize_value<T>(&mut self, value: &T) -> Result<(), S::Error>where
T: Serialize + ?Sized,

#### fn serialize_value<T>(&mut self, value: &T) -> Result<(), S::Error>where T: Serialize + ?Sized,

Serialize a map value. Read more

source§### impl<S> SerializeSeq for Compact<S>where
S: SerializeSeq,

### impl<S> SerializeSeq for Compact<S>where S: SerializeSeq,

source§### impl<S> SerializeStruct for Compact<S>where
S: SerializeStruct,

### impl<S> SerializeStruct for Compact<S>where S: SerializeStruct,

§#### type Ok = <S as SerializeStruct>::Ok

#### type Ok = <S as SerializeStruct>::Ok

Must match the

`Ok`

type of our `Serializer`

.§#### type Error = <S as SerializeStruct>::Error

#### type Error = <S as SerializeStruct>::Error

Must match the

`Error`

type of our `Serializer`

.source§### impl<S> SerializeStructVariant for Compact<S>where
S: SerializeStructVariant,

### impl<S> SerializeStructVariant for Compact<S>where S: SerializeStructVariant,

§#### type Ok = <S as SerializeStructVariant>::Ok

#### type Ok = <S as SerializeStructVariant>::Ok

Must match the

`Ok`

type of our `Serializer`

.§#### type Error = <S as SerializeStructVariant>::Error

#### type Error = <S as SerializeStructVariant>::Error

Must match the

`Error`

type of our `Serializer`

.source§### impl<S> SerializeTuple for Compact<S>where
S: SerializeTuple,

### impl<S> SerializeTuple for Compact<S>where S: SerializeTuple,

source§### impl<S> SerializeTupleStruct for Compact<S>where
S: SerializeTupleStruct,

### impl<S> SerializeTupleStruct for Compact<S>where S: SerializeTupleStruct,

§#### type Ok = <S as SerializeTupleStruct>::Ok

#### type Ok = <S as SerializeTupleStruct>::Ok

Must match the

`Ok`

type of our `Serializer`

.§#### type Error = <S as SerializeTupleStruct>::Error

#### type Error = <S as SerializeTupleStruct>::Error

Must match the

`Error`

type of our `Serializer`

.source§### impl<S> SerializeTupleVariant for Compact<S>where
S: SerializeTupleVariant,

### impl<S> SerializeTupleVariant for Compact<S>where S: SerializeTupleVariant,

§#### type Ok = <S as SerializeTupleVariant>::Ok

#### type Ok = <S as SerializeTupleVariant>::Ok

Must match the

`Ok`

type of our `Serializer`

.§#### type Error = <S as SerializeTupleVariant>::Error

#### type Error = <S as SerializeTupleVariant>::Error

Must match the

`Error`

type of our `Serializer`

.source§### impl<S> Serializer for Compact<S>where
S: Serializer,

### impl<S> Serializer for Compact<S>where S: Serializer,

§#### type Ok = <S as Serializer>::Ok

#### type Ok = <S as Serializer>::Ok

The output type produced by this

`Serializer`

during successful
serialization. Most serializers that produce text or binary output
should set `Ok = ()`

and serialize into an `io::Write`

or buffer
contained within the `Serializer`

instance. Serializers that build
in-memory data structures may be simplified by using `Ok`

to propagate
the data structure around.§#### type Error = <S as Serializer>::Error

#### type Error = <S as Serializer>::Error

The error type when some error occurs during serialization.

§#### type SerializeSeq = Compact<<S as Serializer>::SerializeSeq>

#### type SerializeSeq = Compact<<S as Serializer>::SerializeSeq>

Type returned from

`serialize_seq`

for serializing the content of the
sequence.§#### type SerializeTuple = Compact<<S as Serializer>::SerializeTuple>

#### type SerializeTuple = Compact<<S as Serializer>::SerializeTuple>

Type returned from

`serialize_tuple`

for serializing the content of
the tuple.§#### type SerializeTupleStruct = Compact<<S as Serializer>::SerializeTupleStruct>

#### type SerializeTupleStruct = Compact<<S as Serializer>::SerializeTupleStruct>

Type returned from

`serialize_tuple_struct`

for serializing the
content of the tuple struct.§#### type SerializeTupleVariant = Compact<<S as Serializer>::SerializeTupleVariant>

#### type SerializeTupleVariant = Compact<<S as Serializer>::SerializeTupleVariant>

Type returned from

`serialize_tuple_variant`

for serializing the
content of the tuple variant.§#### type SerializeMap = Compact<<S as Serializer>::SerializeMap>

#### type SerializeMap = Compact<<S as Serializer>::SerializeMap>

Type returned from

`serialize_map`

for serializing the content of the
map.§#### type SerializeStruct = Compact<<S as Serializer>::SerializeStruct>

#### type SerializeStruct = Compact<<S as Serializer>::SerializeStruct>

Type returned from

`serialize_struct`

for serializing the content of
the struct.§#### type SerializeStructVariant = Compact<<S as Serializer>::SerializeStructVariant>

#### type SerializeStructVariant = Compact<<S as Serializer>::SerializeStructVariant>

Type returned from

`serialize_struct_variant`

for serializing the
content of the struct variant.source§#### fn is_human_readable(&self) -> bool

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

Determine whether

`Serialize`

implementations should serialize in
human-readable form. Read moresource§#### fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error>

#### fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error>

Serialize a

`bool`

value. Read moresource§#### fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error>

#### fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error>

Serialize an

`i8`

value. Read moresource§#### fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error>

#### fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error>

Serialize an

`i16`

value. Read moresource§#### fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error>

#### fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error>

Serialize an

`i32`

value. Read moresource§#### fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error>

#### fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error>

Serialize an

`i64`

value. Read moresource§#### fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error>

#### fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error>

Serialize a

`u16`

value. Read moresource§#### fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error>

#### fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error>

Serialize a

`u32`

value. Read moresource§#### fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error>

#### fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error>

Serialize a

`u64`

value. Read moresource§#### fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error>

#### fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error>

Serialize an

`f32`

value. Read moresource§#### fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error>

#### fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error>

Serialize an

`f64`

value. Read moresource§#### fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error>

#### fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error>

Serialize a character. Read more

source§#### fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error>

#### fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error>

Serialize a chunk of raw byte data. Read more

source§#### fn serialize_unit_variant(
self,
name: &'static str,
variant_index: u32,
variant: &'static str
) -> Result<S::Ok, S::Error>

#### fn serialize_unit_variant( self, name: &'static str, variant_index: u32, variant: &'static str ) -> Result<S::Ok, S::Error>

source§#### fn serialize_newtype_struct<T>(
self,
name: &'static str,
value: &T
) -> Result<S::Ok, S::Error>where
T: Serialize + ?Sized,

#### fn serialize_newtype_struct<T>( self, name: &'static str, value: &T ) -> Result<S::Ok, S::Error>where T: Serialize + ?Sized,

Serialize a newtype struct like

`struct Millimeters(u8)`

. Read moresource§#### fn serialize_newtype_variant<T>(
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
value: &T
) -> Result<S::Ok, S::Error>where
T: Serialize + ?Sized,

#### fn serialize_newtype_variant<T>( self, name: &'static str, variant_index: u32, variant: &'static str, value: &T ) -> Result<S::Ok, S::Error>where T: Serialize + ?Sized,

source§#### fn serialize_some<T>(self, value: &T) -> Result<S::Ok, Self::Error>where
T: Serialize + ?Sized,

#### fn serialize_some<T>(self, value: &T) -> Result<S::Ok, Self::Error>where T: Serialize + ?Sized,

source§#### fn serialize_seq(
self,
len: Option<usize>
) -> Result<Self::SerializeSeq, Self::Error>

#### fn serialize_seq( self, len: Option<usize> ) -> Result<Self::SerializeSeq, Self::Error>

Begin to serialize a variably sized sequence. This call must be
followed by zero or more calls to

`serialize_element`

, then a call to
`end`

. Read moresource§#### fn serialize_tuple(
self,
len: usize
) -> Result<Self::SerializeTuple, Self::Error>

#### fn serialize_tuple( self, len: usize ) -> Result<Self::SerializeTuple, Self::Error>

Begin to serialize a statically sized sequence whose length will be
known at deserialization time without looking at the serialized data.
This call must be followed by zero or more calls to

`serialize_element`

,
then a call to `end`

. Read moresource§#### fn serialize_tuple_struct(
self,
name: &'static str,
len: usize
) -> Result<Self::SerializeTupleStruct, Self::Error>

#### fn serialize_tuple_struct( self, name: &'static str, len: usize ) -> Result<Self::SerializeTupleStruct, Self::Error>

Begin to serialize a tuple struct like

`struct Rgb(u8, u8, u8)`

. This
call must be followed by zero or more calls to `serialize_field`

, then a
call to `end`

. Read moresource§#### fn serialize_tuple_variant(
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize
) -> Result<Self::SerializeTupleVariant, Self::Error>

#### fn serialize_tuple_variant( self, name: &'static str, variant_index: u32, variant: &'static str, len: usize ) -> Result<Self::SerializeTupleVariant, Self::Error>

Begin to serialize a tuple variant like

`E::T`

in `enum E { T(u8, u8) }`

. This call must be followed by zero or more calls to
`serialize_field`

, then a call to `end`

. Read moresource§#### fn serialize_map(
self,
len: Option<usize>
) -> Result<Self::SerializeMap, Self::Error>

#### fn serialize_map( self, len: Option<usize> ) -> Result<Self::SerializeMap, Self::Error>

Begin to serialize a map. This call must be followed by zero or more
calls to

`serialize_key`

and `serialize_value`

, then a call to `end`

. Read moresource§#### fn serialize_struct(
self,
name: &'static str,
len: usize
) -> Result<Self::SerializeStruct, Self::Error>

#### fn serialize_struct( self, name: &'static str, len: usize ) -> Result<Self::SerializeStruct, Self::Error>

Begin to serialize a struct like

`struct Rgb { r: u8, g: u8, b: u8 }`

.
This call must be followed by zero or more calls to `serialize_field`

,
then a call to `end`

. Read moresource§#### fn serialize_struct_variant(
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize
) -> Result<Self::SerializeStructVariant, Self::Error>

#### fn serialize_struct_variant( self, name: &'static str, variant_index: u32, variant: &'static str, len: usize ) -> Result<Self::SerializeStructVariant, Self::Error>

Begin to serialize a struct variant like

`E::S`

in `enum E { S { r: u8, g: u8, b: u8 } }`

. This call must be followed by zero or more calls to
`serialize_field`

, then a call to `end`

. Read moresource§#### fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error>

#### fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error>

Serialize an

`i128`

value. Read moresource§#### fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error>

#### fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error>

Serialize a

`u128`

value. Read moresource§#### fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error>where
I: IntoIterator,
<I as IntoIterator>::Item: Serialize,

#### fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error>where I: IntoIterator, <I as IntoIterator>::Item: Serialize,

Collect an iterator as a sequence. Read more

source§### impl<'de, D> VariantAccess<'de> for Compact<D>where
D: VariantAccess<'de>,

### impl<'de, D> VariantAccess<'de> for Compact<D>where D: VariantAccess<'de>,

§#### type Error = <D as VariantAccess<'de>>::Error

#### type Error = <D as VariantAccess<'de>>::Error

The error type that can be returned if some error occurs during
deserialization. Must match the error type of our

`EnumAccess`

.source§#### fn unit_variant(self) -> Result<(), D::Error>

#### fn unit_variant(self) -> Result<(), D::Error>

Called when deserializing a variant with no values. Read more

source§#### fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, D::Error>where
T: DeserializeSeed<'de>,

#### fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, D::Error>where T: DeserializeSeed<'de>,

Called when deserializing a variant with a single value. Read more

source§#### fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, D::Error>where
V: Visitor<'de>,

#### fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, D::Error>where V: Visitor<'de>,

Called when deserializing a tuple-like variant. Read more

source§#### fn struct_variant<V>(
self,
fields: &'static [&'static str],
visitor: V
) -> Result<V::Value, D::Error>where
V: Visitor<'de>,

#### fn struct_variant<V>( self, fields: &'static [&'static str], visitor: V ) -> Result<V::Value, D::Error>where V: Visitor<'de>,

Called when deserializing a struct-like variant. Read more

source§#### fn newtype_variant<T>(self) -> Result<T, Self::Error>where
T: Deserialize<'de>,

#### fn newtype_variant<T>(self) -> Result<T, Self::Error>where T: Deserialize<'de>,

Called when deserializing a variant with a single value. Read more

source§### impl<'de, D> Visitor<'de> for Compact<D>where
D: Visitor<'de>,

### impl<'de, D> Visitor<'de> for Compact<D>where D: Visitor<'de>,

source§#### fn expecting(&self, formatter: &mut Formatter<'_>) -> Result

#### fn expecting(&self, formatter: &mut Formatter<'_>) -> Result

Format a message stating what data this Visitor expects to receive. Read more

source§#### fn visit_bool<E>(self, v: bool) -> Result<D::Value, E>where
E: Error,

#### fn visit_bool<E>(self, v: bool) -> Result<D::Value, E>where E: Error,

The input contains a boolean. Read more

source§#### fn visit_i8<E>(self, v: i8) -> Result<D::Value, E>where
E: Error,

#### fn visit_i8<E>(self, v: i8) -> Result<D::Value, E>where E: Error,

The input contains an

`i8`

. Read moresource§#### fn visit_i16<E>(self, v: i16) -> Result<D::Value, E>where
E: Error,

#### fn visit_i16<E>(self, v: i16) -> Result<D::Value, E>where E: Error,

The input contains an

`i16`

. Read moresource§#### fn visit_i32<E>(self, v: i32) -> Result<D::Value, E>where
E: Error,

#### fn visit_i32<E>(self, v: i32) -> Result<D::Value, E>where E: Error,

The input contains an

`i32`

. Read moresource§#### fn visit_i64<E>(self, v: i64) -> Result<D::Value, E>where
E: Error,

#### fn visit_i64<E>(self, v: i64) -> Result<D::Value, E>where E: Error,

The input contains an

`i64`

. Read moresource§#### fn visit_u8<E>(self, v: u8) -> Result<D::Value, E>where
E: Error,

#### fn visit_u8<E>(self, v: u8) -> Result<D::Value, E>where E: Error,

The input contains a

`u8`

. Read moresource§#### fn visit_u16<E>(self, v: u16) -> Result<D::Value, E>where
E: Error,

#### fn visit_u16<E>(self, v: u16) -> Result<D::Value, E>where E: Error,

The input contains a

`u16`

. Read moresource§#### fn visit_u32<E>(self, v: u32) -> Result<D::Value, E>where
E: Error,

#### fn visit_u32<E>(self, v: u32) -> Result<D::Value, E>where E: Error,

The input contains a

`u32`

. Read moresource§#### fn visit_u64<E>(self, v: u64) -> Result<D::Value, E>where
E: Error,

#### fn visit_u64<E>(self, v: u64) -> Result<D::Value, E>where E: Error,

The input contains a

`u64`

. Read moresource§#### fn visit_f32<E>(self, v: f32) -> Result<D::Value, E>where
E: Error,

#### fn visit_f32<E>(self, v: f32) -> Result<D::Value, E>where E: Error,

The input contains an

`f32`

. Read moresource§#### fn visit_f64<E>(self, v: f64) -> Result<D::Value, E>where
E: Error,

#### fn visit_f64<E>(self, v: f64) -> Result<D::Value, E>where E: Error,

The input contains an

`f64`

. Read moresource§#### fn visit_char<E>(self, v: char) -> Result<D::Value, E>where
E: Error,

#### fn visit_char<E>(self, v: char) -> Result<D::Value, E>where E: Error,

The input contains a

`char`

. Read moresource§#### fn visit_str<E>(self, v: &str) -> Result<D::Value, E>where
E: Error,

#### fn visit_str<E>(self, v: &str) -> Result<D::Value, E>where E: Error,

The input contains a string. The lifetime of the string is ephemeral and
it may be destroyed after this method returns. Read more

source§#### fn visit_borrowed_str<E>(self, v: &'de str) -> Result<D::Value, E>where
E: Error,

#### fn visit_borrowed_str<E>(self, v: &'de str) -> Result<D::Value, E>where E: Error,

The input contains a string that lives at least as long as the

`Deserializer`

. Read moresource§#### fn visit_string<E>(self, v: String) -> Result<D::Value, E>where
E: Error,

#### fn visit_string<E>(self, v: String) -> Result<D::Value, E>where E: Error,

The input contains a string and ownership of the string is being given
to the

`Visitor`

. Read moresource§#### fn visit_bytes<E>(self, v: &[u8]) -> Result<D::Value, E>where
E: Error,

#### fn visit_bytes<E>(self, v: &[u8]) -> Result<D::Value, E>where E: Error,

The input contains a byte array. The lifetime of the byte array is
ephemeral and it may be destroyed after this method returns. Read more

source§#### fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<D::Value, E>where
E: Error,

#### fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<D::Value, E>where E: Error,

The input contains a byte array that lives at least as long as the

`Deserializer`

. Read moresource§#### fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<D::Value, E>where
E: Error,

#### fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<D::Value, E>where E: Error,

The input contains a byte array and ownership of the byte array is being
given to the

`Visitor`

. Read moresource§#### fn visit_none<E>(self) -> Result<D::Value, E>where
E: Error,

#### fn visit_none<E>(self) -> Result<D::Value, E>where E: Error,

The input contains an optional that is absent. Read more

source§#### fn visit_some<D2>(self, deserializer: D2) -> Result<Self::Value, D2::Error>where
D2: Deserializer<'de>,

#### fn visit_some<D2>(self, deserializer: D2) -> Result<Self::Value, D2::Error>where D2: Deserializer<'de>,

The input contains an optional that is present. Read more

source§#### fn visit_unit<E>(self) -> Result<D::Value, E>where
E: Error,

#### fn visit_unit<E>(self) -> Result<D::Value, E>where E: Error,

The input contains a unit

`()`

. Read moresource§#### fn visit_newtype_struct<D2>(
self,
deserializer: D2
) -> Result<Self::Value, D2::Error>where
D2: Deserializer<'de>,

#### fn visit_newtype_struct<D2>( self, deserializer: D2 ) -> Result<Self::Value, D2::Error>where D2: Deserializer<'de>,

The input contains a newtype struct. Read more

source§#### fn visit_seq<V>(self, seq: V) -> Result<D::Value, V::Error>where
V: SeqAccess<'de>,

#### fn visit_seq<V>(self, seq: V) -> Result<D::Value, V::Error>where V: SeqAccess<'de>,

The input contains a sequence of elements. Read more

source§#### fn visit_map<V>(self, map: V) -> Result<D::Value, V::Error>where
V: MapAccess<'de>,

#### fn visit_map<V>(self, map: V) -> Result<D::Value, V::Error>where V: MapAccess<'de>,

The input contains a key-value map. Read more

source§#### fn visit_enum<V>(self, data: V) -> Result<D::Value, V::Error>where
V: EnumAccess<'de>,

#### fn visit_enum<V>(self, data: V) -> Result<D::Value, V::Error>where V: EnumAccess<'de>,

The input contains an enum. Read more

### impl<T: Eq + ?Sized> Eq for Compact<T>

### impl<T: ?Sized> StructuralEq for Compact<T>

### impl<T: ?Sized> StructuralPartialEq for Compact<T>

## Auto Trait Implementations§

### impl<T: ?Sized> RefUnwindSafe for Compact<T>where T: RefUnwindSafe,

### impl<T: ?Sized> Send for Compact<T>where T: Send,

### impl<T: ?Sized> Sync for Compact<T>where T: Sync,

### impl<T: ?Sized> Unpin for Compact<T>where T: Unpin,

### impl<T: ?Sized> UnwindSafe for Compact<T>where T: UnwindSafe,

## 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

Mutably borrows from an owned value. Read more