oct 0.36.2

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

//! The [`Deserialise`] trait.

mod test;

use core::cell::{Cell, OnceCell, RefCell, UnsafeCell};
use core::cmp::{self, Reverse};
use core::marker::{PhantomData, PhantomPinned};
use core::mem::{ManuallyDrop, MaybeUninit};
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::transmute_unchecked;
use oct::serdes::{self, Error, Read};

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

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

#[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(feature = "alloc")]
use core::ffi::CStr;

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

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

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

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

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

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

#[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::{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 deserialised from
/// octets.
#[doc(alias = "Deserialize")]
#[doc(alias = "Decode")]
pub trait Deserialise: Sized {
	/// Deserialises an object from the provided reader.
	///
	/// # Errors
	///
	/// new function should forward any read error
	/// given by `r`. If the reader did not contain a
	/// valid serialisation of the implementing type,
	/// new method should return an [`InvalidData`]
	/// error. The state of the reader in case of error
	/// is unspecified.
	///
	/// [`InvalidData`]: Error::invalid_data
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self>;
}

/// Reads an octet array from the underlying buffer.
///
/// # Errors
///
/// new method should return an [`Err`] instance
/// if an error occurs during reading. For new
/// method specifically, new includes if the
/// underlying buffer contains less than `N` octets.
fn read_array<R: ?Sized + Read, const N: usize>(r: &mut R) -> serdes::Result<[u8; N]> {
	let mut buf = [0; N];
	r.read_exact(&mut buf)?;

	Ok(buf)
}

#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))]
impl<T: Deserialise> Deserialise for Arc<T> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		Deserialise::deserialise(r).map(Self::new)
	}
}

#[cfg(all(feature = "alloc", target_has_atomic = "ptr", feature = "bstr"))]
impl Deserialise for Arc<ByteStr> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		Box::deserialise(r).map(Into::into)
	}
}

#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))]
impl Deserialise for Arc<CStr> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		Box::deserialise(r).map(Into::into)
	}
}

#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))]
impl<T: Deserialise> Deserialise for Arc<[T]> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		Box::deserialise(r).map(Into::into)
	}
}

#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))]
impl Deserialise for Arc<str> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		Box::deserialise(r).map(Into::into)
	}
}

// SORT: array
impl<T: Deserialise, const N: usize> Deserialise for [T; N] {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let mut new = [const { MaybeUninit::<T>::uninit() }; N];

		for slot in &mut new {
			slot.write(T::deserialise(r)?);
		}

		// SAFETY: All items have been initialised.
		let new = unsafe { transmute_unchecked(new) };
		Ok(new)
	}
}

#[cfg(target_has_atomic = "8")]
impl Deserialise for AtomicBool {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		bool::deserialise(r).map(Self::new)
	}
}

#[cfg(all(target_has_atomic = "128", feature = "atomic_u128_i128"))]
impl Deserialise for AtomicI128 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		i128::deserialise(r).map(Self::new)
	}
}

#[cfg(target_has_atomic = "16")]
impl Deserialise for AtomicI16 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		i16::deserialise(r).map(Self::new)
	}
}

#[cfg(target_has_atomic = "32")]
impl Deserialise for AtomicI32 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		i32::deserialise(r).map(Self::new)
	}
}

#[cfg(target_has_atomic = "64")]
impl Deserialise for AtomicI64 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		i64::deserialise(r).map(Self::new)
	}
}

#[cfg(target_has_atomic = "8")]
impl Deserialise for AtomicI8 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		i8::deserialise(r).map(Self::new)
	}
}

#[cfg(target_has_atomic = "ptr")]
impl Deserialise for AtomicIsize {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		isize::deserialise(r).map(Self::new)
	}
}

#[cfg(all(target_has_atomic = "128", feature = "atomic_u128_i128"))]
impl Deserialise for AtomicU128 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		u128::deserialise(r).map(Self::new)
	}
}

#[cfg(target_has_atomic = "16")]
impl Deserialise for AtomicU16 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		u16::deserialise(r).map(Self::new)
	}
}

#[cfg(target_has_atomic = "32")]
impl Deserialise for AtomicU32 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		u32::deserialise(r).map(Self::new)
	}
}

#[cfg(target_has_atomic = "64")]
impl Deserialise for AtomicU64 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		u64::deserialise(r).map(Self::new)
	}
}

