Remove the 'static requirement from the BinRead Vec implementation by delegating to a new trait method.

binrw/src/binread/impls.rs

@@ -10,7 +10,9 @@ use core::num::{
 };
 
 macro_rules! binread_impl {
-    ($($type_name:ty),*$(,)?) => {
+    // `$(some_lit $(__unused $is_lit_present:tt))?` allows us to match on the present of a literal
+    // using `$($($is_list_present)? fn do_whatever() {})?`
+    ($($type_name:ty $(as int $(__unused $is_int:tt)?)?),*$(,)?) => {
         $(
             impl BinRead for $type_name {
                 type Args<'a> = ();
@@ -29,12 +31,91 @@ macro_rules! binread_impl {
                         }
                     })
                 }
+
+                $(
+                    $($is_int)?
+                    fn read_options_count<'a, R, C>(
+                        reader: &mut R,
+                        endian: Endian,
+                        _args: Self::Args<'a>,
+                        count: C::Count,
+                    ) -> BinResult<C>
+                    where
+                        R: Read + Seek,
+                        Self::Args<'a>: Clone,
+                        C: crate::container::Container<Item=Self>,
+                    {
+                        C::new_smart(count, |mut buf| {
+                            reader.read_exact(&mut bytemuck::cast_slice_mut::<_, u8>(
+                                &mut buf,
+                            ))?;
+
+                            if core::mem::size_of::<Self>() != 1
+                                && ((cfg!(target_endian = "big") && endian == crate::Endian::Little)
+                                    || (cfg!(target_endian = "little") && endian == crate::Endian::Big))
+                            {
+                                for value in buf.iter_mut() {
+                                    *value = value.swap_bytes();
+                                }
+                            }
+                            Ok(())
+                        })
+                    }
+                )?
             }
         )*
     }
 }
 
-binread_impl!(u8, u16, u32, u64, u128, i8, i16, i32, i64, i128, f32, f64);
+binread_impl!(
+    u16 as int,
+    u32 as int,
+    u64 as int,
+    u128 as int,
+    i8 as int,
+    i16 as int,
+    i32 as int,
+    i64 as int,
+    i128 as int,
+    f32,
+    f64
+);
+
+impl BinRead for u8 {
+    type Args<'a> = ();
+    fn read_options<R: Read + Seek>(
+        reader: &mut R,
+        _endian: Endian,
+        _args: Self::Args<'_>,
+    ) -> BinResult<Self> {
+        let mut val = 0u8;
+        let pos = reader.stream_position()?;
+        reader
+            .read_exact(core::slice::from_mut(&mut val))
+            .or_else(crate::__private::restore_position(reader, pos))?;
+
+        Ok(val)
+    }
+
+    // This extra impl for `u8` makes it faster than
+    // `binread_impl`, but *only* because `binread_impl` is not allowed
+    // to use unsafe code to eliminate the unnecessary zero-fill.
+    // Otherwise, performance would be identical and it could be
+    // deleted.
+    fn read_options_count<'a, R, C>(
+        reader: &mut R,
+        _endian: Endian,
+        _args: Self::Args<'a>,
+        count: C::Count,
+    ) -> BinResult<C>
+    where
+        R: Read + Seek,
+        Self::Args<'a>: Clone,
+        C: crate::container::Container<Item = Self>,
+    {
+        C::new_smart(count, |buf| reader.read_exact(buf).map_err(Into::into))
+    }
+}
 
 fn unexpected_zero_num() -> Error {
     Error::Io(io::Error::new(
@@ -133,7 +214,7 @@ pub struct VecArgs<Inner: Clone> {
 
 impl<B> BinRead for Vec<B>
 where
-    B: BinRead + 'static,
+    B: BinRead,
     for<'a> B::Args<'a>: Clone,
 {
     type Args<'a> = VecArgs<B::Args<'a>>;
@@ -143,7 +224,7 @@ where
         endian: Endian,
         args: Self::Args<'_>,
     ) -> BinResult<Self> {
-        crate::helpers::count_with(args.count, B::read_options)(reader, endian, args.inner)
+        B::read_options_count(reader, endian, args.inner, args.count)
     }
 }
 
@@ -159,7 +240,7 @@ where
         endian: Endian,
         args: Self::Args<'_>,
     ) -> BinResult<Self> {
-        array_init::try_array_init(|_| BinRead::read_options(reader, endian, args.clone()))
+        BinRead::read_options_count(reader, endian, args, ())
     }
 }
 

binrw/src/binread/mod.rs

@@ -192,6 +192,62 @@ pub trait BinRead: Sized {
         endian: Endian,
         args: Self::Args<'_>,
     ) -> BinResult<Self>;
+
+    /// Read `count` items of `Self` from the reader using the given [`Endian`] and arguments
+    ///
+    /// A vehicle for optimizations of types that can easily be read many-at-a-time.
+    /// For example, the integral types {i,u}{8,16,32,64,128}.
+    ///
+    /// # Errors
+    ///
+    /// If reading fails, an [`Error`](crate::Error) variant will be returned.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use binrw::{io::{Read, Seek}, BinRead, BinResult, Endian, container::Container};
+    /// struct CustomU8(u8);
+    ///
+    /// impl BinRead for CustomU8 {
+    ///     type Args<'a> = <u8 as BinRead>::Args<'a>;
+    ///
+    ///     fn read_options<R: Read + Seek>(
+    ///         reader: &mut R,
+    ///         endian: binrw::Endian,
+    ///         args: Self::Args<'_>,
+    ///     ) -> BinResult<Self> {
+    ///         u8::read_options(reader, endian, args).map(CustomU8)
+    ///     }
+    ///
+    ///     fn read_options_count<'a, R, C>(
+    ///         reader: &mut R,
+    ///         endian: Endian,
+    ///         args: Self::Args<'a>,
+    ///         count: C::Count,
+    ///     ) -> BinResult<C>
+    ///     where
+    ///         R: Read + Seek,
+    ///         Self::Args<'a>: Clone,
+    ///         C: Container<Item=Self>
+    ///     {
+    ///         let c: C::HigherSelf<u8> = u8::read_options_count(reader, endian, args, count)?;
+    ///         Ok(c.map(CustomU8))
+    ///     }
+    /// }
+    /// ```
+    fn read_options_count<'a, R, C>(
+        reader: &mut R,
+        endian: Endian,
+        args: Self::Args<'a>,
+        count: C::Count,
+    ) -> BinResult<C>
+    where
+        R: Read + Seek,
+        Self::Args<'a>: Clone,
+        C: crate::container::Container<Item = Self>,
+    {
+        C::new_naive(count, || Self::read_options(reader, endian, args.clone()))
+    }
 }
 
 /// Extension methods for reading [`BinRead`] objects directly from a reader.

