primitives/types/heap_array/

array.rs

use std::{
    fmt::{Debug, Display},
    marker::PhantomData,
    mem::{ManuallyDrop, MaybeUninit},
    ops::{Add, Mul, Sub},
    sync::Arc,
    vec,
};

use bytemuck::{box_bytes_of, from_box_bytes, BoxBytes, Pod};
use derive_more::derive::{AsMut, AsRef, Deref, DerefMut, IntoIterator};
use hybrid_array::{Array, ArraySize};
use rayon::iter::{FromParallelIterator, IntoParallelIterator, ParallelIterator};
use serde::{Deserialize, Serialize};
use typenum::{Diff, Prod, Sum, Unsigned, U1, U2, U3, U5};
use wincode::{
    io::{Reader, Writer},
    ReadResult,
    SchemaRead,
    SchemaWrite,
    TypeMeta,
    WriteResult,
};

use crate::{errors::PrimitiveError, types::Positive};

/// An array on the heap that encodes its length in the type system.
#[derive(Deref, DerefMut, Clone, IntoIterator, AsRef, AsMut, Eq)]
#[into_iterator(owned, ref, ref_mut)]
pub struct HeapArray<T: Sized, M: Positive> {
    #[deref]
    #[deref_mut]
    #[as_ref(forward)]
    #[as_mut(forward)]
    pub(super) data: Box<[T]>,
    #[into_iterator(ignore)]
    // `fn() -> M` is used instead of `M` so `HeapArray<T, M>` doesn't need `M` to implement `Send
    // + Sync` to be `Send + Sync` itself. This would be the case if `M` was used directly.
    pub(super) _len: PhantomData<fn() -> M>,
}

impl<T: Sized, M: Positive> HeapArray<T, M> {
    pub(super) fn new(data: Box<[T]>) -> Self {
        Self {
            data,
            _len: PhantomData,
        }
    }
}

impl<T: Sized, M: Positive> HeapArray<T, M> {
    /// Zero-copy cast from a `#[repr(transparent)]` wrapper to its inner type.
    pub fn peel_transparent<U>(self) -> HeapArray<U, M>
    where
        T: bytemuck::TransparentWrapper<U>,
    {
        use bytemuck::allocation::TransparentWrapperAlloc;
        HeapArray::new(T::peel_vec(self.data.into_vec()).into_boxed_slice())
    }

    /// Zero-copy cast from a type to its `#[repr(transparent)]` wrapper.
    pub fn wrap_transparent<W>(self) -> HeapArray<W, M>
    where
        W: bytemuck::TransparentWrapper<T>,
    {
        use bytemuck::allocation::TransparentWrapperAlloc;
        HeapArray::new(W::wrap_vec(self.data.into_vec()).into_boxed_slice())
    }
}

// bytemuck::BoxBytes transformation for copy-less casting
impl<T: Pod, M: Positive> HeapArray<T, M> {
    pub fn into_box_bytes(self) -> BoxBytes {
        box_bytes_of(self.data)
    }

    pub fn from_box_bytes(buf: BoxBytes) -> Self {
        Self {
            data: from_box_bytes(buf),
            _len: PhantomData,
        }
    }
}

impl<T: Sized, M: Positive> HeapArray<T, M> {
    pub fn map<F, U>(self, f: F) -> HeapArray<U, M>
    where
        F: FnMut(T) -> U,
    {
        self.into_iter().map(f).collect()
    }

    /// Destructure into a fixed-size array `[T; K]`.
    ///
    /// `K` is inferred from the destructuring pattern at the call site
    /// (e.g. `let [a, b, c] = ha.into_array();` fixes `K = 3`). A mismatch
    /// between `K` and `M::USIZE` is a compile-time error.
    pub fn into_array<const K: usize>(self) -> [T; K] {
        const {
            assert!(
                M::USIZE == K,
                "HeapArray length does not match destructured array length",
            );
        }
        // SAFETY: the const assert above proves `self.data.len() == M::USIZE == K`,
        // and `Box<[T]>` with length `K` has the same layout as `Box<[T; K]>`.
        let raw: *mut [T] = Box::into_raw(self.data);
        unsafe { *Box::from_raw(raw.cast::<[T; K]>()) }
    }
}