#[cfg(target_has_atomic = "8")]
impl Deserialise for AtomicU8 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		u8::deserialise(r).map(Self::new)
	}
}

#[cfg(target_has_atomic = "ptr")]
impl Deserialise for AtomicUsize {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		usize::deserialise(r).map(Self::new)
	}
}

#[cfg(feature = "alloc")]
impl<T: Ord + Deserialise> Deserialise for BinaryHeap<T> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let v = Vec::<T>::deserialise(r)?;
		Ok(v.into())
	}
}

impl Deserialise for bool {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		const FALSE: u8 = false as u8;
		const TRUE:  u8 = true as u8;

		let value = u8::deserialise(r)?;

		match value {
			FALSE => Ok(false),
			TRUE  => Ok(true),
			_     => Err(Error::invalid_data()),
		}
	}
}

impl<T: Deserialise> Deserialise for Bound<T> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let discriminant = Deserialise::deserialise(r)?;

		match discriminant {
			serdes::BOUND_INCLUDED => {
				let bound = T::deserialise(r)?;
				Ok(Self::Included(bound))
			}

			serdes::BOUND_EXCLUDED => {
				let bound = T::deserialise(r)?;
				Ok(Self::Excluded(bound))
			}

			serdes::BOUND_UNBOUNDED => {
				Ok(Self::Unbounded)
			}

			_ => Err(Error::invalid_data()),
		}
	}
}

#[cfg(feature = "alloc")]
impl<T: Deserialise> Deserialise for Box<T> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		Deserialise::deserialise(r).map(Self::new)
	}
}

#[cfg(all(feature = "alloc", feature = "bstr"))]
impl Deserialise for Box<ByteStr> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		// FIXME(bstr): Use
		// `<ByteStr as Into<Box<ByteStr>>>::into` when
		// possible.

		let buf = ByteString::deserialise(r)?.0.into_boxed_slice();

		let s = {
			// SAFETY: `ByteStr` is fully compatible with
			// `[u8]`.
			let raw = Box::into_raw(buf) as *mut ByteStr;

			unsafe { Self::from_raw(raw) }
		};

		Ok(s)
	}
}

#[cfg(feature = "alloc")]
impl Deserialise for Box<CStr> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		CString::deserialise(r).map(Into::into)
	}
}

#[cfg(feature = "alloc")]
impl<T: Deserialise> Deserialise for Box<[T]> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		Vec::deserialise(r).map(Into::into)
	}
}

#[cfg(feature = "alloc")]
impl Deserialise for Box<str> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		String::deserialise(r).map(Into::into)
	}
}

#[cfg(all(feature = "alloc", feature = "bstr"))]
impl Deserialise for ByteString {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let len = usize::deserialise(r)?;

		let mut buf = vec![0_u8; len];
		r.read_exact(&mut buf)?;

		Ok(Self(buf))
	}
}

#[cfg(feature = "alloc")]
impl Deserialise for CString {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let len = usize::deserialise(r)?;

		let mut v = vec![0_u8; len + 1];
		r.read_exact(&mut v[..len])?;

		// SAFETY: We initially allocated the nul termina-
		// tor.
		let s = unsafe { Self::from_vec_with_nul_unchecked(v) };

		Ok(s)
	}
}

impl<T: Deserialise> Deserialise for Cell<T> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		T::deserialise(r).map(Into::into)
	}
}

impl Deserialise for char {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let value = u32::deserialise(r)?;
		value.try_into().ok().ok_or_else(Error::invalid_data)
	}
}

#[cfg(feature = "ascii")]
impl Deserialise for ascii::Char {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Self::from_u8(value).ok_or_else(Error::invalid_data)
	}
}

#[cfg(feature = "alloc")]
impl<B: ?Sized + ToOwned<Owned: Deserialise>> Deserialise for Cow<'_, B> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		Deserialise::deserialise(r).map(Self::Owned)
	}
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
impl Deserialise for arch::CpuidResult {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let eax = Deserialise::deserialise(r)?;
		let ebx = Deserialise::deserialise(r)?;
		let ecx = Deserialise::deserialise(r)?;
		let edx = Deserialise::deserialise(r)?;
		Ok(Self { eax, ebx, ecx, edx })
	}
}

