oct 0.36.2

// Copyright 2024-2026 Gabriel Bjørnager Jensen.
//
// SPDX: MIT OR Apache-2.0

//! The [`Serialise`] trait.

mod test;

use core::cell::{
	Cell,
	LazyCell,
	OnceCell,
	Ref,
	RefCell,
	RefMut,
	UnsafeCell,
};
use core::cmp::{self, Reverse};
use core::convert::Infallible;
use core::ffi::CStr;
use core::marker::{PhantomData, PhantomPinned};
use core::mem::ManuallyDrop;
use core::net::{
	IpAddr,
	Ipv4Addr,
	Ipv6Addr,
	SocketAddr,
	SocketAddrV4,
	SocketAddrV6,
};
use core::num::{NonZero, Saturating, Wrapping};
use core::ops::{
	Bound,
	Range,
	RangeFrom,
	RangeFull,
	RangeInclusive,
	RangeTo,
	RangeToInclusive,
};
use core::time::Duration;
use oct::serdes::{self, Error, serialise_iter, Write};

#[allow(unused_imports)]
use core::sync::atomic;

#[allow(unused_imports)]
use oct::transmute;

#[cfg(feature = "alloc")]
use alloc::borrow::{Cow, ToOwned};

#[cfg(feature = "alloc")]
use alloc::boxed::Box;

#[cfg(feature = "alloc")]
use alloc::collections::{BinaryHeap, LinkedList, VecDeque};

#[cfg(feature = "alloc")]
use alloc::ffi::CString;

#[cfg(feature = "alloc")]
use alloc::rc::{self, Rc};

#[cfg(feature = "alloc")]
use alloc::string::String;

#[cfg(feature = "alloc")]
use alloc::vec::Vec;

#[cfg(all(feature = "alloc", feature = "bstr"))]
use alloc::bstr::ByteString;

#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))]
use alloc::sync::{self, Arc};

#[cfg(feature = "ascii")]
use core::ascii;

#[cfg(feature = "bstr")]
use core::bstr::ByteStr;

#[cfg(feature = "simd")]
use core::simd::{self, MaskElement, Simd, SimdElement};

#[cfg(feature = "std")]
use core::hash::BuildHasher;

#[cfg(feature = "std")]
use std::collections::{HashMap, HashSet};

#[cfg(feature = "std")]
use std::io::Cursor;

#[cfg(feature = "std")]
use std::net::Shutdown;

#[cfg(feature = "std")]
use std::sync::{LazyLock, Mutex, OnceLock, RwLock};

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
use core::arch::aarch64 as arch;

#[cfg(target_arch = "wasm32")]
use core::arch::wasm32 as arch;

#[cfg(target_arch = "x86")]
use core::arch::x86 as arch;

#[cfg(target_arch = "x86_64")]
use core::arch::x86_64 as arch;

#[cfg(target_has_atomic = "8")]
use core::sync::atomic::{AtomicBool, AtomicI8, AtomicU8};

#[cfg(target_has_atomic = "16")]
use core::sync::atomic::{AtomicI16, AtomicU16};

#[cfg(target_has_atomic = "32")]
use core::sync::atomic::{AtomicI32, AtomicU32};

#[cfg(target_has_atomic = "64")]
use core::sync::atomic::{AtomicI64, AtomicU64};

#[cfg(all(target_has_atomic = "128", feature = "atomic_u128_i128"))]
use core::sync::atomic::{AtomicI128, AtomicU128};

#[cfg(target_has_atomic = "ptr")]
use core::sync::atomic::{AtomicIsize, AtomicUsize};

/// Denotes a type capable of being serialised into
/// octets.
///
/// [`IntoOctets`]: oct::IntoOctets
#[doc(alias = "Serialize")]
#[doc(alias = "Encode")]
pub trait Serialise {
	/// Serialises the object into the provided writer.
	///
	/// # Errors
	///
	/// This function should forward any error given by
	/// `w`. In the case of the provided object value
	/// itself being unserialisable, this method should
	/// return an [`InvalidInput`] error without writing
	/// to the writer. The state of the writer in case
	/// of error is otherwise unspecified.
	///
	/// [`InvalidInput`]: Error::invalid_input
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()>;
}