impl<T: Sized + Default, M: Positive> HeapArray<T, M> {
    pub fn from_single_value(val: T) -> Self {
        Self {
            data: vec![val].into_boxed_slice(),
            _len: PhantomData,
        }
    }
}

impl<T: Sized + Default, M: Positive> Default for HeapArray<T, M> {
    fn default() -> Self {
        Self {
            data: (0..M::USIZE).map(|_| T::default()).collect(),
            _len: PhantomData,
        }
    }
}

impl<T: Sized + Debug, M: Positive> Debug for HeapArray<T, M> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct(format!("HeapArray<{}>", M::USIZE).as_str())
            .field("data", &self.data)
            .finish()
    }
}

impl<T: Sized + Serialize, M: Positive> Serialize for HeapArray<T, M> {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        use serde::ser::SerializeTuple;
        let mut tuple = serializer.serialize_tuple(M::USIZE)?;
        for element in self.data.iter() {
            tuple.serialize_element(element)?;
        }
        tuple.end()
    }
}

impl<'de, T: Sized + Deserialize<'de>, M: Positive> Deserialize<'de> for HeapArray<T, M> {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        struct HeapArrayVisitor<T, M: Positive> {
            _phantom: PhantomData<(T, M)>,
        }

        impl<'de, T: Deserialize<'de>, M: Positive> serde::de::Visitor<'de> for HeapArrayVisitor<T, M> {
            type Value = HeapArray<T, M>;

            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                write!(formatter, "a tuple of {} elements", M::USIZE)
            }

            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
            where
                A: serde::de::SeqAccess<'de>,
            {
                let mut data = Vec::with_capacity(M::USIZE);
                for i in 0..M::USIZE {
                    let element = seq
                        .next_element()?
                        .ok_or_else(|| serde::de::Error::invalid_length(i, &self))?;
                    data.push(element);
                }

                Ok(HeapArray {
                    data: data.into_boxed_slice(),
                    _len: PhantomData,
                })
            }
        }

        deserializer.deserialize_tuple(
            M::USIZE,
            HeapArrayVisitor {
                _phantom: PhantomData,
            },
        )
    }
}

impl<T: Sized + SchemaWrite<Src = T>, M: Positive> SchemaWrite for HeapArray<T, M> {
    type Src = HeapArray<T, M>;

    const TYPE_META: wincode::TypeMeta = match <T as SchemaWrite>::TYPE_META {
        TypeMeta::Static { size, zero_copy } => TypeMeta::Static {
            size: size * M::USIZE,
            zero_copy,
        },
        TypeMeta::Dynamic => TypeMeta::Dynamic,
    };

    #[inline]
    fn size_of(src: &Self::Src) -> WriteResult<usize> {
        if let TypeMeta::Static { size, .. } = <Self as SchemaWrite>::TYPE_META {
            return Ok(size);
        }

        // Extremely unlikely a type-in-memory's size will overflow usize::MAX.
        src.iter()
            .map(T::size_of)
            .try_fold(0usize, |acc, x| x.map(|x| acc + x))
    }

    #[inline]
    fn write(writer: &mut impl Writer, src: &Self::Src) -> WriteResult<()> {
        if let TypeMeta::Static {
            size,
            zero_copy: true,
        } = <Self as SchemaWrite>::TYPE_META
        {
            // SAFETY: `size` is the size of the encoded length. `writer.write(src)` will write
            // `size` bytes, fully initializing the trusted window.
            let writer = &mut unsafe { writer.as_trusted_for(size) }?;
            // SAFETY: `T::Src` is zero-copy eligible (no invalid bit patterns, no layout
            // requirements, no endianness checks, etc.).
            unsafe { writer.write_slice_t(&src.data)? };
            writer.finish()?;
        } else if let TypeMeta::Static { size, .. } = <Self as SchemaWrite>::TYPE_META {
            #[allow(clippy::arithmetic_side_effects)]
            // SAFETY: `size` is the size of the encoded length.
            // M writes of `T::Src` will write `size` bytes,
            // fully initializing the trusted window.
            let mut writer = unsafe { writer.as_trusted_for(size) }?;
            for item in src {
                T::write(&mut writer, item)?;
            }
            writer.finish()?;
        } else {
            for item in src {
                T::write(writer, item)?;
            }
        }

        Ok(())
    }
}

