Trait serde_with::SerializeAs

pub trait SerializeAs<T> {
    fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer;
}

A data structure that can be serialized into any data format supported by Serde, analogue to Serialize.

The trait is analogue to the serde::Serialize trait, with the same meaning of input and output arguments. It can and should the implemented using the same code structure as the Serialize trait. As such, the same advice for implementing Serialize applies here.

Differences to Serialize

The trait is only required for container-like types or types implementing specific conversion functions. Container-like types are Vec, BTreeMap, but also Option and Box. Conversion types serialize into a different serde data type. For example, DisplayFromStr uses the Display trait to serialize a String and DurationSeconds converts a Duration into either String or integer values.

This code shows how to implement Serialize for Box:

impl<T> Serialize for Box<T>
where
    T: Serialize,
{
    #[inline]
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        (**self).serialize(serializer)
    }
}

and this code shows how to do the same using SerializeAs:

impl<T, U> SerializeAs<Box<T>> for Box<U>
where
    U: SerializeAs<T>,
{
    fn serialize_as<S>(source: &Box<T>, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        SerializeAsWrap::<T, U>::new(source).serialize(serializer)
    }
}

It uses two type parameters, T and U instead of only one and performs the serialization step using the SerializeAsWrap type. The T type is the on the Rust side before serialization, whereas the U type determines how the value will be serialized. These two changes are usually enough to make a container type implement SerializeAs.

Required methods

fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.

Loading content...

Implementations on Foreign Types

impl SerializeAs<NaiveDateTime> for DateTime<Utc>

