Trait Serialize

pub trait Serialize<S: Fallible + ?Sized>: Archive {
    // Required method
    fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>;
}

Converts a type to its archived form.

Objects perform any supportive serialization during serialize. For types that reference nonlocal (pointed-to) data, this is when that data must be serialized to the output. These types will need to bound S to implement Writer and any other required traits (e.g. Sharing). They should then serialize their dependencies during serialize.

See Archive for examples of implementing Serialize.

Required Methods

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<K, S> Serialize<S> for BTreeSet<K>

where K: Serialize<S> + Ord, K::Archived: Ord, S: Fallible + Allocator + Writer + ?Sized, S::Error: Source,

Available on crate feature alloc only.

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

impl<K, S, RS> Serialize<S> for HashSet<K, RS>

where K::Archived: Hash + Eq, K: Serialize<S> + Hash + Eq, S: Fallible + Allocator + Writer + ?Sized, S::Error: Source,

Available on crate feature std only.

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

impl<K, V, S> Serialize<S> for BTreeMap<K, V>

where K: Serialize<S> + Ord, K::Archived: Ord, V: Serialize<S>, S: Allocator + Fallible + Writer + ?Sized, S::Error: Source,

Available on crate feature alloc only.

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

impl<K, V, S, RandomState> Serialize<S> for HashMap<K, V, RandomState>

where K: Serialize<S> + Hash + Eq, K::Archived: Hash + Eq, V: Serialize<S>, S: Fallible + Writer + Allocator + ?Sized, S::Error: Source,

Available on crate feature std only.

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + Writer + ?Sized> Serialize<S> for CString

Available on crate feature alloc only.

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for IpAddr

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for SocketAddr

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for bool

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for char

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for f32

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for f64

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for i8

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for i16

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for i32

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for i64

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for i128

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for isize

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for u8

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for u16

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for u32

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for u64

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for u128

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for ()

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for usize

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for String

where S::Error: Source, str: SerializeUnsized<S>,

Available on crate feature alloc only.

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for PhantomPinned

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for Ipv4Addr

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for Ipv6Addr

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for SocketAddrV4

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for SocketAddrV6

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for RangeFull

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for Duration

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for NonZeroI16_be

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for NonZeroI16_le

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for NonZeroI32_be

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for NonZeroI32_le

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for NonZeroI64_be

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for NonZeroI64_le

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for NonZeroI128_be

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for NonZeroI128_le

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for NonZeroU16_be

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for NonZeroU16_le

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for NonZeroU32_be

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for NonZeroU32_le

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for NonZeroU64_be

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for NonZeroU64_le

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for NonZeroU128_be

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for NonZeroU128_le

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for char_be

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for char_le

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for f32_be

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for f32_le

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for f64_be

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for f64_le

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for i16_be

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for i16_le

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for i32_be

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for i32_le

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for i64_be

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for i64_le

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for i128_be

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for i128_le

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for u16_be

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for u16_le

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for u32_be

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for u32_le

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for u64_be

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for u64_le

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for u128_be

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for u128_le

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for NonZeroI8

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for NonZeroI16

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for NonZeroI32

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for NonZeroI64

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for NonZeroI128

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for NonZeroIsize

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for NonZeroU8

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for NonZeroU16

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for NonZeroU32

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for NonZeroU64

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for NonZeroU128

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<S: Fallible + ?Sized> Serialize<S> for NonZeroUsize

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

impl<T0, S> Serialize<S> for (T0,)

where T0: Serialize<S>, S: Fallible + ?Sized,

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

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

where T0: Serialize<S>, T1: Serialize<S>, S: Fallible + ?Sized,

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

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

where T0: Serialize<S>, T1: Serialize<S>, T2: Serialize<S>, S: Fallible + ?Sized,

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

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

where T0: Serialize<S>, T1: Serialize<S>, T2: Serialize<S>, T3: Serialize<S>, S: Fallible + ?Sized,

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

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

where T0: Serialize<S>, T1: Serialize<S>, T2: Serialize<S>, T3: Serialize<S>, T4: Serialize<S>, S: Fallible + ?Sized,

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

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

where T0: Serialize<S>, T1: Serialize<S>, T2: Serialize<S>, T3: Serialize<S>, T4: Serialize<S>, T5: Serialize<S>, S: Fallible + ?Sized,

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

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

where T0: Serialize<S>, T1: Serialize<S>, T2: Serialize<S>, T3: Serialize<S>, T4: Serialize<S>, T5: Serialize<S>, T6: Serialize<S>, S: Fallible + ?Sized,

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

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

where T0: Serialize<S>, T1: Serialize<S>, T2: Serialize<S>, T3: Serialize<S>, T4: Serialize<S>, T5: Serialize<S>, T6: Serialize<S>, T7: Serialize<S>, S: Fallible + ?Sized,

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

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