pub(crate) struct SliceDropGuard<T> {
    ptr: *mut MaybeUninit<T>,
    initialized_len: usize,
}

impl<T> SliceDropGuard<T> {
    pub(crate) fn new(ptr: *mut MaybeUninit<T>) -> Self {
        Self {
            ptr,
            initialized_len: 0,
        }
    }

    #[inline(always)]
    #[allow(clippy::arithmetic_side_effects)]
    pub(crate) fn inc_len(&mut self) {
        self.initialized_len += 1;
    }
}

impl<T> Drop for SliceDropGuard<T> {
    #[inline(always)]
    fn drop(&mut self) {
        unsafe {
            std::ptr::drop_in_place(std::ptr::slice_from_raw_parts_mut(
                self.ptr.cast::<T>(),
                self.initialized_len,
            ));
        }
    }
}

impl<'de, T: Sized + SchemaRead<'de, Dst = T>, M: Positive> SchemaRead<'de> for HeapArray<T, M> {
    type Dst = HeapArray<T::Dst, M>;

    const TYPE_META: TypeMeta = const {
        match T::TYPE_META {
            TypeMeta::Static { size, zero_copy } => TypeMeta::Static {
                size: M::USIZE * size,
                zero_copy,
            },
            TypeMeta::Dynamic => TypeMeta::Dynamic,
        }
    };

    #[inline]
    fn read(reader: &mut impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>) -> ReadResult<()> {
        /// Drop guard for `TypeMeta::Static { zero_copy: true }` types.
        ///
        /// In this case we do not need to drop items individually, as
        /// the container will be initialized by a single memcpy.
        struct DropGuardRawCopy<T>(*mut [MaybeUninit<T>]);
        impl<T> Drop for DropGuardRawCopy<T> {
            #[inline]
            fn drop(&mut self) {
                let container = unsafe { Box::from_raw(self.0) };
                drop(container);
            }
        }
        /// Drop guard for `TypeMeta::Static { zero_copy: false } | TypeMeta::Dynamic` types.
        ///
        /// In this case we need to drop items individually, as
        /// the container will be initialized by a series of reads.
        struct DropGuardElemCopy<T> {
            inner: ManuallyDrop<SliceDropGuard<T>>,
            fat: *mut [MaybeUninit<T>],
        }
        impl<T> DropGuardElemCopy<T> {
            #[inline(always)]
            fn new(fat: *mut [MaybeUninit<T>], raw: *mut MaybeUninit<T>) -> Self {
                Self {
                    inner: ManuallyDrop::new(SliceDropGuard::new(raw)),
                    fat,
                }
            }
        }
        impl<T> Drop for DropGuardElemCopy<T> {
            #[inline]
            fn drop(&mut self) {
                unsafe {
                    ManuallyDrop::drop(&mut self.inner);
                }
                let container = unsafe { Box::from_raw(self.fat) };
                drop(container);
            }
        }
        let mem = Box::<[T::Dst]>::new_uninit_slice(M::USIZE);
        let fat = Box::into_raw(mem);
        match T::TYPE_META {
            TypeMeta::Static {
                zero_copy: true, ..
            } => {
                let guard = DropGuardRawCopy(fat);
                let dst = unsafe { &mut *fat };
                unsafe { reader.copy_into_slice_t(dst)? };
                std::mem::forget(guard);
            }
            TypeMeta::Static {
                size,
                zero_copy: false,
            } => {
                let raw_base = unsafe { (*fat).as_mut_ptr() };
                let mut guard: DropGuardElemCopy<T::Dst> = DropGuardElemCopy::new(fat, raw_base);
                #[allow(clippy::arithmetic_side_effects)]
                let reader = &mut unsafe { reader.as_trusted_for(size * M::USIZE) }?;
                for i in 0..M::USIZE {
                    let slot = unsafe { &mut *raw_base.add(i) };
                    T::read(reader, slot)?;
                    guard.inner.inc_len();
                }
                std::mem::forget(guard);
            }
            TypeMeta::Dynamic => {
                let raw_base = unsafe { (*fat).as_mut_ptr() };
                let mut guard: DropGuardElemCopy<T::Dst> = DropGuardElemCopy::new(fat, raw_base);
                for i in 0..M::USIZE {
                    let slot = unsafe { &mut *raw_base.add(i) };
                    T::read(reader, slot)?;
                    guard.inner.inc_len();
                }
                std::mem::forget(guard);
            }
        }
        let container = unsafe { Box::from_raw(fat) };
        let container = unsafe { container.assume_init().try_into().unwrap() };
        dst.write(container);
        Ok(())
    }
}