#[cfg(feature = "std")]
impl<T: Deserialise> Deserialise for Cursor<T> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let position = Deserialise::deserialise(r)?;
		let inner    = Deserialise::deserialise(r)?;

		let mut new = Self::new(inner);
		new.set_position(position);

		Ok(new)
	}
}

impl Deserialise for Duration {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let secs         = Deserialise::deserialise(r)?;
		let subsec_nanos = Deserialise::deserialise(r)?;
		Ok(Self::new(secs, subsec_nanos))
	}
}

#[cfg(feature = "f16")]
impl Deserialise for f16 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		read_array(r).map(Self::from_le_bytes)
	}
}

impl Deserialise for f32 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		read_array(r).map(Self::from_le_bytes)
	}
}

impl Deserialise for f64 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		read_array(r).map(Self::from_le_bytes)
	}
}

#[cfg(feature = "f128")]
impl Deserialise for f128 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		read_array(r).map(Self::from_le_bytes)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
impl Deserialise for arch::float16x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;

		// FIXME(f16): Use `f16` instead.
		Ok(transmute::<[u16; 4], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
impl Deserialise for arch::float16x4x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;

		// FIXME(f16): Use `f16` instead.
		Ok(transmute::<[u16; 8], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
impl Deserialise for arch::float16x4x3_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;

		// FIXME(f16): Use `f16` instead.
		Ok(transmute::<[u16; 12], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
impl Deserialise for arch::float16x4x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;

		// FIXME(f16): Use `f16` instead.
		Ok(transmute::<[u16; 16], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
impl Deserialise for arch::float16x8_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;

		// FIXME(f16): Use `f16` instead.
		Ok(transmute::<[u16; 8], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
impl Deserialise for arch::float16x8x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;

		// FIXME(f16): Use `f16` instead.
		Ok(transmute::<[u16; 16], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
impl Deserialise for arch::float16x8x3_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;

		// FIXME(f16): Use `f16` instead.
		Ok(transmute::<[u16; 24], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
impl Deserialise for arch::float16x8x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;

		// FIXME(f16): Use `f16` instead.
		Ok(transmute::<[u16; 32], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::float32x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[f32; 64], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::float32x2x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[f32; 128], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::float32x2x3_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[f32; 192], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::float32x2x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[f32; 256], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::float32x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[f32; 4], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::float32x4x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[f32; 8], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::float32x4x3_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[f32; 12], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::float32x4x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[f32; 16], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
impl Deserialise for arch::float64x1_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[f64; 1], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
impl Deserialise for arch::float64x1x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[f64; 2], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
impl Deserialise for arch::float64x1x3_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[f64; 3], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
impl Deserialise for arch::float64x1x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[f64; 4], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
impl Deserialise for arch::float64x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[f64; 2], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
impl Deserialise for arch::float64x2x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[f64; 4], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
impl Deserialise for arch::float64x2x3_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[f64; 6], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
impl Deserialise for arch::float64x2x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[f64; 8], Self>(data))
	}
}

#[cfg(feature = "std")]
impl<K: Eq + Hash + Deserialise, V: Deserialise, S: Default + BuildHasher> Deserialise for HashMap<K, V, S> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let len = usize::deserialise(r)?;

		let mut new = Self::with_hasher(Default::default());

		for _ in 0..len {
			let key  = Deserialise::deserialise(r)?;
			let value = Deserialise::deserialise(r)?;

			new.insert(key, value);
		}

		Ok(new)
	}
}

#[cfg(feature = "std")]
impl<T: Eq + Hash + Deserialise, S: BuildHasher + Default> Deserialise for HashSet<T, S> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let len = usize::deserialise(r)?;

		let mut new = Self::with_hasher(Default::default());

		for _ in 0..len {
			let key = Deserialise::deserialise(r)?;
			new.insert(key);
		}

		Ok(new)
	}
}

impl Deserialise for i128 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		read_array(r).map(Self::from_le_bytes)
	}
}

impl Deserialise for i16 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		read_array(r).map(Self::from_le_bytes)
	}
}

impl Deserialise for i32 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		read_array(r).map(Self::from_le_bytes)
	}
}

impl Deserialise for i64 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		read_array(r).map(Self::from_le_bytes)
	}
}

