```
pub trait Serialize {
// Required method
fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where S: Serializer;
}
```

## Expand description

A **data structure** that can be serialized into any data format supported
by Serde.

Serde provides `Serialize`

implementations for many Rust primitive and
standard library types. The complete list is here. All of
these can be serialized using Serde out of the box.

Additionally, Serde provides a procedural macro called `serde_derive`

to
automatically generate `Serialize`

implementations for structs and enums in
your program. See the derive section of the manual for how to use this.

In rare cases it may be necessary to implement `Serialize`

manually for some
type in your program. See the Implementing `Serialize`

section of the
manual for more about this.

Third-party crates may provide `Serialize`

implementations for types that
they expose. For example the `linked-hash-map`

crate provides a
`LinkedHashMap<K, V>`

type that is serializable by Serde because the crate
provides an implementation of `Serialize`

for it.

## Required Methods§

source#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

Serialize this value into the given Serde serializer.

See the Implementing `Serialize`

section of the manual for more
information about how to implement this method.

```
use serde::ser::{Serialize, SerializeStruct, Serializer};
struct Person {
name: String,
age: u8,
phones: Vec<String>,
}
// This is what #[derive(Serialize)] would generate.
impl Serialize for Person {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let mut s = serializer.serialize_struct("Person", 3)?;
s.serialize_field("name", &self.name)?;
s.serialize_field("age", &self.age)?;
s.serialize_field("phones", &self.phones)?;
s.end()
}
}
```

## Object Safety§

**not**object safe.

## Implementations on Foreign Types§

source§### impl Serialize for IpAddr

### impl Serialize for IpAddr

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for SocketAddr

### impl Serialize for SocketAddr

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for Empty

### impl Serialize for Empty

#### fn serialize<S>(
&self,
ser: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for Num

### impl Serialize for Num

#### fn serialize<S>(
&self,
ser: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for Value

### impl Serialize for Value

#### fn serialize<S>(
&self,
ser: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for Value

### impl Serialize for Value

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for bool

### impl Serialize for bool

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for char

### impl Serialize for char

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for f32

### impl Serialize for f32

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for f64

### impl Serialize for f64

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for i8

### impl Serialize for i8

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for i16

### impl Serialize for i16

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for i32

### impl Serialize for i32

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for i64

### impl Serialize for i64

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for i128

### impl Serialize for i128

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for isize

### impl Serialize for isize

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for str

### impl Serialize for str

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for u8

### impl Serialize for u8

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for u16

### impl Serialize for u16

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for u32

### impl Serialize for u32

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for u64

### impl Serialize for u64

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for u128

### impl Serialize for u128

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for ()

### impl Serialize for ()

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for usize

### impl Serialize for usize

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for CString

### impl Serialize for CString

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for CStr

### impl Serialize for CStr

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for Ipv4Addr

### impl Serialize for Ipv4Addr

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for Ipv6Addr

### impl Serialize for Ipv6Addr

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for SocketAddrV4

### impl Serialize for SocketAddrV4

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for SocketAddrV6

### impl Serialize for SocketAddrV6

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for NonZero<i8>

### impl Serialize for NonZero<i8>

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for NonZero<i16>

### impl Serialize for NonZero<i16>

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for NonZero<i32>

### impl Serialize for NonZero<i32>

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for NonZero<i64>

### impl Serialize for NonZero<i64>

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for NonZero<i128>

### impl Serialize for NonZero<i128>

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for NonZero<isize>

### impl Serialize for NonZero<isize>

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for NonZero<u8>

### impl Serialize for NonZero<u8>

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for NonZero<u16>

### impl Serialize for NonZero<u16>

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for NonZero<u32>

### impl Serialize for NonZero<u32>

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for NonZero<u64>

### impl Serialize for NonZero<u64>

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for NonZero<u128>

### impl Serialize for NonZero<u128>

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for NonZero<usize>

### impl Serialize for NonZero<usize>

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for AtomicBool

### impl Serialize for AtomicBool

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for AtomicI8

### impl Serialize for AtomicI8

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for AtomicI16

### impl Serialize for AtomicI16

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for AtomicI32

### impl Serialize for AtomicI32

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for AtomicI64

### impl Serialize for AtomicI64

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for AtomicIsize

### impl Serialize for AtomicIsize

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for AtomicU8

### impl Serialize for AtomicU8

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for AtomicU16

### impl Serialize for AtomicU16

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for AtomicU32

### impl Serialize for AtomicU32

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for AtomicU64

