# Trait serde::Serialize

source · [−]

    pub trait Serialize {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::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::Ok, S::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()
        }
    }

## Implementations on Foreign Types

source

### impl Serialize for bool

source

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

source

### impl Serialize for isize

source

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

source

### impl Serialize for i8

source

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

source

### impl Serialize for i16

source

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

source

### impl Serialize for i32

source

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

source

### impl Serialize for i64

source

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

source

### impl Serialize for usize

source

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

source

### impl Serialize for u8

source

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

source

### impl Serialize for u16

source

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

source

### impl Serialize for u32

source

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

source

### impl Serialize for u64

source

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

source

### impl Serialize for f32

source

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

source

### impl Serialize for f64

source

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

source

### impl Serialize for char

source

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

source

### impl Serialize for i128

source

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

source

### impl Serialize for u128

source

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

source

### impl Serialize for str

source

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

source

### impl Serialize for String

source

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

source

### impl<'a> Serialize for Arguments<'a>

source

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

source

### impl Serialize for CStr

source

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

source

### impl Serialize for CString

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

### impl<T, H> Serialize for HashSet<T, H> where
T: Serialize,

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

### impl<Idx> Serialize for Range<Idx> where
Idx: Serialize,

source

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

source

### impl<Idx> Serialize for RangeInclusive<Idx> where
Idx: Serialize,

source

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

source

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

source

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

source

### impl Serialize for ()

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

#### fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::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) where
T0: Serialize,
T1: Serialize,
T2: Serialize,
T3: Serialize,
T4: Serialize,
T5: Serialize,
T6: Serialize,
T7: Serialize,
T8: Serialize,

source

#### fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::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) where
T0: Serialize,
T1: Serialize,
T2: Serialize,
T3: Serialize,
T4: Serialize,
T5: Serialize,
T6: Serialize,
T7: Serialize,
T8: Serialize,
T9: Serialize,

source

#### fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::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) where
T0: Serialize,
T1: Serialize,
T2: Serialize,
T3: Serialize,
T4: Serialize,
T5: Serialize,
T6: Serialize,
T7: Serialize,
T8: Serialize,
T9: Serialize,
T10: Serialize,

source

#### fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::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) where
T0: Serialize,
T1: Serialize,
T2: Serialize,
T3: Serialize,
T4: Serialize,
T5: Serialize,
T6: Serialize,
T7: Serialize,
T8: Serialize,
T9: Serialize,
T10: Serialize,
T11: Serialize,

source

#### fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::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) where
T0: Serialize,
T1: Serialize,
T2: Serialize,
T3: Serialize,
T4: Serialize,
T5: Serialize,
T6: Serialize,
T7: Serialize,
T8: Serialize,
T9: Serialize,
T10: Serialize,
T11: Serialize,
T12: Serialize,

source

#### fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::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) where
T0: Serialize,
T1: Serialize,
T2: Serialize,
T3: Serialize,
T4: Serialize,
T5: Serialize,
T6: Serialize,
T7: Serialize,
T8: Serialize,
T9: Serialize,
T10: Serialize,
T11: Serialize,
T12: Serialize,
T13: Serialize,

source

#### fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::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) where
T0: Serialize,
T1: Serialize,
T2: Serialize,
T3: Serialize,
T4: Serialize,
T5: Serialize,
T6: Serialize,
T7: Serialize,
T8: Serialize,
T9: Serialize,
T10: Serialize,
T11: Serialize,
T12: Serialize,
T13: Serialize,
T14: Serialize,

source

#### fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::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) where
T0: Serialize,
T1: Serialize,
T2: Serialize,
T3: Serialize,
T4: Serialize,
T5: Serialize,
T6: Serialize,
T7: Serialize,
T8: Serialize,
T9: Serialize,
T10: Serialize,
T11: Serialize,
T12: Serialize,
T13: Serialize,
T14: Serialize,
T15: Serialize,

source

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

source

### impl<K, V> Serialize for BTreeMap<K, V> where
K: Serialize,
V: Serialize,

source

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

source

### impl<K, V, H> Serialize for HashMap<K, V, H> where
K: Serialize,
V: Serialize,

source

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

source

### impl<'a, T: ?Sized> Serialize for &'a T where
T: Serialize,

source

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

source

### impl<'a, T: ?Sized> Serialize for &'a mut T where
T: Serialize,

source

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

source

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

source

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

source

### impl<'a, T: ?Sized> Serialize for Cow<'a, T> where
T: Serialize + ToOwned,

source

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

source

### impl Serialize for NonZeroU8

source

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

source

### impl Serialize for NonZeroU16

source

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

source

### impl Serialize for NonZeroU32

source

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

source

### impl Serialize for NonZeroU64

source

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

source

### impl Serialize for NonZeroUsize

source

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

source

### impl Serialize for NonZeroI8

source

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

source

### impl Serialize for NonZeroI16

source

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

source

### impl Serialize for NonZeroI32

source

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

source

### impl Serialize for NonZeroI64

source

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

source

### impl Serialize for NonZeroIsize

source

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

source

### impl Serialize for NonZeroU128

source

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

source

### impl Serialize for NonZeroI128

source

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

source

### impl<T> Serialize for Cell<T> where
T: Serialize + Copy,

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

### impl<T, E> Serialize for Result<T, E> where
T: Serialize,
E: Serialize,

source

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

source

### impl Serialize for Duration

source

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

source

### impl Serialize for SystemTime

source

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

source

### impl Serialize for IpAddr

source

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

source

### impl Serialize for Ipv4Addr

source

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

source

### impl Serialize for Ipv6Addr

source

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

source

### impl Serialize for SocketAddr

source

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

source

### impl Serialize for SocketAddrV4

source

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

source

### impl Serialize for SocketAddrV6

source

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

source

### impl Serialize for Path

source

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

source

### impl Serialize for PathBuf

source

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

source

### impl Serialize for OsStr

source

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

source

### impl Serialize for OsString

source

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

source

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

source

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

source

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

source

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

source

### impl Serialize for AtomicBool

source

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

source

### impl Serialize for AtomicI8

source

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

source

### impl Serialize for AtomicI16

source

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

source

### impl Serialize for AtomicI32

source

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

source

### impl Serialize for AtomicIsize

source

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

source

### impl Serialize for AtomicU8

source

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

source

### impl Serialize for AtomicU16

source

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

source

### impl Serialize for AtomicU32

source

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

source

### impl Serialize for AtomicUsize

source

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

source

### impl Serialize for AtomicI64

source

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

source

### impl Serialize for AtomicU64

source

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

## Implementors