impl Deserialise for i8 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		read_array(r).map(Self::from_le_bytes)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::int16x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[i16; 4], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::int16x4x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[i16; 8], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::int16x4x3_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[i16; 12], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::int16x4x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[i16; 16], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::int16x8_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[i16; 8], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::int16x8x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[i16; 16], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::int16x8x3_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[i16; 24], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::int16x8x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[i16; 32], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::int32x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[i32; 2], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::int32x2x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[i32; 4], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::int32x2x3_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[i32; 6], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::int32x2x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[i32; 8], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::int32x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[i32; 4], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::int32x4x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[i32; 8], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::int32x4x3_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[i32; 12], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::int32x4x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[i32; 16], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::int64x1_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[i64; 1], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::int64x1x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[i64; 2], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::int64x1x3_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[i64; 3], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::int64x1x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[i64; 4], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::int64x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[i64; 2], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::int64x2x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[i64; 4], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::int64x2x3_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[i64; 6], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::int64x2x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[i64; 8], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::int8x16_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[i8; 16], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::int8x16x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[i8; 32], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::int8x16x3_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[i8; 48], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::int8x16x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[i8; 64], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::int8x8_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[i8; 8], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::int8x8x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[i8; 16], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::int8x8x3_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[i8; 24], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::int8x8x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[i8; 32], Self>(data))
	}
}

impl Deserialise for IpAddr {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let discriminant = Deserialise::deserialise(r)?;

		match discriminant {
			serdes::IP_ADDR_V4 => {
				let addr = Deserialise::deserialise(r)?;
				Ok(Self::V4(addr))
			}

			serdes::IP_ADDR_V6 => {
				let addr = Deserialise::deserialise(r)?;
				Ok(Self::V6(addr))
			}

			_ => Err(Error::invalid_data()),
		}
	}
}

impl Deserialise for Ipv4Addr {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		Deserialise::deserialise(r).map(Self::from_bits)
	}
}

impl Deserialise for Ipv6Addr {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		Deserialise::deserialise(r).map(Self::from_bits)
	}
}

impl Deserialise for isize {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let value = i16::deserialise(r)?;
		Ok(value.into())
	}
}

#[cfg(feature = "alloc")]
impl<T: Deserialise> Deserialise for LinkedList<T> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let len = usize::deserialise(r)?;

		let mut new = Self::new();

		for _ in 0..len {
			let item = Deserialise::deserialise(r)?;
			new.push_back(item);
		}

		Ok(new)
	}
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
impl Deserialise for arch::__m128 {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[f32; 4], Self>(data))
	}
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.89)]
#[expect(clippy::incompatible_msrv)]
impl Deserialise for arch::__m128bh {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u16; 8], Self>(data))
	}
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
impl Deserialise for arch::__m128d {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[f64; 2], Self>(data))
	}
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.94)]
#[expect(clippy::incompatible_msrv)]
impl Deserialise for arch::__m128h {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;

		// FIXME(f16): Use `f16` instead.
		Ok(transmute::<[u16; 8], Self>(data))
	}
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
impl Deserialise for arch::__m128i {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u128; 1], Self>(data))
	}
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
impl Deserialise for arch::__m256 {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[f32; 8], Self>(data))
	}
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.89)]
#[expect(clippy::incompatible_msrv)]
impl Deserialise for arch::__m256bh {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u16; 16], Self>(data))
	}
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
impl Deserialise for arch::__m256d {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[f64; 4], Self>(data))
	}
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.94)]
#[expect(clippy::incompatible_msrv)]
impl Deserialise for arch::__m256h {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;

		// FIXME(f16): Use `f16` instead.
		Ok(transmute::<[u16; 16], Self>(data))
	}
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
impl Deserialise for arch::__m256i {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u128; 2], Self>(data))
	}
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
impl Deserialise for arch::__m512 {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[f32; 16], Self>(data))
	}
}

#[cfg(
	all(
		any(
			target_arch = "x86",
			target_arch = "x86_64",
		),
		feature = "f16",
	),
)]
#[rustversion::since(1.89)]
#[expect(clippy::incompatible_msrv)]
impl Deserialise for arch::__m512bh {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u16; 32], Self>(data))
	}
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
impl Deserialise for arch::__m512d {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[f64; 8], Self>(data))
	}
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.94)]
#[expect(clippy::incompatible_msrv)]
impl Deserialise for arch::__m512h {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;