### impl Serialize for AtomicU64

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for AtomicUsize

### impl Serialize for AtomicUsize

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for Duration

### impl Serialize for Duration

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for OsStr

### impl Serialize for OsStr

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for OsString

### impl Serialize for OsString

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for Path

### impl Serialize for Path

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for PathBuf

### impl Serialize for PathBuf

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for SystemTime

### impl Serialize for SystemTime

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for Profile

### impl Serialize for Profile

#### fn serialize<S>(
&self,
s: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for RelativePathBuf

### impl Serialize for RelativePathBuf

#### fn serialize<__S>(
&self,
__serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
__S: Serializer,

source§### impl Serialize for Tag

### impl Serialize for Tag

#### fn serialize<S>(
&self,
ser: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for Map<String, Value>

### impl Serialize for Map<String, Value>

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for Number

### impl Serialize for Number

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for RawValue

### impl Serialize for RawValue

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for Map<String, Value>

### impl Serialize for Map<String, Value>

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for Datetime

### impl Serialize for Datetime

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl Serialize for InternalString

### impl Serialize for InternalString

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<'a, T> Serialize for Cow<'a, T>

### impl<'a, T> Serialize for Cow<'a, T>

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<'a, T> Serialize for &'a T

### impl<'a, T> Serialize for &'a T

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<'a, T> Serialize for &'a mut T

### impl<'a, T> Serialize for &'a mut T

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<A, B> Serialize for Either<A, B>

### impl<A, B> Serialize for Either<A, B>

#### fn serialize<__S>(
&self,
__serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
__S: Serializer,

source§### impl<K, V> Serialize for Slice<K, V>

### impl<K, V> Serialize for Slice<K, V>

Serializes a `map::Slice`

as an ordered sequence.

This behaves like `crate::map::serde_seq`

for `IndexMap`

, serializing a sequence
of `(key, value)`

pairs, rather than as a map that might not preserve order.

#### fn serialize<T>(
&self,
serializer: T
) -> Result<<T as Serializer>::Ok, <T as Serializer>::Error>where
T: Serializer,

source§### impl<K, V, S> Serialize for IndexMap<K, V, S>

### impl<K, V, S> Serialize for IndexMap<K, V, S>

#### fn serialize<T>(
&self,
serializer: T
) -> Result<<T as Serializer>::Ok, <T as Serializer>::Error>where
T: Serializer,

source§### impl<L, R> Serialize for Either<L, R>

### impl<L, R> Serialize for Either<L, R>

#### fn serialize<__S>(
&self,
__serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
__S: Serializer,

source§### impl<T0, T1> Serialize for (T0, T1)

### impl<T0, T1> Serialize for (T0, T1)

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T0, T1, T2> Serialize for (T0, T1, T2)

### impl<T0, T1, T2> Serialize for (T0, T1, T2)

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T0, T1, T2, T3> Serialize for (T0, T1, T2, T3)

### impl<T0, T1, T2, T3> Serialize for (T0, T1, T2, T3)

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T0, T1, T2, T3, T4> Serialize for (T0, T1, T2, T3, T4)

### impl<T0, T1, T2, T3, T4> Serialize for (T0, T1, T2, T3, T4)

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T0, T1, T2, T3, T4, T5> Serialize for (T0, T1, T2, T3, T4, T5)

### impl<T0, T1, T2, T3, T4, T5> Serialize for (T0, T1, T2, T3, T4, T5)

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T0, T1, T2, T3, T4, T5, T6> Serialize for (T0, T1, T2, T3, T4, T5, T6)

### impl<T0, T1, T2, T3, T4, T5, T6> Serialize for (T0, T1, T2, T3, T4, T5, T6)

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T0, T1, T2, T3, T4, T5, T6, T7> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7)

### impl<T0, T1, T2, T3, T4, T5, T6, T7> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7)

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

### impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

### impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

### impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

### impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)

### impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)

### impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)

### impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

### impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for [T; 0]

### impl<T> Serialize for [T; 0]

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for [T; 1]where
T: Serialize,

### impl<T> Serialize for [T; 1]where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for [T; 2]where
T: Serialize,

### impl<T> Serialize for [T; 2]where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for [T; 3]where
T: Serialize,

### impl<T> Serialize for [T; 3]where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for [T; 4]where
T: Serialize,

### impl<T> Serialize for [T; 4]where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for [T; 5]where
T: Serialize,

### impl<T> Serialize for [T; 5]where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for [T; 6]where
T: Serialize,