impl<T: Sized, M: Positive> FromIterator<T> for HeapArray<T, M> {
    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
        let data = iter.into_iter().collect::<Box<_>>();
        assert_eq!(data.len(), M::USIZE,);
        Self {
            data,
            _len: PhantomData,
        }
    }
}

impl<T: Sized + Send, M: Positive> IntoParallelIterator for HeapArray<T, M> {
    type Item = T;
    type Iter = rayon::vec::IntoIter<T>;

    fn into_par_iter(self) -> Self::Iter {
        self.data.into_par_iter()
    }
}

impl<T: Sized + Send, M: Positive> FromParallelIterator<T> for HeapArray<T, M> {
    fn from_par_iter<I: IntoParallelIterator<Item = T>>(par_iter: I) -> Self {
        let data: Box<[T]> = par_iter.into_par_iter().collect::<Vec<T>>().into();
        assert_eq!(data.len(), M::USIZE);
        Self {
            data,
            _len: PhantomData,
        }
    }
}

// -----------------------
// |   Split and Merge   |
// -----------------------

impl<T: Sized + Copy, M: Positive> HeapArray<T, M> {
    pub fn split<M1, M2>(&self) -> (HeapArray<T, M1>, HeapArray<T, M2>)
    where
        M1: Positive,
        M2: Positive + Add<M1, Output = M>,
    {
        let (m1, m2) = self.split_at(M1::USIZE);
        (
            HeapArray::<T, M1> {
                data: m1.into(),
                _len: PhantomData,
            },
            HeapArray::<T, M2> {
                data: m2.into(),
                _len: PhantomData,
            },
        )
    }

    pub fn split_last_pos<M1>(self) -> (HeapArray<T, M1>, T)
    where
        M1: Positive + Add<typenum::B1, Output = M>,
    {
        let Self { data, .. } = self;
        let mut data = data.into_vec();
        let last = data.pop().expect("HeapArray is empty");
        (
            HeapArray::<T, M1> {
                data: data.into_boxed_slice(),
                _len: PhantomData,
            },
            last,
        )
    }

    pub fn split_halves<MDiv2>(&self) -> (HeapArray<T, MDiv2>, HeapArray<T, MDiv2>)
    where
        MDiv2: Positive + Mul<U2, Output = M>,
    {
        let (m1, m2) = self.split_at(MDiv2::USIZE);
        (
            HeapArray::<T, MDiv2> {
                data: m1.into(),
                _len: PhantomData,
            },
            HeapArray::<T, MDiv2> {
                data: m2.into(),
                _len: PhantomData,
            },
        )
    }

    pub fn merge_halves(this: Self, other: Self) -> HeapArray<T, Prod<M, U2>>
    where
        M: Mul<U2, Output: Positive>,
    {
        let mut vec = this.data.into_vec();
        vec.extend(other.data.into_vec());
        HeapArray::<T, Prod<M, U2>> {
            data: vec.into_boxed_slice(),
            _len: PhantomData,
        }
    }