		// FIXME(f16): Use `f16` instead.
		Ok(transmute::<[u16; 32], Self>(data))
	}
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
impl Deserialise for arch::__m512i {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u128; 4], Self>(data))
	}
}

impl<T: Deserialise> Deserialise for ManuallyDrop<T> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		T::deserialise(r).map(Self::new)
	}
}

#[cfg(feature = "simd")]
impl<T: MaskElement + Deserialise, const N: usize> Deserialise for simd::Mask<T, N> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		Deserialise::deserialise(r).map(Self::from_array)
	}
}

impl<T: Deserialise> Deserialise for MaybeUninit<T> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		T::deserialise(r).map(Self::new)
	}
}

#[cfg(feature = "std")]
impl<T: Deserialise> Deserialise for Mutex<T> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		Deserialise::deserialise(r).map(Self::new)
	}
}

impl Deserialise for NonZero<i128> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Self::new(value).ok_or_else(Error::invalid_data)
	}
}

impl Deserialise for NonZero<i16> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Self::new(value).ok_or_else(Error::invalid_data)
	}
}

impl Deserialise for NonZero<i32> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Self::new(value).ok_or_else(Error::invalid_data)
	}
}

impl Deserialise for NonZero<i64> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Self::new(value).ok_or_else(Error::invalid_data)
	}
}

impl Deserialise for NonZero<i8> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Self::new(value).ok_or_else(Error::invalid_data)
	}
}

impl Deserialise for NonZero<isize> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Self::new(value).ok_or_else(Error::invalid_data)
	}
}

impl Deserialise for NonZero<u128> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Self::new(value).ok_or_else(Error::invalid_data)
	}
}

impl Deserialise for NonZero<u16> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Self::new(value).ok_or_else(Error::invalid_data)
	}
}

impl Deserialise for NonZero<u32> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Self::new(value).ok_or_else(Error::invalid_data)
	}
}

impl Deserialise for NonZero<u64> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Self::new(value).ok_or_else(Error::invalid_data)
	}
}

impl Deserialise for NonZero<u8> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Self::new(value).ok_or_else(Error::invalid_data)
	}
}

impl Deserialise for NonZero<usize> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Self::new(value).ok_or_else(Error::invalid_data)
	}
}

impl<T: Deserialise> Deserialise for OnceCell<T> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let new = Option::<T>::deserialise(r)?
			.map(Self::from)
			.unwrap_or_default();

		Ok(new)
	}
}

#[cfg(feature = "std")]
impl<T: Deserialise> Deserialise for OnceLock<T> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let value = Option::<T>::deserialise(r)?;

		let new = value.map(Into::into).unwrap_or_default();
		Ok(new)
	}
}

impl<T: Deserialise> Deserialise for Option<T> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let discriminant = Deserialise::deserialise(r)?;

		match discriminant {
			serdes::OPTION_NONE => {
				Ok(None)
			}

			serdes::OPTION_SOME => {
				let value = Deserialise::deserialise(r)?;
				Ok(Some(value))
			}

			_ => Err(Error::invalid_data()),
		}
	}
}

impl Deserialise for cmp::Ordering {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let discriminant = Deserialise::deserialise(r)?;

		match discriminant {
			serdes::CMP_ORDERING_EQUAL => {
				Ok(Self::Equal)
			}

			serdes::CMP_ORDERING_GREATER => {
				Ok(Self::Greater)
			}

			serdes::CMP_ORDERING_LESS => {
				Ok(Self::Less)
			}

			_ => Err(Error::invalid_data()),
		}
	}
}

impl<T: ?Sized> Deserialise for PhantomData<T> {
	fn deserialise<R: Read>(_r: &mut R) -> serdes::Result<Self> {
		Ok(Self)
	}
}