fn serialize_as<S>(
    source: &NaiveDateTime,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, U> SerializeAs<Box<T>> for Box<U> where
    U: SerializeAs<T>, 

fn serialize_as<S>(source: &Box<T>, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, U> SerializeAs<Option<T>> for Option<U> where
    U: SerializeAs<T>, 

fn serialize_as<S>(source: &Option<T>, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, U> SerializeAs<BinaryHeap<T>> for BinaryHeap<U> where
    U: SerializeAs<T>,
    T: Ord, 

fn serialize_as<S>(
    source: &BinaryHeap<T>,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, U> SerializeAs<Box<[T]>> for Box<[U]> where
    U: SerializeAs<T>, 

fn serialize_as<S>(source: &Box<[T]>, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, U> SerializeAs<BTreeSet<T>> for BTreeSet<U> where
    U: SerializeAs<T>,
    T: Ord, 

fn serialize_as<S>(
    source: &BTreeSet<T>,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, U, H> SerializeAs<HashSet<T, H>> for HashSet<U, H> where
    U: SerializeAs<T>,
    T: Eq + Hash,
    H: BuildHasher, 

fn serialize_as<S>(
    source: &HashSet<T, H>,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, U> SerializeAs<LinkedList<T>> for LinkedList<U> where
    U: SerializeAs<T>, 

fn serialize_as<S>(
    source: &LinkedList<T>,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, U> SerializeAs<Vec<T>> for Vec<U> where
    U: SerializeAs<T>, 

fn serialize_as<S>(source: &Vec<T>, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, U> SerializeAs<VecDeque<T>> for VecDeque<U> where
    U: SerializeAs<T>, 

fn serialize_as<S>(
    source: &VecDeque<T>,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KU, V, VU> SerializeAs<BTreeMap<K, V>> for BTreeMap<KU, VU> where
    KU: SerializeAs<K>,
    VU: SerializeAs<V>,
    K: Ord, 

fn serialize_as<S>(
    source: &BTreeMap<K, V>,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KU, V, VU, H> SerializeAs<HashMap<K, V, H>> for HashMap<KU, VU, H> where
    KU: SerializeAs<K>,
    VU: SerializeAs<V>,
    K: Eq + Hash,
    H: BuildHasher, 

fn serialize_as<S>(
    source: &HashMap<K, V, H>,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T0, As0> SerializeAs<(T0,)> for (As0,) where
    As0: SerializeAs<T0>, 

fn serialize_as<S>(tuple: &(T0,), serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T0, As0, T1, As1> SerializeAs<(T0, T1)> for (As0, As1) where
    As0: SerializeAs<T0>,
    As1: SerializeAs<T1>, 

fn serialize_as<S>(tuple: &(T0, T1), serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T0, As0, T1, As1, T2, As2> SerializeAs<(T0, T1, T2)> for (As0, As1, As2) where
    As0: SerializeAs<T0>,
    As1: SerializeAs<T1>,
    As2: SerializeAs<T2>, 

fn serialize_as<S>(
    tuple: &(T0, T1, T2),
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T0, As0, T1, As1, T2, As2, T3, As3> SerializeAs<(T0, T1, T2, T3)> for (As0, As1, As2, As3) where
    As0: SerializeAs<T0>,
    As1: SerializeAs<T1>,
    As2: SerializeAs<T2>,
    As3: SerializeAs<T3>, 

fn serialize_as<S>(
    tuple: &(T0, T1, T2, T3),
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T0, As0, T1, As1, T2, As2, T3, As3, T4, As4> SerializeAs<(T0, T1, T2, T3, T4)> for (As0, As1, As2, As3, As4) where
    As0: SerializeAs<T0>,
    As1: SerializeAs<T1>,
    As2: SerializeAs<T2>,
    As3: SerializeAs<T3>,
    As4: SerializeAs<T4>, 

fn serialize_as<S>(
    tuple: &(T0, T1, T2, T3, T4),
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T0, As0, T1, As1, T2, As2, T3, As3, T4, As4, T5, As5> SerializeAs<(T0, T1, T2, T3, T4, T5)> for (As0, As1, As2, As3, As4, As5) where
    As0: SerializeAs<T0>,
    As1: SerializeAs<T1>,
    As2: SerializeAs<T2>,
    As3: SerializeAs<T3>,
    As4: SerializeAs<T4>,
    As5: SerializeAs<T5>, 

fn serialize_as<S>(
    tuple: &(T0, T1, T2, T3, T4, T5),
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T0, As0, T1, As1, T2, As2, T3, As3, T4, As4, T5, As5, T6, As6> SerializeAs<(T0, T1, T2, T3, T4, T5, T6)> for (As0, As1, As2, As3, As4, As5, As6) where
    As0: SerializeAs<T0>,
    As1: SerializeAs<T1>,
    As2: SerializeAs<T2>,
    As3: SerializeAs<T3>,
    As4: SerializeAs<T4>,
    As5: SerializeAs<T5>,
    As6: SerializeAs<T6>, 

fn serialize_as<S>(
    tuple: &(T0, T1, T2, T3, T4, T5, T6),
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T0, As0, T1, As1, T2, As2, T3, As3, T4, As4, T5, As5, T6, As6, T7, As7> SerializeAs<(T0, T1, T2, T3, T4, T5, T6, T7)> for (As0, As1, As2, As3, As4, As5, As6, As7) where
    As0: SerializeAs<T0>,
    As1: SerializeAs<T1>,
    As2: SerializeAs<T2>,
    As3: SerializeAs<T3>,
    As4: SerializeAs<T4>,
    As5: SerializeAs<T5>,
    As6: SerializeAs<T6>,
    As7: SerializeAs<T7>, 

fn serialize_as<S>(
    tuple: &(T0, T1, T2, T3, T4, T5, T6, T7),
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T0, As0, T1, As1, T2, As2, T3, As3, T4, As4, T5, As5, T6, As6, T7, As7, T8, As8> SerializeAs<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> for (As0, As1, As2, As3, As4, As5, As6, As7, As8) where
    As0: SerializeAs<T0>,
    As1: SerializeAs<T1>,
    As2: SerializeAs<T2>,
    As3: SerializeAs<T3>,
    As4: SerializeAs<T4>,
    As5: SerializeAs<T5>,
    As6: SerializeAs<T6>,
    As7: SerializeAs<T7>,
    As8: SerializeAs<T8>, 

fn serialize_as<S>(
    tuple: &(T0, T1, T2, T3, T4, T5, T6, T7, T8),
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T0, As0, T1, As1, T2, As2, T3, As3, T4, As4, T5, As5, T6, As6, T7, As7, T8, As8, T9, As9> SerializeAs<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> for (As0, As1, As2, As3, As4, As5, As6, As7, As8, As9) where
    As0: SerializeAs<T0>,
    As1: SerializeAs<T1>,
    As2: SerializeAs<T2>,
    As3: SerializeAs<T3>,
    As4: SerializeAs<T4>,
    As5: SerializeAs<T5>,
    As6: SerializeAs<T6>,
    As7: SerializeAs<T7>,
    As8: SerializeAs<T8>,
    As9: SerializeAs<T9>, 

fn serialize_as<S>(
    tuple: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9),
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T0, As0, T1, As1, T2, As2, T3, As3, T4, As4, T5, As5, T6, As6, T7, As7, T8, As8, T9, As9, T10, As10> SerializeAs<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> for (As0, As1, As2, As3, As4, As5, As6, As7, As8, As9, As10) where
    As0: SerializeAs<T0>,
    As1: SerializeAs<T1>,
    As2: SerializeAs<T2>,
    As3: SerializeAs<T3>,
    As4: SerializeAs<T4>,
    As5: SerializeAs<T5>,
    As6: SerializeAs<T6>,
    As7: SerializeAs<T7>,
    As8: SerializeAs<T8>,
    As9: SerializeAs<T9>,
    As10: SerializeAs<T10>, 

fn serialize_as<S>(
    tuple: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10),
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T0, As0, T1, As1, T2, As2, T3, As3, T4, As4, T5, As5, T6, As6, T7, As7, T8, As8, T9, As9, T10, As10, T11, As11> SerializeAs<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> for (As0, As1, As2, As3, As4, As5, As6, As7, As8, As9, As10, As11) where
    As0: SerializeAs<T0>,
    As1: SerializeAs<T1>,
    As2: SerializeAs<T2>,
    As3: SerializeAs<T3>,
    As4: SerializeAs<T4>,
    As5: SerializeAs<T5>,
    As6: SerializeAs<T6>,
    As7: SerializeAs<T7>,
    As8: SerializeAs<T8>,
    As9: SerializeAs<T9>,
    As10: SerializeAs<T10>,
    As11: SerializeAs<T11>, 

fn serialize_as<S>(
    tuple: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11),
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T0, As0, T1, As1, T2, As2, T3, As3, T4, As4, T5, As5, T6, As6, T7, As7, T8, As8, T9, As9, T10, As10, T11, As11, T12, As12> SerializeAs<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> for (As0, As1, As2, As3, As4, As5, As6, As7, As8, As9, As10, As11, As12) where
    As0: SerializeAs<T0>,
    As1: SerializeAs<T1>,
    As2: SerializeAs<T2>,
    As3: SerializeAs<T3>,
    As4: SerializeAs<T4>,
    As5: SerializeAs<T5>,
    As6: SerializeAs<T6>,
    As7: SerializeAs<T7>,
    As8: SerializeAs<T8>,
    As9: SerializeAs<T9>,
    As10: SerializeAs<T10>,
    As11: SerializeAs<T11>,
    As12: SerializeAs<T12>, 

fn serialize_as<S>(
    tuple: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12),
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T0, As0, T1, As1, T2, As2, T3, As3, T4, As4, T5, As5, T6, As6, T7, As7, T8, As8, T9, As9, T10, As10, T11, As11, T12, As12, T13, As13> SerializeAs<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> for (As0, As1, As2, As3, As4, As5, As6, As7, As8, As9, As10, As11, As12, As13) where
    As0: SerializeAs<T0>,
    As1: SerializeAs<T1>,
    As2: SerializeAs<T2>,
    As3: SerializeAs<T3>,
    As4: SerializeAs<T4>,
    As5: SerializeAs<T5>,
    As6: SerializeAs<T6>,
    As7: SerializeAs<T7>,
    As8: SerializeAs<T8>,
    As9: SerializeAs<T9>,
    As10: SerializeAs<T10>,
    As11: SerializeAs<T11>,
    As12: SerializeAs<T12>,
    As13: SerializeAs<T13>, 

fn serialize_as<S>(
    tuple: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13),
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T0, As0, T1, As1, T2, As2, T3, As3, T4, As4, T5, As5, T6, As6, T7, As7, T8, As8, T9, As9, T10, As10, T11, As11, T12, As12, T13, As13, T14, As14> SerializeAs<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> for (As0, As1, As2, As3, As4, As5, As6, As7, As8, As9, As10, As11, As12, As13, As14) where
    As0: SerializeAs<T0>,
    As1: SerializeAs<T1>,
    As2: SerializeAs<T2>,
    As3: SerializeAs<T3>,
    As4: SerializeAs<T4>,
    As5: SerializeAs<T5>,
    As6: SerializeAs<T6>,
    As7: SerializeAs<T7>,
    As8: SerializeAs<T8>,
    As9: SerializeAs<T9>,
    As10: SerializeAs<T10>,
    As11: SerializeAs<T11>,
    As12: SerializeAs<T12>,
    As13: SerializeAs<T13>,
    As14: SerializeAs<T14>, 

fn serialize_as<S>(
    tuple: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14),
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T0, As0, T1, As1, T2, As2, T3, As3, T4, As4, T5, As5, T6, As6, T7, As7, T8, As8, T9, As9, T10, As10, T11, As11, T12, As12, T13, As13, T14, As14, T15, As15> SerializeAs<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> for (As0, As1, As2, As3, As4, As5, As6, As7, As8, As9, As10, As11, As12, As13, As14, As15) where
    As0: SerializeAs<T0>,
    As1: SerializeAs<T1>,
    As2: SerializeAs<T2>,
    As3: SerializeAs<T3>,
    As4: SerializeAs<T4>,
    As5: SerializeAs<T5>,
    As6: SerializeAs<T6>,
    As7: SerializeAs<T7>,
    As8: SerializeAs<T8>,
    As9: SerializeAs<T9>,
    As10: SerializeAs<T10>,
    As11: SerializeAs<T11>,
    As12: SerializeAs<T12>,
    As13: SerializeAs<T13>,
    As14: SerializeAs<T14>,
    As15: SerializeAs<T15>, 

fn serialize_as<S>(
    tuple: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15),
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, As> SerializeAs<[T; 0]> for [As; 0] where
    As: SerializeAs<T>, 

fn serialize_as<S>(array: &[T; 0], serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, As> SerializeAs<[T; 1]> for [As; 1] where
    As: SerializeAs<T>, 

fn serialize_as<S>(array: &[T; 1], serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, As> SerializeAs<[T; 2]> for [As; 2] where
    As: SerializeAs<T>, 

fn serialize_as<S>(array: &[T; 2], serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, As> SerializeAs<[T; 3]> for [As; 3] where
    As: SerializeAs<T>, 

fn serialize_as<S>(array: &[T; 3], serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, As> SerializeAs<[T; 4]> for [As; 4] where
    As: SerializeAs<T>, 

fn serialize_as<S>(array: &[T; 4], serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, As> SerializeAs<[T; 5]> for [As; 5] where
    As: SerializeAs<T>, 

fn serialize_as<S>(array: &[T; 5], serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, As> SerializeAs<[T; 6]> for [As; 6] where
    As: SerializeAs<T>, 

fn serialize_as<S>(array: &[T; 6], serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, As> SerializeAs<[T; 7]> for [As; 7] where
    As: SerializeAs<T>, 

fn serialize_as<S>(array: &[T; 7], serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, As> SerializeAs<[T; 8]> for [As; 8] where
    As: SerializeAs<T>, 

fn serialize_as<S>(array: &[T; 8], serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, As> SerializeAs<[T; 9]> for [As; 9] where
    As: SerializeAs<T>, 

fn serialize_as<S>(array: &[T; 9], serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, As> SerializeAs<[T; 10]> for [As; 10] where
    As: SerializeAs<T>, 

fn serialize_as<S>(array: &[T; 10], serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, As> SerializeAs<[T; 11]> for [As; 11] where
    As: SerializeAs<T>, 

fn serialize_as<S>(array: &[T; 11], serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, As> SerializeAs<[T; 12]> for [As; 12] where
    As: SerializeAs<T>, 

fn serialize_as<S>(array: &[T; 12], serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, As> SerializeAs<[T; 13]> for [As; 13] where
    As: SerializeAs<T>, 

fn serialize_as<S>(array: &[T; 13], serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, As> SerializeAs<[T; 14]> for [As; 14] where
    As: SerializeAs<T>, 

fn serialize_as<S>(array: &[T; 14], serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, As> SerializeAs<[T; 15]> for [As; 15] where
    As: SerializeAs<T>, 

fn serialize_as<S>(array: &[T; 15], serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, As> SerializeAs<[T; 16]> for [As; 16] where
    As: SerializeAs<T>, 

fn serialize_as<S>(array: &[T; 16], serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, As> SerializeAs<[T; 17]> for [As; 17] where
    As: SerializeAs<T>, 

fn serialize_as<S>(array: &[T; 17], serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, As> SerializeAs<[T; 18]> for [As; 18] where
    As: SerializeAs<T>, 

fn serialize_as<S>(array: &[T; 18], serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, As> SerializeAs<[T; 19]> for [As; 19] where
    As: SerializeAs<T>, 

fn serialize_as<S>(array: &[T; 19], serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, As> SerializeAs<[T; 20]> for [As; 20] where
    As: SerializeAs<T>, 

fn serialize_as<S>(array: &[T; 20], serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, As> SerializeAs<[T; 21]> for [As; 21] where
    As: SerializeAs<T>, 

fn serialize_as<S>(array: &[T; 21], serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, As> SerializeAs<[T; 22]> for [As; 22] where
    As: SerializeAs<T>, 

fn serialize_as<S>(array: &[T; 22], serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, As> SerializeAs<[T; 23]> for [As; 23] where
    As: SerializeAs<T>, 

fn serialize_as<S>(array: &[T; 23], serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, As> SerializeAs<[T; 24]> for [As; 24] where
    As: SerializeAs<T>, 

fn serialize_as<S>(array: &[T; 24], serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, As> SerializeAs<[T; 25]> for [As; 25] where
    As: SerializeAs<T>, 

fn serialize_as<S>(array: &[T; 25], serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, As> SerializeAs<[T; 26]> for [As; 26] where
    As: SerializeAs<T>, 

fn serialize_as<S>(array: &[T; 26], serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, As> SerializeAs<[T; 27]> for [As; 27] where
    As: SerializeAs<T>, 

fn serialize_as<S>(array: &[T; 27], serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, As> SerializeAs<[T; 28]> for [As; 28] where
    As: SerializeAs<T>, 

fn serialize_as<S>(array: &[T; 28], serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, As> SerializeAs<[T; 29]> for [As; 29] where
    As: SerializeAs<T>, 

fn serialize_as<S>(array: &[T; 29], serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, As> SerializeAs<[T; 30]> for [As; 30] where
    As: SerializeAs<T>, 

fn serialize_as<S>(array: &[T; 30], serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, As> SerializeAs<[T; 31]> for [As; 31] where
    As: SerializeAs<T>, 

fn serialize_as<S>(array: &[T; 31], serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, As> SerializeAs<[T; 32]> for [As; 32] where
    As: SerializeAs<T>, 

fn serialize_as<S>(array: &[T; 32], serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<BTreeMap<K, V>> for Vec<(KAs, VAs)> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &BTreeMap<K, V>,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<HashMap<K, V, RandomState>> for Vec<(KAs, VAs)> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &HashMap<K, V>,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<BinaryHeap<(K, V)>> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &BinaryHeap<(K, V)>,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<BinaryHeap<(K, V)>> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &BinaryHeap<(K, V)>,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<BTreeSet<(K, V)>> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &BTreeSet<(K, V)>,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<BTreeSet<(K, V)>> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &BTreeSet<(K, V)>,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<HashSet<(K, V), RandomState>> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &HashSet<(K, V)>,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<HashSet<(K, V), RandomState>> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &HashSet<(K, V)>,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<LinkedList<(K, V)>> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &LinkedList<(K, V)>,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<LinkedList<(K, V)>> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &LinkedList<(K, V)>,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<Option<(K, V)>> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &Option<(K, V)>,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<Option<(K, V)>> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &Option<(K, V)>,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<Vec<(K, V)>> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &Vec<(K, V)>,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<Vec<(K, V)>> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &Vec<(K, V)>,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<VecDeque<(K, V)>> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &VecDeque<(K, V)>,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<VecDeque<(K, V)>> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &VecDeque<(K, V)>,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 0]> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 0],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 0]> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 0],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 1]> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 1],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 1]> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 1],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 2]> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 2],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 2]> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 2],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 3]> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 3],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 3]> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 3],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 4]> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 4],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 4]> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 4],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 5]> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 5],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 5]> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 5],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 6]> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 6],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 6]> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 6],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 7]> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 7],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 7]> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 7],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 8]> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 8],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 8]> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 8],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 9]> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 9],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 9]> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 9],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 10]> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 10],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 10]> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 10],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 11]> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 11],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 11]> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 11],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 12]> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 12],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 12]> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 12],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 13]> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 13],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 13]> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 13],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 14]> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 14],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 14]> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 14],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 15]> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 15],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 15]> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 15],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 16]> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 16],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 16]> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 16],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 17]> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 17],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 17]> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 17],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 18]> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 18],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 18]> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 18],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 19]> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 19],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 19]> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 19],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 20]> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 20],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 20]> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 20],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 21]> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 21],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 21]> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 21],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 22]> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 22],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 22]> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 22],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 23]> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 23],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 23]> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 23],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 24]> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 24],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 24]> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 24],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 25]> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 25],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 25]> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 25],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 26]> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 26],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 26]> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 26],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 27]> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 27],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 27]> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 27],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 28]> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 28],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 28]> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 28],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 29]> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 29],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 29]> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 29],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 30]> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 30],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 30]> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 30],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 31]> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 31],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 31]> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 31],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 32]> for BTreeMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 32],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, KAs, V, VAs> SerializeAs<[(K, V); 32]> for HashMap<KAs, VAs> where
    KAs: SerializeAs<K>,
    VAs: SerializeAs<V>, 