### impl<T> Serialize for [T; 6]where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for [T; 7]where
T: Serialize,

### impl<T> Serialize for [T; 7]where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for [T; 8]where
T: Serialize,

### impl<T> Serialize for [T; 8]where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for [T; 9]where
T: Serialize,

### impl<T> Serialize for [T; 9]where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for [T; 10]where
T: Serialize,

### impl<T> Serialize for [T; 10]where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for [T; 11]where
T: Serialize,

### impl<T> Serialize for [T; 11]where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for [T; 12]where
T: Serialize,

### impl<T> Serialize for [T; 12]where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for [T; 13]where
T: Serialize,

### impl<T> Serialize for [T; 13]where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for [T; 14]where
T: Serialize,

### impl<T> Serialize for [T; 14]where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for [T; 15]where
T: Serialize,

### impl<T> Serialize for [T; 15]where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for [T; 16]where
T: Serialize,

### impl<T> Serialize for [T; 16]where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for [T; 17]where
T: Serialize,

### impl<T> Serialize for [T; 17]where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for [T; 18]where
T: Serialize,

### impl<T> Serialize for [T; 18]where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for [T; 19]where
T: Serialize,

### impl<T> Serialize for [T; 19]where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for [T; 20]where
T: Serialize,

### impl<T> Serialize for [T; 20]where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for [T; 21]where
T: Serialize,

### impl<T> Serialize for [T; 21]where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for [T; 22]where
T: Serialize,

### impl<T> Serialize for [T; 22]where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for [T; 23]where
T: Serialize,

### impl<T> Serialize for [T; 23]where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for [T; 24]where
T: Serialize,

### impl<T> Serialize for [T; 24]where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for [T; 25]where
T: Serialize,

### impl<T> Serialize for [T; 25]where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for [T; 26]where
T: Serialize,

### impl<T> Serialize for [T; 26]where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for [T; 27]where
T: Serialize,

### impl<T> Serialize for [T; 27]where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for [T; 28]where
T: Serialize,

### impl<T> Serialize for [T; 28]where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for [T; 29]where
T: Serialize,

### impl<T> Serialize for [T; 29]where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for [T; 30]where
T: Serialize,

### impl<T> Serialize for [T; 30]where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for [T; 31]where
T: Serialize,

### impl<T> Serialize for [T; 31]where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for [T; 32]where
T: Serialize,

### impl<T> Serialize for [T; 32]where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for [T]where
T: Serialize,

### impl<T> Serialize for [T]where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for (T,)where
T: Serialize,

### impl<T> Serialize for (T,)where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for Rc<T>

### impl<T> Serialize for Rc<T>

This impl requires the `"rc"`

Cargo feature of Serde.

Serializing a data structure containing `Rc`

will serialize a copy of
the contents of the `Rc`

each time the `Rc`

is referenced within the
data structure. Serialization will not attempt to deduplicate these
repeated data.

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for Weak<T>

### impl<T> Serialize for Weak<T>

This impl requires the `"rc"`

Cargo feature of Serde.

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for Arc<T>

### impl<T> Serialize for Arc<T>

This impl requires the `"rc"`

Cargo feature of Serde.

Serializing a data structure containing `Arc`

will serialize a copy of
the contents of the `Arc`

each time the `Arc`

is referenced within the
data structure. Serialization will not attempt to deduplicate these
repeated data.

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for Weak<T>

### impl<T> Serialize for Weak<T>

This impl requires the `"rc"`

Cargo feature of Serde.

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for Cell<T>

### impl<T> Serialize for Cell<T>

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for RefCell<T>

### impl<T> Serialize for RefCell<T>

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for PhantomData<T>where
T: ?Sized,

### impl<T> Serialize for PhantomData<T>where
T: ?Sized,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for Saturating<T>where
T: Serialize,

### impl<T> Serialize for Saturating<T>where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for Wrapping<T>where
T: Serialize,

### impl<T> Serialize for Wrapping<T>where
T: Serialize,

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for Mutex<T>

### impl<T> Serialize for Mutex<T>

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for RwLock<T>

### impl<T> Serialize for RwLock<T>

#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

source§### impl<T> Serialize for Tagged<T>where
T: Serialize,

### impl<T> Serialize for Tagged<T>where
T: Serialize,

#### fn serialize<__S>(
&self,
__serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
__S: Serializer,

source§### impl<T> Serialize for Slice<T>where
T: Serialize,

### impl<T> Serialize for Slice<T>where
T: Serialize,

Serializes a `set::Slice`

as an ordered sequence.