impl Deserialise for PhantomPinned {
	fn deserialise<R: Read>(_r: &mut R) -> serdes::Result<Self> {
		Ok(Self)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::poly16x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u16; 4], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::poly16x4x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u16; 8], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::poly16x4x3_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u16; 12], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::poly16x4x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u16; 16], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::poly16x8_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u16; 8], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::poly16x8x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u16; 16], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::poly16x8x3_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u16; 24], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::poly16x8x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u16; 32], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::poly64x1_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u64; 1], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::poly64x1x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u64; 2], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::poly64x1x3_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u64; 3], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::poly64x1x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u64; 4], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::poly64x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u64; 2], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::poly64x2x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u64; 4], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::poly64x2x3_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u64; 6], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::poly64x2x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u64; 8], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::poly8x16_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u8; 16], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::poly8x16x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u8; 32], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::poly8x16x3_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u8; 48], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::poly8x16x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u8; 64], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::poly8x8_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u8; 8], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::poly8x8x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u8; 16], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::poly8x8x3_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u8; 24], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::poly8x8x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u8; 32], Self>(data))
	}
}

impl<T: Deserialise> Deserialise for Range<T> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let start = Deserialise::deserialise(r)?;
		let end   = Deserialise::deserialise(r)?;

		Ok(start..end)
	}
}

impl<T: Deserialise> Deserialise for RangeFrom<T> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let start = Deserialise::deserialise(r)?;
		Ok(start..)
	}
}

impl Deserialise for RangeFull {
	fn deserialise<R: Read>(_r: &mut R) -> serdes::Result<Self> {
		Ok(..)
	}
}

impl<T: Deserialise> Deserialise for RangeInclusive<T> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let start = Deserialise::deserialise(r)?;
		let end   = Deserialise::deserialise(r)?;

		Ok(start..=end)
	}
}

impl<T: Deserialise> Deserialise for RangeTo<T> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let end = Deserialise::deserialise(r)?;
		Ok(..end)
	}
}

impl<T: Deserialise> Deserialise for RangeToInclusive<T> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let end = Deserialise::deserialise(r)?;
		Ok(..=end)
	}
}

#[cfg(feature = "alloc")]
impl<T: Deserialise> Deserialise for Rc<T> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		Deserialise::deserialise(r).map(Self::new)
	}
}

#[cfg(all(feature = "alloc", feature = "bstr"))]
impl Deserialise for Rc<ByteStr> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		Box::deserialise(r).map(Into::into)
	}
}

#[cfg(feature = "alloc")]
impl Deserialise for Rc<CStr> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		Box::deserialise(r).map(Into::into)
	}
}

#[cfg(feature = "alloc")]
impl<T: Deserialise> Deserialise for Rc<[T]> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		Box::deserialise(r).map(Into::into)
	}
}

#[cfg(feature = "alloc")]
impl Deserialise for Rc<str> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		Box::deserialise(r).map(Into::into)
	}
}

impl<T: Deserialise> Deserialise for RefCell<T> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		T::deserialise(r).map(Into::into)
	}
}

impl<T: Deserialise, E: Deserialise> Deserialise for Result<T, E> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let discriminant = Deserialise::deserialise(r)?;

		match discriminant {
			serdes::RESULT_OK => {
				let value = Deserialise::deserialise(r)?;
				Ok(Ok(value))
			}

			serdes::RESULT_ERR => {
				let e = Deserialise::deserialise(r)?;
				Ok(Err(e))
			}

			_ => Err(Error::invalid_data())
		}
	}
}

impl<T: Deserialise> Deserialise for Reverse<T> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		Deserialise::deserialise(r).map(Self)
	}
}

#[cfg(feature = "std")]
impl<T: Deserialise> Deserialise for RwLock<T> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		Deserialise::deserialise(r).map(Self::new)
	}
}

impl<T: Deserialise> Deserialise for Saturating<T> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		Deserialise::deserialise(r).map(Self)
	}
}

#[cfg(feature = "std")]
impl Deserialise for Shutdown {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let discriminant = Deserialise::deserialise(r)?;

		match discriminant {
			serdes::SHUTDOWN_BOTH => {
				Ok(Self::Both)
			}

			serdes::SHUTDOWN_READ => {
				Ok(Self::Read)
			}

			serdes::SHUTDOWN_WRITE => {
				Ok(Self::Write)
			}

			_ => {
				Err(Error::invalid_data())
			}
		}
	}
}

#[cfg(feature = "simd")]
impl<T: SimdElement + Deserialise, const N: usize> Deserialise for Simd<T, N> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		<[T; N]>::deserialise(r).map(Into::into)
	}
}

impl Deserialise for SocketAddr {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let discriminant = Deserialise::deserialise(r)?;