    pub fn split3<M1, M2, M3>(&self) -> (HeapArray<T, M1>, HeapArray<T, M2>, HeapArray<T, M3>)
    where
        M1: Positive,
        M2: Positive + Add<M1>,
        M3: Positive + Add<Sum<M2, M1>, Output = M>,
    {
        let (m1, m_rest) = self.split_at(M1::USIZE);
        let (m2, m3) = m_rest.split_at(M2::USIZE);
        (
            HeapArray::<T, M1> {
                data: m1.into(),
                _len: PhantomData,
            },
            HeapArray::<T, M2> {
                data: m2.into(),
                _len: PhantomData,
            },
            HeapArray::<T, M3> {
                data: m3.into(),
                _len: PhantomData,
            },
        )
    }

    pub fn split_thirds<MDiv3>(
        &self,
    ) -> (
        HeapArray<T, MDiv3>,
        HeapArray<T, MDiv3>,
        HeapArray<T, MDiv3>,
    )
    where
        MDiv3: Positive + Mul<U3, Output = M>,
    {
        let (m1, m_rest) = self.split_at(MDiv3::USIZE);
        let (m2, m3) = m_rest.split_at(MDiv3::USIZE);
        (
            HeapArray::<T, MDiv3> {
                data: m1.into(),
                _len: PhantomData,
            },
            HeapArray::<T, MDiv3> {
                data: m2.into(),
                _len: PhantomData,
            },
            HeapArray::<T, MDiv3> {
                data: m3.into(),
                _len: PhantomData,
            },
        )
    }

    pub fn merge_thirds(first: Self, second: Self, third: Self) -> HeapArray<T, Prod<M, U3>>
    where
        M: Mul<U3, Output: Positive>,
    {
        let mut vec = first.data.into_vec();
        vec.extend(second.data.into_vec());
        vec.extend(third.data.into_vec());
        HeapArray::<T, Prod<M, U3>> {
            data: vec.into_boxed_slice(),
            _len: PhantomData,
        }
    }

    pub fn merge_fifths(
        first: Self,
        second: Self,
        third: Self,
        fourth: Self,
        fifth: Self,
    ) -> HeapArray<T, Prod<M, U5>>
    where
        M: Mul<U5, Output: Positive>,
    {
        let mut vec = first.data.into_vec();
        vec.reserve_exact(M::USIZE * 4);
        vec.extend(second.data.into_vec());
        vec.extend(third.data.into_vec());
        vec.extend(fourth.data.into_vec());
        vec.extend(fifth.data.into_vec());
        HeapArray::<T, Prod<M, U5>> {
            data: vec.into_boxed_slice(),
            _len: PhantomData,
        }
    }
}

pub struct HeapArrayTuple<T1: Sized, T2: Sized, M: Positive>(
    pub HeapArray<T1, M>,
    pub HeapArray<T2, M>,
);

impl<T1: Sized, T2: Sized, M: Positive> FromIterator<(T1, T2)> for HeapArrayTuple<T1, T2, M> {
    fn from_iter<I: IntoIterator<Item = (T1, T2)>>(iter: I) -> Self {
        let (data1, data2): (Vec<_>, Vec<_>) = iter.into_iter().unzip();

        assert_eq!(data1.len(), M::USIZE);
        assert_eq!(data2.len(), M::USIZE);
        HeapArrayTuple(
            HeapArray::<T1, M> {
                data: data1.into_boxed_slice(),
                _len: PhantomData,
            },
            HeapArray::<T2, M> {
                data: data2.into_boxed_slice(),
                _len: PhantomData,
            },
        )
    }
}

impl<T: Sized, M: Positive> TryFrom<Vec<T>> for HeapArray<T, M> {
    type Error = PrimitiveError;

    fn try_from(data: Vec<T>) -> Result<Self, PrimitiveError> {
        if data.len() == M::USIZE {
            Ok(Self {
                data: data.into_boxed_slice(),
                _len: PhantomData,
            })
        } else {
            Err(PrimitiveError::InvalidSize(M::USIZE, data.len()))
        }
    }
}