#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))]
impl<T: ?Sized + Serialise> Serialise for Arc<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		T::serialise(self, w)
	}
}

// SORT: array
impl<T: Serialise, const N: usize> Serialise for [T; N] {
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		serialise_iter(self, w)
	}
}

#[cfg(target_has_atomic = "8")]
impl Serialise for AtomicBool {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.load(atomic::Ordering::Relaxed).serialise(w)
	}
}

#[cfg(all(target_has_atomic = "128", feature = "atomic_u128_i128"))]
impl Serialise for AtomicI128 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.load(atomic::Ordering::Relaxed).serialise(w)
	}
}

#[cfg(target_has_atomic = "16")]
impl Serialise for AtomicI16 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.load(atomic::Ordering::Relaxed).serialise(w)
	}
}

#[cfg(target_has_atomic = "32")]
impl Serialise for AtomicI32 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.load(atomic::Ordering::Relaxed).serialise(w)
	}
}

#[cfg(target_has_atomic = "64")]
impl Serialise for AtomicI64 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.load(atomic::Ordering::Relaxed).serialise(w)
	}
}

#[cfg(target_has_atomic = "8")]
impl Serialise for AtomicI8 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.load(atomic::Ordering::Relaxed).serialise(w)
	}
}

#[cfg(target_has_atomic = "ptr")]
impl Serialise for AtomicIsize {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.load(atomic::Ordering::Relaxed).serialise(w)
	}
}

#[cfg(all(target_has_atomic = "128", feature = "atomic_u128_i128"))]
impl Serialise for AtomicU128 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.load(atomic::Ordering::Relaxed).serialise(w)
	}
}

#[cfg(target_has_atomic = "16")]
impl Serialise for AtomicU16 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.load(atomic::Ordering::Relaxed).serialise(w)
	}
}

#[cfg(target_has_atomic = "32")]
impl Serialise for AtomicU32 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.load(atomic::Ordering::Relaxed).serialise(w)
	}
}

#[cfg(target_has_atomic = "64")]
impl Serialise for AtomicU64 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.load(atomic::Ordering::Relaxed).serialise(w)
	}
}

#[cfg(target_has_atomic = "8")]
impl Serialise for AtomicU8 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.load(atomic::Ordering::Relaxed).serialise(w)
	}
}

#[cfg(target_has_atomic = "ptr")]
impl Serialise for AtomicUsize {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.load(atomic::Ordering::Relaxed).serialise(w)
	}
}

#[cfg(feature = "alloc")]
impl<T: Serialise> Serialise for BinaryHeap<T> {
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.as_slice().serialise(w)
	}
}

impl Serialise for bool {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		u8::from(*self).serialise(w)
	}
}

impl<T: Serialise> Serialise for Bound<T> {
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		match *self {
			Self::Included(ref bound) => {
				serdes::BOUND_INCLUDED.serialise(w)?;
				bound.serialise(w)?;
			}

			Self::Excluded(ref bound) => {
				serdes::BOUND_EXCLUDED.serialise(w)?;
				bound.serialise(w)?;
			}

			Self::Unbounded => {
				serdes::BOUND_UNBOUNDED.serialise(w)?;
			}
		}

		Ok(())
	}
}

#[cfg(feature = "alloc")]
impl<T: ?Sized + Serialise> Serialise for Box<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		T::serialise(self, w)
	}
}

#[cfg(feature = "bstr")]
impl Serialise for ByteStr {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.0.serialise(w)
	}
}

#[cfg(all(feature = "alloc", feature = "bstr"))]
impl Serialise for ByteString {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.0.serialise(w)
	}
}

impl Serialise for CStr {
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.to_bytes().serialise(w)
	}
}

#[cfg(feature = "alloc")]
impl Serialise for CString {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.as_c_str().serialise(w)
	}
}

impl<T: Copy + Serialise> Serialise for Cell<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.get().serialise(w)
	}
}

impl Serialise for char {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		u32::from(*self).serialise(w)
	}
}