where T0: Serialize<S>, T1: Serialize<S>, T2: Serialize<S>, T3: Serialize<S>, T4: Serialize<S>, T5: Serialize<S>, T6: Serialize<S>, T7: Serialize<S>, T8: Serialize<S>, S: Fallible + ?Sized,

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

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

where T0: Serialize<S>, T1: Serialize<S>, T2: Serialize<S>, T3: Serialize<S>, T4: Serialize<S>, T5: Serialize<S>, T6: Serialize<S>, T7: Serialize<S>, T8: Serialize<S>, T9: Serialize<S>, S: Fallible + ?Sized,

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

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

where T0: Serialize<S>, T1: Serialize<S>, T2: Serialize<S>, T3: Serialize<S>, T4: Serialize<S>, T5: Serialize<S>, T6: Serialize<S>, T7: Serialize<S>, T8: Serialize<S>, T9: Serialize<S>, T10: Serialize<S>, S: Fallible + ?Sized,

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

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

where T0: Serialize<S>, T1: Serialize<S>, T2: Serialize<S>, T3: Serialize<S>, T4: Serialize<S>, T5: Serialize<S>, T6: Serialize<S>, T7: Serialize<S>, T8: Serialize<S>, T9: Serialize<S>, T10: Serialize<S>, T11: Serialize<S>, S: Fallible + ?Sized,

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

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

where T0: Serialize<S>, T1: Serialize<S>, T2: Serialize<S>, T3: Serialize<S>, T4: Serialize<S>, T5: Serialize<S>, T6: Serialize<S>, T7: Serialize<S>, T8: Serialize<S>, T9: Serialize<S>, T10: Serialize<S>, T11: Serialize<S>, T12: Serialize<S>, S: Fallible + ?Sized,

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

impl<T, S> Serialize<S> for Box<T>

where T: SerializeUnsized<S> + ?Sized, S: Fallible + ?Sized,

Available on crate feature alloc only.

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

impl<T, S> Serialize<S> for VecDeque<T>

where T: Serialize<S>, S: Fallible + Allocator + Writer + ?Sized,

Available on crate feature alloc only.

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

impl<T, S> Serialize<S> for Rc<T>

where T: SerializeUnsized<S> + ?Sized + 'static, S: Fallible + Writer + Sharing + ?Sized, S::Error: Source,

Available on crate feature alloc only.

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

impl<T, S> Serialize<S> for Weak<T>

where T: SerializeUnsized<S> + ?Sized + 'static, S: Fallible + Writer + Sharing + ?Sized, S::Error: Source,

Available on crate feature alloc only.

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

impl<T, S> Serialize<S> for Arc<T>

where T: SerializeUnsized<S> + ?Sized + 'static, S: Fallible + Writer + Sharing + ?Sized, S::Error: Source,

Available on target_has_atomic="ptr" and crate feature alloc only.

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

impl<T, S> Serialize<S> for Weak<T>

where T: SerializeUnsized<S> + ?Sized + 'static, S: Fallible + Writer + Sharing + ?Sized, S::Error: Source,

Available on target_has_atomic="ptr" and crate feature alloc only.

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

impl<T, S> Serialize<S> for RangeToInclusive<T>

where T: Serialize<S>, S: Fallible + ?Sized,

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

impl<T, S, const N: usize> Serialize<S> for [T; N]

where T: Serialize<S>, S: Fallible + ?Sized,

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

impl<T, U, S> Serialize<S> for Result<T, U>

where T: Serialize<S>, U: Serialize<S>, S: Fallible + ?Sized,

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

impl<T: Serialize<S>, S: Fallible + Allocator + Writer + ?Sized> Serialize<S> for Vec<T>

Available on crate feature alloc only.

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

impl<T: Serialize<S>, S: Fallible + ?Sized> Serialize<S> for Bound<T>

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

impl<T: Serialize<S>, S: Fallible + ?Sized> Serialize<S> for Option<T>

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

impl<T: Serialize<S>, S: Fallible + ?Sized> Serialize<S> for ManuallyDrop<T>

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

impl<T: Serialize<S>, S: Fallible + ?Sized> Serialize<S> for Range<T>

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

impl<T: Serialize<S>, S: Fallible + ?Sized> Serialize<S> for RangeFrom<T>

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

impl<T: Serialize<S>, S: Fallible + ?Sized> Serialize<S> for RangeInclusive<T>

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

impl<T: Serialize<S>, S: Fallible + ?Sized> Serialize<S> for RangeTo<T>

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

impl<T: ?Sized, S: Fallible + ?Sized> Serialize<S> for PhantomData<T>

fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error>

Implementors

impl<S, BK, BV, K, V> Serialize<S> for EntryAdapter<BK, BV, K, V>

where S: Fallible + ?Sized, BK: Borrow<K>, BV: Borrow<V>, K: Serialize<S>, V: Serialize<S>,

impl<S, F, W> Serialize<S> for With<F, W>

where S: Fallible + ?Sized, F: ?Sized, W: SerializeWith<F, S>,