impl<T: Sized, M: Positive> TryFrom<Box<[T]>> for HeapArray<T, M> {
    type Error = PrimitiveError;

    fn try_from(data: Box<[T]>) -> Result<Self, PrimitiveError> {
        if data.len() == M::USIZE {
            Ok(Self {
                data,
                _len: PhantomData,
            })
        } else {
            Err(PrimitiveError::InvalidSize(M::USIZE, data.len()))
        }
    }
}

impl<T: Sized + Clone, M: Positive> TryFrom<Arc<[T]>> for HeapArray<T, M> {
    type Error = PrimitiveError;

    fn try_from(data: Arc<[T]>) -> Result<Self, PrimitiveError> {
        if data.len() != M::USIZE {
            return Err(PrimitiveError::InvalidSize(M::USIZE, data.len()));
        }
        Ok(Self {
            data: data.to_vec().into_boxed_slice(),
            _len: PhantomData,
        })
    }
}

impl<T: Sized> From<T> for HeapArray<T, U1> {
    fn from(element: T) -> Self {
        Self {
            data: Box::new([element]),
            _len: PhantomData,
        }
    }
}

impl<T: Sized, M: Positive> From<HeapArray<T, M>> for Vec<T> {
    fn from(array: HeapArray<T, M>) -> Self {
        array.data.into_vec()
    }
}

impl<T: Sized + Clone, M: Positive + ArraySize> From<Array<T, M>> for HeapArray<T, M> {
    fn from(array: Array<T, M>) -> Self {
        Self {
            data: array.to_vec().into_boxed_slice(),
            _len: PhantomData,
        }
    }
}

impl<T: Sized, M: Positive> HeapArray<T, M> {
    /// Take the first `N` elements and discard the rest. `N` may equal `M`
    /// (no slack) or be strictly less.
    pub fn truncate<N>(self) -> HeapArray<T, N>
    where
        N: Positive,
        M: Sub<N, Output: Unsigned>,
    {
        let mut vec = self.data.into_vec();
        vec.truncate(N::USIZE);
        HeapArray {
            data: vec.into_boxed_slice(),
            _len: PhantomData,
        }
    }

    pub fn split_last<N: Positive>(self) -> (HeapArray<T, Diff<M, N>>, HeapArray<T, N>)
    where
        M: Sub<N, Output: Positive>,
    {
        let mut vec = self.data.into_vec();
        let last_n = vec.split_off(M::USIZE - N::USIZE);

        (
            HeapArray {
                data: vec.into_boxed_slice(),
                _len: PhantomData,
            },
            HeapArray {
                data: last_n.into_boxed_slice(),
                _len: PhantomData,
            },
        )
    }

    pub fn from_fn(f: impl FnMut(usize) -> T) -> Self {
        Self {
            data: (0..M::USIZE).map(f).collect::<Box<_>>(),
            _len: PhantomData,
        }
    }

    pub fn from_constant(c: T) -> Self
    where
        T: Copy,
    {
        Self {
            data: (0..M::USIZE).map(|_| c).collect::<Box<_>>(),
            _len: PhantomData,
        }
    }
}

impl<T: Sized, M: Positive> Display for HeapArray<T, M>
where
    T: Display,
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "[")?;
        for (i, item) in self.data.iter().enumerate() {
            if i != 0 {
                write!(f, ", ")?;
            }
            write!(f, "{item}")?;
        }
        write!(f, "]")
    }
}

#[cfg(test)]
pub mod tests {
    use hybrid_array::sizes::{U2, U3, U6};
    use typenum::{U1, U4};

    use super::*;

    #[test]
    fn test_heap_array() {
        let array = HeapArray::<_, U3>::from_fn(|i| i);
        assert_eq!(array.into_iter().collect::<Vec<_>>(), vec![0, 1, 2]);
    }