binrw/src/container.rs

@@ -0,0 +1,121 @@
+//! container module
+#[cfg(not(feature = "std"))]
+use alloc::vec::Vec;
+
+/// Container
+pub trait Container: Sized + IntoIterator {
+    /// Count
+    type Count;
+
+    /// naive
+    ///
+    /// # Errors
+    ///
+    /// If `f` returns an error, the error will be returned
+    fn new_naive<Fun, Error>(count: Self::Count, f: Fun) -> Result<Self, Error>
+    where
+        Fun: FnMut() -> Result<Self::Item, Error>;
+
+    /// smart
+    ///
+    /// # Errors
+    ///
+    /// If `f` returns an error, the error will be returned
+    fn new_smart<Fun, Error>(count: Self::Count, f: Fun) -> Result<Self, Error>
+    where
+        Fun: FnMut(&mut [Self::Item]) -> Result<(), Error>,
+        Self::Item: Default + Clone;
+
+    // whee it's a Functor
+    /// Type Constructor
+    type HigherSelf<T>: Container<Count = Self::Count, HigherSelf<Self::Item> = Self>
+        + IntoIterator<Item = T>;
+
+    /// map
+    fn map<Fun, T>(self, f: Fun) -> Self::HigherSelf<T>
+    where
+        Fun: FnMut(Self::Item) -> T;
+}
+
+impl<T, const N: usize> Container for [T; N] {
+    type Count = ();
+    type HigherSelf<X> = [X; N];
+
+    fn new_naive<Fun, Error>(_count: (), mut f: Fun) -> Result<Self, Error>
+    where
+        Fun: FnMut() -> Result<Self::Item, Error>,
+    {
+        array_init::try_array_init(|_| f())
+    }
+
+    fn new_smart<Fun, Error>(_count: (), mut f: Fun) -> Result<Self, Error>
+    where
+        Fun: FnMut(&mut [Self::Item]) -> Result<(), Error>,
+        Self::Item: Default + Clone,
+    {
+        let mut res = array_init::array_init(|_| Self::Item::default());
+        f(&mut res)?;
+        Ok(res)
+    }
+
+    fn map<Fun, X>(self, f: Fun) -> Self::HigherSelf<X>
+    where
+        Fun: FnMut(Self::Item) -> X,
+    {
+        self.map(f)
+    }
+}
+
+impl<T> Container for Vec<T> {
+    type Count = usize;
+    type HigherSelf<X> = Vec<X>;
+
+    fn new_naive<Fun, Error>(count: usize, f: Fun) -> Result<Self, Error>
+    where
+        Fun: FnMut() -> Result<Self::Item, Error>,
+    {
+        core::iter::repeat_with(f).take(count).collect()
+    }
+
+    fn new_smart<Fun, Error>(count: usize, mut f: Fun) -> Result<Self, Error>
+    where
+        Fun: FnMut(&mut [Self::Item]) -> Result<(), Error>,
+        Self::Item: Default + Clone,
+    {
+        let mut list = Self::default();
+        let mut start = 0;
+        let mut remaining = count;
+        // Allocating and reading from the source in chunks is done to keep
+        // a bad `count` from causing huge memory allocations that are
+        // doomed to fail
+        while remaining != 0 {
+            // Using a similar strategy as std `default_read_to_end` to
+            // leverage the memory growth strategy of the underlying Vec
+            // implementation (in std this will be exponential) using a
+            // minimum byte allocation
+            let growth: usize = 32 / core::mem::size_of::<u32>();
+            list.reserve(remaining.min(growth.max(1)));
+
+            let items_to_read = remaining.min(list.capacity() - start);
+            let end = start + items_to_read;
+
+            // In benchmarks, this resize decreases performance by 27–40%
+            // relative to using `unsafe` to write directly to uninitialised
+            // memory, but nobody ever got fired for buying IBM
+            list.resize(end, Self::Item::default());
+            f(&mut list[start..end])?;
+
+            remaining -= items_to_read;
+            start += items_to_read;
+        }
+
+        Ok(list)
+    }
+
+    fn map<Fun, X>(self, f: Fun) -> Self::HigherSelf<X>
+    where
+        Fun: FnMut(Self::Item) -> X,
+    {
+        self.into_iter().map(f).collect()
+    }
+}