#[cfg(feature = "ascii")]
impl Serialise for ascii::Char {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.to_u8().serialise(w)
	}
}

#[cfg(feature = "alloc")]
impl<B: ?Sized + ToOwned + Serialise> Serialise for Cow<'_, B> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		B::serialise(self, w)
	}
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
impl Serialise for arch::CpuidResult {
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.eax.serialise(w)?;
		self.ebx.serialise(w)?;
		self.ecx.serialise(w)?;
		self.edx.serialise(w)?;
		Ok(())
	}
}

#[cfg(feature = "std")]
impl<T: Serialise> Serialise for Cursor<T> {
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.position().serialise(w)?;
		self.get_ref().serialise(w)?;
		Ok(())
	}
}

impl Serialise for Duration {
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.as_secs().serialise(w)?;
		self.subsec_nanos().serialise(w)
	}
}

#[cfg(feature = "f16")]
impl Serialise for f16 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		w.write_all(&self.to_le_bytes())
	}
}

impl Serialise for f32 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		w.write_all(&self.to_le_bytes())
	}
}

impl Serialise for f64 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		w.write_all(&self.to_le_bytes())
	}
}

#[cfg(feature = "f128")]
impl Serialise for f128 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		w.write_all(&self.to_le_bytes())
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
impl Serialise for arch::float16x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		// FIXME(f16): Use `f16` instead.
		transmute::<Self, [u16; 4]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
impl Serialise for arch::float16x4x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		// FIXME(f16): Use `f16` instead.
		transmute::<Self, [u16; 8]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
impl Serialise for arch::float16x4x3_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		// FIXME(f16): Use `f16` instead.
		transmute::<Self, [u16; 12]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
impl Serialise for arch::float16x4x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		// FIXME(f16): Use `f16` instead.
		transmute::<Self, [u16; 16]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
impl Serialise for arch::float16x8_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		// FIXME(f16): Use `f16` instead.
		transmute::<Self, [u16; 8]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
impl Serialise for arch::float16x8x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		// FIXME(f16): Use `f16` instead.
		transmute::<Self, [u16; 16]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
impl Serialise for arch::float16x8x3_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		// FIXME(f16): Use `f16` instead.
		transmute::<Self, [u16; 24]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
impl Serialise for arch::float16x8x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		// FIXME(f16): Use `f16` instead.
		transmute::<Self, [u16; 32]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::float32x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [f32; 2]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::float32x2x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [f32; 4]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::float32x2x3_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [f32; 6]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::float32x2x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [f32; 8]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::float32x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [f32; 4]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::float32x4x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [f32; 8]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::float32x4x3_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [f32; 12]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::float32x4x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [f32; 16]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
impl Serialise for arch::float64x1_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [f64; 1]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
impl Serialise for arch::float64x1x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [f64; 2]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
impl Serialise for arch::float64x1x3_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [f64; 3]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
impl Serialise for arch::float64x1x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [f64; 4]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
impl Serialise for arch::float64x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [f64; 2]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
impl Serialise for arch::float64x2x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [f64; 4]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
impl Serialise for arch::float64x2x3_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [f64; 6]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
impl Serialise for arch::float64x2x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [f64; 8]>(*self).serialise(w)
	}
}

#[cfg(feature = "std")]
impl<K: Serialise, V: Serialise, S: BuildHasher> Serialise for HashMap<K, V, S> {
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.len().serialise(w)?;
		serialise_iter(self, w)
	}
}

#[cfg(feature = "std")]
impl<T: Serialise, S: BuildHasher> Serialise for HashSet<T, S> {
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.len().serialise(w)?;
		serialise_iter(self, w)
	}
}

impl Serialise for i128 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		w.write_all(&self.to_le_bytes())
	}
}

impl Serialise for i16 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		w.write_all(&self.to_le_bytes())
	}
}

impl Serialise for i32 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		w.write_all(&self.to_le_bytes())
	}
}

impl Serialise for i64 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		w.write_all(&self.to_le_bytes())
	}
}

impl Serialise for i8 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		w.write_all(&self.to_le_bytes())
	}
}