		match discriminant {
			serdes::SOCKET_ADDR_V4 => {
				let addr = Deserialise::deserialise(r)?;
				Ok(Self::V4(addr))
			}

			serdes::SOCKET_ADDR_V6 => {
				let addr = Deserialise::deserialise(r)?;
				Ok(Self::V6(addr))
			}

			_ => Err(Error::invalid_data()),
		}
	}
}

impl Deserialise for SocketAddrV4 {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let ip   = Deserialise::deserialise(r)?;
		let port = Deserialise::deserialise(r)?;

		Ok(Self::new(ip, port))
	}
}

impl Deserialise for SocketAddrV6 {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let ip       = Deserialise::deserialise(r)?;
		let port     = Deserialise::deserialise(r)?;
		let flowinfo = Deserialise::deserialise(r)?;
		let scope_id = Deserialise::deserialise(r)?;

		Ok(Self::new(ip, port, flowinfo, scope_id))
	}
}

#[cfg(feature = "alloc")]
impl Deserialise for String {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let len = usize::deserialise(r)?;

		let mut v = vec![0; len];
		r.read_exact(&mut v)?;

		Self::from_utf8(v).ok().ok_or_else(Error::invalid_data)
	}
}

// SORT: tuple
/// Implemented for tuples with up to twelve
/// members.
#[cfg_attr(feature = "unstable_docs", doc(fake_variadic))]
impl<T: Deserialise> Deserialise for (T,) {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		Ok((
			Deserialise::deserialise(r)?,
		))
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1> Deserialise for (T0, T1)
where
	T0: Deserialise,
	T1: Deserialise,
{
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		Ok((
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
		))
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2> Deserialise for (T0, T1, T2)
where
	T0: Deserialise,
	T1: Deserialise,
	T2: Deserialise,
{
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		Ok((
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
		))
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3> Deserialise for (T0, T1, T2, T3)
where
	T0: Deserialise,
	T1: Deserialise,
	T2: Deserialise,
	T3: Deserialise,
{
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		Ok((
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
		))
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4> Deserialise for (T0, T1, T2, T3, T4)
where
	T0: Deserialise,
	T1: Deserialise,
	T2: Deserialise,
	T3: Deserialise,
	T4: Deserialise,
{
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		Ok((
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
		))
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5> Deserialise for (T0, T1, T2, T3, T4, T5)
where
	T0: Deserialise,
	T1: Deserialise,
	T2: Deserialise,
	T3: Deserialise,
	T4: Deserialise,
	T5: Deserialise,
{
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		Ok((
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
		))
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5, T6> Deserialise for (T0, T1, T2, T3, T4, T5, T6)
where
	T0: Deserialise,
	T1: Deserialise,
	T2: Deserialise,
	T3: Deserialise,
	T4: Deserialise,
	T5: Deserialise,
	T6: Deserialise,
{
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		Ok((
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
		))
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5, T6, T7> Deserialise for (T0, T1, T2, T3, T4, T5, T6, T7)
where
	T0: Deserialise,
	T1: Deserialise,
	T2: Deserialise,
	T3: Deserialise,
	T4: Deserialise,
	T5: Deserialise,
	T6: Deserialise,
	T7: Deserialise,
{
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		Ok((
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
		))
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Deserialise for (T0, T1, T2, T3, T4, T5, T6, T7, T8)
where
	T0: Deserialise,
	T1: Deserialise,
	T2: Deserialise,
	T3: Deserialise,
	T4: Deserialise,
	T5: Deserialise,
	T6: Deserialise,
	T7: Deserialise,
	T8: Deserialise,
{
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		Ok((
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
		))
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Deserialise for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)
where
	T0: Deserialise,
	T1: Deserialise,
	T2: Deserialise,
	T3: Deserialise,
	T4: Deserialise,
	T5: Deserialise,
	T6: Deserialise,
	T7: Deserialise,
	T8: Deserialise,
	T9: Deserialise,
{
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		Ok((
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
		))
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Deserialise for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
where
	T0:  Deserialise,
	T1:  Deserialise,
	T2:  Deserialise,
	T3:  Deserialise,
	T4:  Deserialise,
	T5:  Deserialise,
	T6:  Deserialise,
	T7:  Deserialise,
	T8:  Deserialise,
	T9:  Deserialise,
	T10: Deserialise,
{
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		Ok((
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
		))
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Deserialise for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
where
	T0:  Deserialise,
	T1:  Deserialise,
	T2:  Deserialise,
	T3:  Deserialise,
	T4:  Deserialise,
	T5:  Deserialise,
	T6:  Deserialise,
	T7:  Deserialise,
	T8:  Deserialise,
	T9:  Deserialise,
	T10: Deserialise,
	T11: Deserialise,
{
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		Ok((
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
		))
	}
}

// SORT: unit
impl Deserialise for () {
	#[inline]
	fn deserialise<R: Read>(_r: &mut R) -> serdes::Result<Self> {
		Ok(())
	}
}

impl Deserialise for u128 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		read_array(r).map(Self::from_le_bytes)
	}
}

impl Deserialise for u16 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		read_array(r).map(Self::from_le_bytes)
	}
}

impl Deserialise for u32 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		read_array(r).map(Self::from_le_bytes)
	}
}

impl Deserialise for u64 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		read_array(r).map(Self::from_le_bytes)
	}
}

impl Deserialise for u8 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		read_array(r).map(Self::from_le_bytes)
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::uint16x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u16; 4], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::uint16x4x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u16; 8], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::uint16x4x3_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u16; 12], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::uint16x4x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u16; 16], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::uint16x8_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u16; 8], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::uint16x8x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u16; 16], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::uint16x8x3_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u16; 24], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::uint16x8x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u16; 32], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::uint32x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u32; 2], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::uint32x2x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u32; 4], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::uint32x2x3_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u32; 6], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::uint32x2x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u32; 8], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::uint32x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u32; 4], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::uint32x4x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u32; 8], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::uint32x4x3_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u32; 12], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::uint32x4x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u32; 16], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::uint64x1_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u64; 1], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::uint64x1x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u64; 2], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::uint64x1x3_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u64; 3], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::uint64x1x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u64; 4], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::uint64x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u64; 2], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::uint64x2x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u64; 4], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::uint64x2x3_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u64; 6], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::uint64x2x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u64; 8], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::uint8x16_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u8; 16], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::uint8x16x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u8; 32], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::uint8x16x3_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u8; 48], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::uint8x16x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u8; 64], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::uint8x8_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u8; 8], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::uint8x8x2_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u8; 16], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::uint8x8x3_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u8; 24], Self>(data))
	}
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl Deserialise for arch::uint8x8x4_t {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u8; 32], Self>(data))
	}
}