    #[test]
    fn test_default() {
        let array = HeapArray::<usize, U3>::default();
        assert_eq!(array.len(), 3);
    }

    #[test]
    fn test_heap_array_split_last() {
        let array = HeapArray::<_, U6>::from_fn(|i| i);
        let (first, last) = array.split_last::<U2>();
        assert_eq!(first.into_iter().collect::<Vec<_>>(), vec![0, 1, 2, 3]);
        assert_eq!(last.into_iter().collect::<Vec<_>>(), vec![4, 5]);
    }

    #[test]
    fn test_heap_array_from_array() {
        let array = Array::<_, U3>::from_fn(|i| i);
        let heap_array = HeapArray::<_, U3>::from(array);
        assert_eq!(heap_array.into_iter().collect::<Vec<_>>(), vec![0, 1, 2]);
    }

    #[test]
    fn test_heap_array_from_vec() {
        let vec = vec![0, 1, 2];
        let heap_array = HeapArray::<_, U3>::try_from(vec).unwrap();
        assert_eq!(heap_array.into_iter().collect::<Vec<_>>(), vec![0, 1, 2]);

        let vec = vec![0, 1];
        let heap_array = HeapArray::<_, U3>::try_from(vec);
        assert!(heap_array.is_err());
    }

    #[test]
    fn test_heap_array_from_iter() {
        let heap_array = HeapArray::<_, U3>::from_fn(|i| i);
        assert_eq!(heap_array.into_iter().collect::<Vec<_>>(), vec![0, 1, 2]);
    }

    #[test]
    #[should_panic]
    fn test_heap_array_from_iter_wrong_size() {
        HeapArray::<_, U2>::from_iter(0..3);
    }

    #[test]
    fn test_heap_array_deserialize() {
        let array = HeapArray::<usize, U6>::from_fn(|i| i);
        let serialized = bincode::serialize(&array).unwrap();
        bincode::deserialize::<HeapArray<usize, U6>>(&serialized).unwrap();

        // With the new tuple-based serialization (which doesn't include length),
        // we can't detect length mismatches unless we use strict deserialization
        // that rejects trailing bytes.
        use bincode::Options;
        let config = bincode::DefaultOptions::new()
            .with_fixint_encoding()
            .reject_trailing_bytes();

        let wrong_deserialize = config.deserialize::<HeapArray<usize, U3>>(&serialized);
        assert!(wrong_deserialize.is_err());
    }

    #[test]
    fn test_heap_array_split() {
        let array = HeapArray::<_, U6>::from_fn(|i| i);
        let (first, second) = array.split::<U4, U2>();
        assert_eq!(first.into_iter().collect::<Vec<_>>(), vec![0, 1, 2, 3]);
        assert_eq!(second.into_iter().collect::<Vec<_>>(), vec![4, 5]);

        let (first, second) = array.split_halves::<U3>();
        assert_eq!(first.into_iter().collect::<Vec<_>>(), vec![0, 1, 2]);
        assert_eq!(second.into_iter().collect::<Vec<_>>(), vec![3, 4, 5]);

        // let (first, second) = array.split::<U4, U1>(); --> doesn't compile

        // let (first, second) = array.split_halves::<U2>(); --> doesn't compile
    }

    #[test]
    fn test_heap_array_split3() {
        let array = HeapArray::<_, U6>::from_fn(|i| i);
        let (first, second, third) = array.split3::<U3, U2, U1>();
        assert_eq!(first.into_iter().collect::<Vec<_>>(), vec![0, 1, 2]);
        assert_eq!(second.into_iter().collect::<Vec<_>>(), vec![3, 4]);
        assert_eq!(third.into_iter().collect::<Vec<_>>(), vec![5]);

        let (first, second, third) = array.split_thirds::<U2>();
        assert_eq!(first.into_iter().collect::<Vec<_>>(), vec![0, 1]);
        assert_eq!(second.into_iter().collect::<Vec<_>>(), vec![2, 3]);
        assert_eq!(third.into_iter().collect::<Vec<_>>(), vec![4, 5]);

        // let (a1, a2, a3) = array.split3::<U3, U2, U2>(); // doesn't compile

        // let (a1, a2, a3) = array.split_thirds::<U2>(); // doesn't compile
    }