impl Serialise for Infallible {
	#[inline]
	fn serialise<W: Write>(&self, _w: &mut W) -> serdes::Result<()> {
		match *self {}
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::int16x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [i16; 4]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::int16x4x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [i16; 8]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::int16x4x3_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [i16; 12]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::int16x4x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [i16; 16]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::int16x8_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [i16; 8]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::int16x8x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [i16; 16]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::int16x8x3_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [i16; 24]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::int16x8x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [i16; 32]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::int32x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [i32; 2]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::int32x2x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [i32; 4]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::int32x2x3_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [i32; 6]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::int32x2x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [i32; 8]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::int32x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [i32; 4]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::int32x4x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [i32; 8]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::int32x4x3_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [i32; 12]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::int32x4x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [i32; 16]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::int64x1_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [i64; 1]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::int64x1x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [i64; 2]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::int64x1x3_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [i64; 3]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::int64x1x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [i64; 4]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::int64x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [i64; 2]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::int64x2x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [i64; 4]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::int64x2x3_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [i64; 6]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::int64x2x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [i64; 8]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::int8x16_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [i8; 16]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::int8x16x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [i8; 32]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::int8x16x3_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [i8; 48]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::int8x16x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [i8; 64]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::int8x8_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [i8; 8]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::int8x8x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [i8; 16]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::int8x8x3_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [i8; 24]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::int8x8x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [i8; 32]>(*self).serialise(w)
	}
}

impl Serialise for IpAddr {
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		match *self {
			Self::V4(addr) => {
				serdes::IP_ADDR_V4.serialise(w)?;
				addr.serialise(w)?;
			}

			Self::V6(addr) => {
				serdes::IP_ADDR_V6.serialise(w)?;
				addr.serialise(w)?;
			}
		}

		Ok(())
	}
}

impl Serialise for Ipv4Addr {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.to_bits().serialise(w)
	}
}

impl Serialise for Ipv6Addr {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.to_bits().serialise(w)
	}
}

impl Serialise for isize {
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		i16::try_from(*self)
			.map_err(|_| Error::invalid_input())?
			.serialise(w)
	}
}

impl<T: Serialise> Serialise for LazyCell<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		T::serialise(self, w)
	}
}

#[cfg(feature = "std")]
impl<T: Serialise> Serialise for LazyLock<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		T::serialise(self, w)
	}
}

#[cfg(feature = "alloc")]
impl<T: Serialise> Serialise for LinkedList<T> {
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.len().serialise(w)?;
		serialise_iter(self, w)
	}
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
impl Serialise for arch::__m128 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [f32; 4]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.89)]
#[expect(clippy::incompatible_msrv)]
impl Serialise for arch::__m128bh {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u16; 8]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
impl Serialise for arch::__m128d {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [f64; 2]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.94)]
#[expect(clippy::incompatible_msrv)]
impl Serialise for arch::__m128h {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		// FIXME(f16): Use `f16` instead.
		transmute::<Self, [u16; 8]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
impl Serialise for arch::__m128i {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u128; 1]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
impl Serialise for arch::__m256 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [f32; 8]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.89)]
#[expect(clippy::incompatible_msrv)]
impl Serialise for arch::__m256bh {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u16; 16]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
impl Serialise for arch::__m256d {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [f64; 4]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.94)]
#[expect(clippy::incompatible_msrv)]
impl Serialise for arch::__m256h {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		// FIXME(f16): Use `f16` instead.
		transmute::<Self, [u16; 16]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
impl Serialise for arch::__m256i {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u128; 2]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
impl Serialise for arch::__m512 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [f32; 16]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.89)]
#[expect(clippy::incompatible_msrv)]
impl Serialise for arch::__m512bh {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u16; 32]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
impl Serialise for arch::__m512d {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [f64; 8]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.94)]
#[expect(clippy::incompatible_msrv)]
impl Serialise for arch::__m512h {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		// FIXME(f16): Use `f16` instead.
		transmute::<Self, [u16; 32]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
impl Serialise for arch::__m512i {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u128; 4]>(*self).serialise(w)
	}
}

impl<T: Serialise> Serialise for ManuallyDrop<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		T::serialise(self, w)
	}
}