impl<T: Deserialise> Deserialise for UnsafeCell<T> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		T::deserialise(r).map(Into::into)
	}
}

impl Deserialise for usize {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let value = u16::deserialise(r)?;
		Ok(value.into())
	}
}

#[cfg(target_arch = "wasm32")]
impl Deserialise for arch::v128 {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let data = Deserialise::deserialise(r)?;
		Ok(transmute::<[u128; 1], Self>(data))
	}
}

#[cfg(feature = "alloc")]
impl<T: Deserialise> Deserialise for Vec<T> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let len = usize::deserialise(r)?;

		let mut v = Self::with_capacity(len);

		for _ in 0..len {
			let item = Deserialise::deserialise(r)?;
			v.push(item);
		}

		Ok(v)
	}
}

#[cfg(feature = "alloc")]
impl<T: Deserialise> Deserialise for VecDeque<T> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let len = usize::deserialise(r)?;

		let mut v = Self::with_capacity(len);

		for _ in 0..len {
			let item = Deserialise::deserialise(r)?;
			v.push_back(item);
		}

		Ok(v)
	}
}

#[cfg(feature = "alloc")]
impl<T: Deserialise> Deserialise for rc::Weak<T> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		// Deserialise the value and drop it immediately.

		let _ = Option::<T>::deserialise(r)?;

		let new = Self::new();
		Ok(new)
	}
}

#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))]
impl<T: Deserialise> Deserialise for sync::Weak<T> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		// Deserialise the value and drop it immediately.

		let _ = Option::<T>::deserialise(r)?;

		let new = Self::new();
		Ok(new)
	}
}

impl<T: Deserialise> Deserialise for Wrapping<T> {
	fn deserialise<R: Read>(r: &mut R) -> serdes::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Ok(Self(value))
	}
}