fn serialize_as<S>(
    source: &[(K, V); 32],
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Loading content...

Implementors

impl SerializeAs<Vec<u8>> for BytesOrString

fn serialize_as<S>(source: &Vec<u8>, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<AsRefStr> SerializeAs<Option<AsRefStr>> for NoneAsEmptyString where
    AsRefStr: AsRef<str>, 

fn serialize_as<S>(
    source: &Option<AsRefStr>,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<SEPARATOR, I, T> SerializeAs<I> for StringWithSeparator<SEPARATOR, T> where
    SEPARATOR: Separator,
    &'a I: IntoIterator<Item = &'a T>,
    T: ToString, 

fn serialize_as<S>(source: &I, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<STRICTNESS> SerializeAs<Duration> for DurationSeconds<f64, STRICTNESS> where
    STRICTNESS: Strictness, 

fn serialize_as<S>(source: &Duration, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<STRICTNESS> SerializeAs<Duration> for DurationSeconds<u64, STRICTNESS> where
    STRICTNESS: Strictness, 

fn serialize_as<S>(source: &Duration, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<STRICTNESS> SerializeAs<Duration> for DurationSeconds<String, STRICTNESS> where
    STRICTNESS: Strictness, 

fn serialize_as<S>(source: &Duration, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<STRICTNESS> SerializeAs<Duration> for DurationSecondsWithFrac<f64, STRICTNESS> where
    STRICTNESS: Strictness, 

fn serialize_as<S>(source: &Duration, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<STRICTNESS> SerializeAs<Duration> for DurationSecondsWithFrac<String, STRICTNESS> where
    STRICTNESS: Strictness, 

fn serialize_as<S>(source: &Duration, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<STRICTNESS> SerializeAs<SystemTime> for TimestampSeconds<f64, STRICTNESS> where
    STRICTNESS: Strictness, 

fn serialize_as<S>(
    source: &SystemTime,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<STRICTNESS> SerializeAs<SystemTime> for TimestampSeconds<i64, STRICTNESS> where
    STRICTNESS: Strictness, 

fn serialize_as<S>(
    source: &SystemTime,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<STRICTNESS> SerializeAs<SystemTime> for TimestampSeconds<String, STRICTNESS> where
    STRICTNESS: Strictness, 

fn serialize_as<S>(
    source: &SystemTime,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<STRICTNESS> SerializeAs<SystemTime> for TimestampSecondsWithFrac<f64, STRICTNESS> where
    STRICTNESS: Strictness, 

fn serialize_as<S>(
    source: &SystemTime,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<STRICTNESS> SerializeAs<SystemTime> for TimestampSecondsWithFrac<String, STRICTNESS> where
    STRICTNESS: Strictness, 

fn serialize_as<S>(
    source: &SystemTime,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<STRICTNESS> SerializeAs<Duration> for DurationSeconds<f64, STRICTNESS> where
    STRICTNESS: Strictness, 

fn serialize_as<S>(source: &Duration, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<STRICTNESS> SerializeAs<Duration> for DurationSeconds<i64, STRICTNESS> where
    STRICTNESS: Strictness, 

fn serialize_as<S>(source: &Duration, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<STRICTNESS> SerializeAs<Duration> for DurationSeconds<String, STRICTNESS> where
    STRICTNESS: Strictness, 

fn serialize_as<S>(source: &Duration, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<STRICTNESS> SerializeAs<Duration> for DurationSecondsWithFrac<f64, STRICTNESS> where
    STRICTNESS: Strictness, 

fn serialize_as<S>(source: &Duration, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<STRICTNESS> SerializeAs<Duration> for DurationSecondsWithFrac<String, STRICTNESS> where
    STRICTNESS: Strictness, 

fn serialize_as<S>(source: &Duration, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T> SerializeAs<T> for Hex<Lowercase> where
    T: AsRef<[u8]>, 

fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T> SerializeAs<T> for Hex<Uppercase> where
    T: AsRef<[u8]>, 

fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T> SerializeAs<T> for JsonString where
    T: Serialize, 

fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T> SerializeAs<T> for DisplayFromStr where
    T: Display, 

fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T, TAs> SerializeAs<T> for DefaultOnError<TAs> where
    TAs: SerializeAs<T>, 

fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<T: Serialize> SerializeAs<T> for Same

fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<TZ, STRICTNESS> SerializeAs<DateTime<TZ>> for TimestampSeconds<f64, STRICTNESS> where
    TZ: TimeZone,
    STRICTNESS: Strictness, 

fn serialize_as<S>(
    source: &DateTime<TZ>,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<TZ, STRICTNESS> SerializeAs<DateTime<TZ>> for TimestampSeconds<i64, STRICTNESS> where
    TZ: TimeZone,
    STRICTNESS: Strictness, 

fn serialize_as<S>(
    source: &DateTime<TZ>,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<TZ, STRICTNESS> SerializeAs<DateTime<TZ>> for TimestampSeconds<String, STRICTNESS> where
    TZ: TimeZone,
    STRICTNESS: Strictness, 

fn serialize_as<S>(
    source: &DateTime<TZ>,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<TZ, STRICTNESS> SerializeAs<DateTime<TZ>> for TimestampSecondsWithFrac<f64, STRICTNESS> where
    TZ: TimeZone,
    STRICTNESS: Strictness, 

fn serialize_as<S>(
    source: &DateTime<TZ>,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<TZ, STRICTNESS> SerializeAs<DateTime<TZ>> for TimestampSecondsWithFrac<String, STRICTNESS> where
    TZ: TimeZone,
    STRICTNESS: Strictness, 

fn serialize_as<S>(
    source: &DateTime<TZ>,
    serializer: S
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Loading content...