#[cfg(feature = "simd")]
impl<T: MaskElement + Serialise, const N: usize> Serialise for simd::Mask<T, N> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.to_array().serialise(w)
	}
}

#[cfg(feature = "std")]
impl<T: Serialise> Serialise for Mutex<T> {
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		let lock = match self.lock() {
			Ok(lock) => lock,
			Err(e)   => e.into_inner(),
		};

		T::serialise(&lock, w)
	}
}

impl Serialise for NonZero<i128> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.get().serialise(w)
	}
}

impl Serialise for NonZero<i16> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.get().serialise(w)
	}
}

impl Serialise for NonZero<i32> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.get().serialise(w)
	}
}

impl Serialise for NonZero<i64> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.get().serialise(w)
	}
}

impl Serialise for NonZero<i8> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.get().serialise(w)
	}
}

impl Serialise for NonZero<isize> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.get().serialise(w)
	}
}

impl Serialise for NonZero<u128> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.get().serialise(w)
	}
}

impl Serialise for NonZero<u16> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.get().serialise(w)
	}
}

impl Serialise for NonZero<u32> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.get().serialise(w)
	}
}

impl Serialise for NonZero<u64> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.get().serialise(w)
	}
}

impl Serialise for NonZero<u8> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.get().serialise(w)
	}
}

impl Serialise for NonZero<usize> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.get().serialise(w)
	}
}

impl<T: Serialise> Serialise for OnceCell<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.get().serialise(w)
	}
}

#[cfg(feature = "std")]
impl<T: Serialise> Serialise for OnceLock<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.get().serialise(w)
	}
}

impl<T: Serialise> Serialise for Option<T> {
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		match *self {
			None => {
				serdes::OPTION_NONE.serialise(w)?;
			}

			Some(ref value) => {
				serdes::OPTION_SOME.serialise(w)?;
				value.serialise(w)?;
			}
		}

		Ok(())
	}
}

impl Serialise for cmp::Ordering {
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		match *self {
			Self::Equal => {
				serdes::CMP_ORDERING_EQUAL.serialise(w)?;
			}

			Self::Greater => {
				serdes::CMP_ORDERING_GREATER.serialise(w)?;
			}

			Self::Less => {
				serdes::CMP_ORDERING_LESS.serialise(w)?;
			}
		}

		Ok(())
	}
}

impl<T: ?Sized> Serialise for PhantomData<T> {
	#[inline]
	fn serialise<W: Write>(&self, _w: &mut W) -> serdes::Result<()> {
		Ok(())
	}
}

impl Serialise for PhantomPinned {
	#[inline]
	fn serialise<W: Write>(&self, _w: &mut W) -> serdes::Result<()> {
		Ok(())
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::poly16x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u16; 4]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::poly16x4x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u16; 8]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::poly16x4x3_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u16; 12]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::poly16x4x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u16; 16]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::poly16x8_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u16; 8]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::poly16x8x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u16; 16]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::poly16x8x3_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u16; 24]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::poly16x8x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u16; 32]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::poly64x1_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u64; 1]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::poly64x1x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u64; 2]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::poly64x1x3_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u64; 3]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::poly64x1x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u64; 4]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::poly64x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u64; 2]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::poly64x2x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u64; 4]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::poly64x2x3_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u64; 6]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::poly64x2x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u64; 8]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::poly8x16_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u8; 16]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::poly8x16x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u8; 32]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::poly8x16x3_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u8; 48]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::poly8x16x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u8; 64]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::poly8x8_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u8; 8]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::poly8x8x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u8; 16]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::poly8x8x3_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u8; 24]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::poly8x8x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u8; 32]>(*self).serialise(w)
	}
}

impl<T: Serialise> Serialise for Range<T> {
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.start.serialise(w)?;
		self.end.serialise(w)
	}
}

impl<T: Serialise> Serialise for RangeFrom<T> {
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.start.serialise(w)
	}
}

impl Serialise for RangeFull {
	fn serialise<W: Write>(&self, _w: &mut W) -> serdes::Result<()> {
		Ok(())
	}
}

impl<T: Serialise> Serialise for RangeInclusive<T> {
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.start().serialise(w)?;
		self.end().serialise(w)
	}
}