    #[test]
    fn test_heap_array_wrap_transparent() {
        #[repr(transparent)]
        #[derive(Clone, Copy, Debug, PartialEq, Eq)]
        struct Wrap(u32);
        // SAFETY: `Wrap` is `#[repr(transparent)]` over `u32`.
        unsafe impl bytemuck::TransparentWrapper<u32> for Wrap {}

        let array = HeapArray::<u32, U3>::from_fn(|i| (i as u32) * 10);
        let wrapped: HeapArray<Wrap, U3> = array.wrap_transparent();
        assert_eq!(
            wrapped.into_iter().collect::<Vec<_>>(),
            vec![Wrap(0), Wrap(10), Wrap(20)],
        );
    }

    #[test]
    fn test_heap_array_peel_transparent() {
        #[repr(transparent)]
        #[derive(Clone, Copy, Debug, PartialEq, Eq)]
        struct Wrap(u32);
        // SAFETY: `Wrap` is `#[repr(transparent)]` over `u32`.
        unsafe impl bytemuck::TransparentWrapper<u32> for Wrap {}

        let array = HeapArray::<Wrap, U3>::from_fn(|i| Wrap((i as u32) * 10));
        let peeled: HeapArray<u32, U3> = array.peel_transparent();
        assert_eq!(peeled.into_iter().collect::<Vec<_>>(), vec![0, 10, 20]);
    }

    #[test]
    fn test_heap_array_wrap_peel_roundtrip() {
        #[repr(transparent)]
        #[derive(Clone, Copy, Debug, PartialEq, Eq)]
        struct Wrap(u32);
        // SAFETY: `Wrap` is `#[repr(transparent)]` over `u32`.
        unsafe impl bytemuck::TransparentWrapper<u32> for Wrap {}

        let original = HeapArray::<u32, U4>::from_fn(|i| i as u32 + 1);
        let expected = original.clone().into_iter().collect::<Vec<_>>();
        let roundtripped: HeapArray<u32, U4> =
            original.wrap_transparent::<Wrap>().peel_transparent();
        assert_eq!(roundtripped.into_iter().collect::<Vec<_>>(), expected);
    }

    #[test]
    fn test_heap_array_wincode_roundtrip() {
        // Test static zero-copy type
        let array = HeapArray::<u32, U4>::from_fn(|i| (i * 10) as u32);
        let ser = wincode::serialize(&array).unwrap();
        let bin_ser = bincode::serialize(&array).unwrap();
        let deserialized: HeapArray<u32, U4> = wincode::deserialize(&ser).unwrap();

        assert_eq!(ser, bin_ser);
        assert_eq!(deserialized, array);

        // Test static non-zero-copy type
        #[derive(
            Debug, Copy, Clone, PartialEq, SchemaRead, SchemaWrite, Serialize, Deserialize,
        )]
        struct NonZeroCopy {
            a: u8,
            b: u16,
        }
        let array = HeapArray::<NonZeroCopy, U3>::from_fn(|i| NonZeroCopy {
            a: i as u8,
            b: (i * 100) as u16,
        });
        let ser = wincode::serialize(&array).unwrap();
        let bin_ser = bincode::serialize(&array).unwrap();
        let deserialized: HeapArray<NonZeroCopy, U3> = wincode::deserialize(&ser).unwrap();
        assert_eq!(ser, bin_ser);
        assert_eq!(deserialized, array);

        // Test dynamically-sized type
        let array = HeapArray::<String, U2>::from_fn(|i| format!("String {i}"));
        let ser = wincode::serialize(&array).unwrap();
        let bin_ser = bincode::serialize(&array).unwrap();
        let deserialized: HeapArray<String, U2> = wincode::deserialize(&ser).unwrap();
        assert_eq!(ser, bin_ser);
        assert_eq!(deserialized, array);
    }
}