impl<T: Serialise> Serialise for RangeTo<T> {
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.end.serialise(w)
	}
}

impl<T: Serialise> Serialise for RangeToInclusive<T> {
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.end.serialise(w)
	}
}

#[cfg(feature = "alloc")]
impl<T: ?Sized + Serialise> Serialise for Rc<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		T::serialise(self, w)
	}
}

impl<T: ?Sized + Serialise> Serialise for Ref<'_, T> {
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		T::serialise(self, w)
	}
}

// SORT: reference
impl<T: ?Sized + Serialise> Serialise for &T {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		T::serialise(self, w)
	}
}

// SORT: reference
impl<T: ?Sized + Serialise> Serialise for &mut T {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		T::serialise(self, w)
	}
}

impl<T: ?Sized + Serialise> Serialise for RefCell<T> {
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		T::serialise(&self.borrow(), w)
	}
}

impl<T: ?Sized + Serialise> Serialise for RefMut<'_, T> {
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		T::serialise(self, w)
	}
}

impl<T: Serialise, E: Serialise> Serialise for Result<T, E> {
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		match *self {
			Ok(ref value) => {
				serdes::RESULT_OK.serialise(w)?;
				value.serialise(w)?;
			}

			Err(ref e) => {
				serdes::RESULT_ERR.serialise(w)?;
				e.serialise(w)?;
			}
		}

		Ok(())
	}
}

impl<T: Serialise> Serialise for Reverse<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.0.serialise(w)
	}
}

#[cfg(feature = "std")]
impl<T: ?Sized + Serialise> Serialise for RwLock<T> {
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		let lock = match self.read() {
			Ok(lock) => lock,
			Err(e)   => e.into_inner(),
		};

		T::serialise(&lock, w)
	}
}

impl<T: Serialise> Serialise for Saturating<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.0.serialise(w)
	}
}

#[cfg(feature = "std")]
impl Serialise for Shutdown {
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		match *self {
			Self::Both => {
				serdes::SHUTDOWN_BOTH.serialise(w)?;
			}

			Self::Read => {
				serdes::SHUTDOWN_READ.serialise(w)?;
			}

			Self::Write => {
				serdes::SHUTDOWN_WRITE.serialise(w)?;
			}
		}

		Ok(())
	}
}

#[cfg(feature = "simd")]
impl<T: SimdElement + Serialise, const N: usize> Serialise for Simd<T, N> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.as_array().serialise(w)
	}
}

impl Serialise for SocketAddr {
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		match *self {
			Self::V4(addr) => {
				serdes::SOCKET_ADDR_V4.serialise(w)?;
				addr.serialise(w)?;
			}

			Self::V6(addr) => {
				serdes::SOCKET_ADDR_V6.serialise(w)?;
				addr.serialise(w)?;
			}
		}

		Ok(())
	}
}

impl Serialise for SocketAddrV4 {
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.ip().serialise(w)?;
		self.port().serialise(w)
	}
}

impl Serialise for SocketAddrV6 {
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.ip().serialise(w)?;
		self.port().serialise(w)?;
		self.flowinfo().serialise(w)?;
		self.scope_id().serialise(w)
	}
}

// SORT: slice
impl<T: Serialise> Serialise for [T] {
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.len().serialise(w)?;
		serialise_iter(self, w)
	}
}

impl Serialise for str {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.as_bytes().serialise(w)
	}
}

#[cfg(feature = "alloc")]
impl Serialise for String {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.as_str().serialise(w)
	}
}

// SORT: tuple
/// Implemented for tuples with up to twelve
/// members.
#[cfg_attr(feature = "unstable_docs", doc(fake_variadic))]
impl<T: Serialise> Serialise for (T,) {
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.0.serialise(w)
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1> Serialise for (T0, T1)
where
	T0: Serialise,
	T1: Serialise,
{
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.0.serialise(w)?;
		self.1.serialise(w)
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2> Serialise for (T0, T1, T2)
where
	T0: Serialise,
	T1: Serialise,
	T2: Serialise,
{
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.0.serialise(w)?;
		self.1.serialise(w)?;
		self.2.serialise(w)
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3> Serialise for (T0, T1, T2, T3)
where
	T0: Serialise,
	T1: Serialise,
	T2: Serialise,
	T3: Serialise,
{
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.0.serialise(w)?;
		self.1.serialise(w)?;
		self.2.serialise(w)?;
		self.3.serialise(w)
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4> Serialise for (T0, T1, T2, T3, T4)
where
	T0: Serialise,
	T1: Serialise,
	T2: Serialise,
	T3: Serialise,
	T4: Serialise,
{
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.0.serialise(w)?;
		self.1.serialise(w)?;
		self.2.serialise(w)?;
		self.3.serialise(w)?;
		self.4.serialise(w)
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5> Serialise for (T0, T1, T2, T3, T4, T5)
where
	T0: Serialise,
	T1: Serialise,
	T2: Serialise,
	T3: Serialise,
	T4: Serialise,
	T5: Serialise,
{
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.0.serialise(w)?;
		self.1.serialise(w)?;
		self.2.serialise(w)?;
		self.3.serialise(w)?;
		self.4.serialise(w)?;
		self.5.serialise(w)
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5, T6> Serialise for (T0, T1, T2, T3, T4, T5, T6)
where
	T0: Serialise,
	T1: Serialise,
	T2: Serialise,
	T3: Serialise,
	T4: Serialise,
	T5: Serialise,
	T6: Serialise,
{
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.0.serialise(w)?;
		self.1.serialise(w)?;
		self.2.serialise(w)?;
		self.3.serialise(w)?;
		self.4.serialise(w)?;
		self.5.serialise(w)?;
		self.6.serialise(w)
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5, T6, T7> Serialise for (T0, T1, T2, T3, T4, T5, T6, T7)
where
	T0: Serialise,
	T1: Serialise,
	T2: Serialise,
	T3: Serialise,
	T4: Serialise,
	T5: Serialise,
	T6: Serialise,
	T7: Serialise,
{
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.0.serialise(w)?;
		self.1.serialise(w)?;
		self.2.serialise(w)?;
		self.3.serialise(w)?;
		self.4.serialise(w)?;
		self.5.serialise(w)?;
		self.6.serialise(w)?;
		self.7.serialise(w)
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Serialise for (T0, T1, T2, T3, T4, T5, T6, T7, T8)
where
	T0: Serialise,
	T1: Serialise,
	T2: Serialise,
	T3: Serialise,
	T4: Serialise,
	T5: Serialise,
	T6: Serialise,
	T7: Serialise,
	T8: Serialise,
{
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.0.serialise(w)?;
		self.1.serialise(w)?;
		self.2.serialise(w)?;
		self.3.serialise(w)?;
		self.4.serialise(w)?;
		self.5.serialise(w)?;
		self.6.serialise(w)?;
		self.7.serialise(w)?;
		self.8.serialise(w)
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Serialise for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)
where
	T0: Serialise,
	T1: Serialise,
	T2: Serialise,
	T3: Serialise,
	T4: Serialise,
	T5: Serialise,
	T6: Serialise,
	T7: Serialise,
	T8: Serialise,
	T9: Serialise,
{
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.0.serialise(w)?;
		self.1.serialise(w)?;
		self.2.serialise(w)?;
		self.3.serialise(w)?;
		self.4.serialise(w)?;
		self.5.serialise(w)?;
		self.6.serialise(w)?;
		self.7.serialise(w)?;
		self.8.serialise(w)?;
		self.9.serialise(w)
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Serialise for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
where
	T0:  Serialise,
	T1:  Serialise,
	T2:  Serialise,
	T3:  Serialise,
	T4:  Serialise,
	T5:  Serialise,
	T6:  Serialise,
	T7:  Serialise,
	T8:  Serialise,
	T9:  Serialise,
	T10: Serialise,
{
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.0.serialise(w)?;
		self.1.serialise(w)?;
		self.2.serialise(w)?;
		self.3.serialise(w)?;
		self.4.serialise(w)?;
		self.5.serialise(w)?;
		self.6.serialise(w)?;
		self.7.serialise(w)?;
		self.8.serialise(w)?;
		self.9.serialise(w)?;
		self.10.serialise(w)
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Serialise for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
where
	T0:  Serialise,
	T1:  Serialise,
	T2:  Serialise,
	T3:  Serialise,
	T4:  Serialise,
	T5:  Serialise,
	T6:  Serialise,
	T7:  Serialise,
	T8:  Serialise,
	T9:  Serialise,
	T10: Serialise,
	T11: Serialise,
{
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.0.serialise(w)?;
		self.1.serialise(w)?;
		self.2.serialise(w)?;
		self.3.serialise(w)?;
		self.4.serialise(w)?;
		self.5.serialise(w)?;
		self.6.serialise(w)?;
		self.7.serialise(w)?;
		self.8.serialise(w)?;
		self.9.serialise(w)?;
		self.10.serialise(w)?;
		self.11.serialise(w)
	}
}

// SORT: unit
impl Serialise for () {
	#[inline]
	fn serialise<W: Write>(&self, _w: &mut W) -> serdes::Result<()> {
		Ok(())
	}
}

impl Serialise for u128 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		w.write_all(&self.to_le_bytes())
	}
}

impl Serialise for u16 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		w.write_all(&self.to_le_bytes())
	}
}

impl Serialise for u32 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		w.write_all(&self.to_le_bytes())
	}
}

impl Serialise for u64 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		w.write_all(&self.to_le_bytes())
	}
}

impl Serialise for u8 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		w.write_all(&self.to_le_bytes())
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::uint16x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u16; 4]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::uint16x4x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u16; 8]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::uint16x4x3_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u16; 12]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::uint16x4x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u16; 16]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::uint16x8_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u16; 8]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::uint16x8x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u16; 16]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::uint16x8x3_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u16; 24]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::uint16x8x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u16; 32]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::uint32x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u32; 2]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::uint32x2x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u32; 4]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::uint32x2x3_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u32; 6]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::uint32x2x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u32; 8]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::uint32x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u32; 4]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::uint32x4x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u32; 8]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::uint32x4x3_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u32; 12]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::uint32x4x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u32; 16]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::uint64x1_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u64; 1]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::uint64x1x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u64; 2]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::uint64x1x3_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u64; 3]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::uint64x1x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u64; 4]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::uint64x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u64; 2]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::uint64x2x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u64; 4]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::uint64x2x3_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u64; 6]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::uint64x2x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u64; 8]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::uint8x16_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u8; 16]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::uint8x16x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u8; 32]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::uint8x16x3_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u8; 48]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::uint8x16x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u8; 64]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::uint8x8_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u8; 8]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::uint8x8x2_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u8; 16]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::uint8x8x3_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u8; 24]>(*self).serialise(w)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Serialise for arch::uint8x8x4_t {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u8; 32]>(*self).serialise(w)
	}
}

impl<T: Copy + Serialise> Serialise for UnsafeCell<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		// SAFETY: `UnsafeCell` guarantees synchronisation
		// (via `!Sync`).
		let value = unsafe { *self.get() };

		value.serialise(w)
	}
}

impl Serialise for usize {
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		u16::try_from(*self)
			.map_err(|_| Error::invalid_input())?
			.serialise(w)
	}
}

#[cfg(target_arch = "wasm32")]
impl Serialise for arch::v128 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		transmute::<Self, [u128; 1]>(*self).serialise(w)
	}
}

#[cfg(feature = "alloc")]
impl<T: Serialise> Serialise for Vec<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.as_slice().serialise(w)
	}
}

#[cfg(feature = "alloc")]
impl<T: Serialise> Serialise for VecDeque<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.len().serialise(w)?;
		serialise_iter(self, w)
	}
}

#[cfg(feature = "alloc")]
impl<T: Serialise> Serialise for rc::Weak<T> {
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.upgrade().serialise(w)
	}
}

#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))]
impl<T: Serialise> Serialise for sync::Weak<T> {
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.upgrade().serialise(w)
	}
}

impl<T: Serialise> Serialise for Wrapping<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> serdes::Result<()> {
		self.0.serialise(w)
	}
}