Extra crate support, try_generate, try_fold

novacrazy · novacrazy · commit 7b3efcfc76c3 · 2025-10-16T20:57:58.000-05:00
diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml
@@ -38,7 +38,7 @@ jobs:
         uses: dtolnay/rust-toolchain@nightly
 
       - name: Build documentation
-        run: cargo doc --features "serde zeroize const-default alloc hybrid-array-0_4"
+        run: cargo doc --features "serde zeroize const-default alloc hybrid-array-0_4 subtle arbitrary bytemuck"
 
       - name: Finalize documentation
         run: |
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,3 +1,8 @@
+* **`1.3.5`**
+    * Add `subtle`, `arbitrary`, and `bytemuck` implementations for `GenericArray` when the inner type supports them.
+    * Add `FallibleGenericSequence` with `try_generate` for fallible generation of sequences/arrays.
+    * Add `try_fold` to `FunctionalSequence` for fallible folding of sequences/arrays.
+
 * **`1.3.4`**
     * Significantly improve stack usage of `GenericArray` methods in unoptimized (`-C opt-level=0`) build modes.
     * Introduce the `hybrid-array-0_4` feature to allow interop between `generic-array` 1.x and `hybrid-array` 0.4 versions.
diff --git a/Cargo.toml b/Cargo.toml
@@ -33,6 +33,9 @@ const-default = { version = "1", optional = true, default-features = false }
 serde_core = { version = "1.0", optional = true, default-features = false }
 zeroize = { version = "1", optional = true, default-features = false }
 faster-hex = { version = "0.10", optional = true, default-features = false }
+subtle = { version = "2", optional = true, default-features = false }
+arbitrary = { version = "1", optional = true, default-features = false }
+bytemuck = { version = "1", optional = true, default-features = false }
 rustversion = "1"
 
 generic_array-0_14 = { package = "generic-array", version = "0.14", optional = true, default-features = false }
@@ -57,7 +60,7 @@ codegen-units = 1
 
 [package.metadata.docs.rs]
 # all but "internals", don't show those on docs.rs
-features = ["serde", "zeroize", "const-default", "alloc", "hybrid-array-0_4"]
+features = ["serde", "zeroize", "const-default", "alloc", "hybrid-array-0_4", "subtle", "arbitrary", "bytemuck"]
 rustdoc-args = ["--cfg", "docsrs"]
 
 [package.metadata.playground]
diff --git a/README.md b/README.md
@@ -1,5 +1,7 @@
 [![Crates.io](https://img.shields.io/crates/v/generic-array.svg)](https://crates.io/crates/generic-array)
 [![Build Status](https://github.com/fizyk20/generic-array/actions/workflows/CI.yml/badge.svg)](https://github.com/fizyk20/generic-array/actions/workflows/CI.yml)
+![Rust Version](https://img.shields.io/badge/rustc-1.65+-blue.svg)
+
 # generic-array
 
 This crate implements a structure that can be used as a generic array type.
@@ -126,6 +128,10 @@ features = [
     "const-default",    # Compile-time const default value support via trait
     "alloc",            # Enables From/TryFrom implementations between GenericArray and Vec<T>/Box<[T]>
     "faster-hex",       # Enables internal use of the `faster-hex` crate for faster hex encoding via SIMD
+    "subtle",           # Enables `subtle` crate support for constant-time equality checks and conditional selection
+    "arbitrary",        # Enables `arbitrary` crate support for fuzzing
+    "bytemuck",         # Enables `bytemuck` crate support
+    "compat-0_14",      # Enables interoperability with `generic-array` 0.14
     "compat-0_14",      # Enables interoperability with `generic-array` 0.14
     "hybrid-array-0_4"  # Enables interoperability with `hybrid-array` 0.4
 ]
diff --git a/src/ext_impls/impl_alloc.rs b/src/ext_impls/impl_alloc.rs
diff --git a/src/ext_impls/impl_arbitrary.rs b/src/ext_impls/impl_arbitrary.rs
@@ -0,0 +1,37 @@
+use arbitrary::Arbitrary;
+
+use crate::{sequence::FallibleGenericSequence as _, ArrayLength, GenericArray};
+
+impl<'a, T, N: ArrayLength> Arbitrary<'a> for GenericArray<T, N>
+where
+    T: Arbitrary<'a>,
+{
+    #[inline]
+    fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
+        GenericArray::try_generate(|_| T::arbitrary(u))
+    }
+
+    #[inline]
+    fn arbitrary_take_rest(mut u: arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
+        let mut array = Self::arbitrary(&mut u)?;
+        if let Some(last) = array.last_mut() {
+            *last = T::arbitrary_take_rest(u)?;
+        }
+        Ok(array)
+    }
+
+    fn size_hint(depth: usize) -> (usize, Option<usize>) {
+        Self::try_size_hint(depth).unwrap_or_default()
+    }
+
+    fn try_size_hint(
+        depth: usize,
+    ) -> arbitrary::Result<(usize, Option<usize>), arbitrary::MaxRecursionReached> {
+        let hint = <T as Arbitrary>::try_size_hint(depth)?;
+
+        // same as `arbitrary::size_hint::and_all(...)` but without allocations
+        Ok(core::iter::repeat(hint)
+            .take(N::USIZE)
+            .fold((0, Some(0)), arbitrary::size_hint::and))
+    }
+}
diff --git a/src/ext_impls/impl_bytemuck.rs b/src/ext_impls/impl_bytemuck.rs
@@ -0,0 +1,7 @@
+use bytemuck::{Pod, Zeroable};
+
+use crate::{ArrayLength, GenericArray};
+
+unsafe impl<T: Pod, N: ArrayLength> Pod for GenericArray<T, N> where GenericArray<T, N>: Copy {}
+
+unsafe impl<T: Zeroable, N: ArrayLength> Zeroable for GenericArray<T, N> {}
diff --git a/src/ext_impls/impl_const_default.rs b/src/ext_impls/impl_const_default.rs
diff --git a/src/ext_impls/impl_serde.rs b/src/ext_impls/impl_serde.rs
diff --git a/src/ext_impls/impl_subtle.rs b/src/ext_impls/impl_subtle.rs
@@ -0,0 +1,33 @@
+use subtle::{ConditionallySelectable, ConstantTimeEq};
+
+use crate::{ArrayLength, GenericArray};
+
+impl<T, N: ArrayLength> ConstantTimeEq for GenericArray<T, N>
+where
+    T: ConstantTimeEq,
+{
+    #[inline]
+    fn ct_eq(&self, other: &Self) -> subtle::Choice {
+        self.as_slice().ct_eq(other.as_slice())
+    }
+}
+
+impl<T, N: ArrayLength> ConditionallySelectable for GenericArray<T, N>
+where
+    GenericArray<T, N>: Copy,
+    T: ConditionallySelectable,
+{
+    #[inline]
+    fn conditional_select(a: &Self, b: &Self, choice: subtle::Choice) -> Self {
+        let mut out = *a;
+        out.conditional_assign(b, choice);
+        out
+    }
+
+    #[inline]
+    fn conditional_assign(&mut self, other: &Self, choice: subtle::Choice) {
+        for (a, b) in self.iter_mut().zip(other.iter()) {
+            a.conditional_assign(b, choice);
+        }
+    }
+}
diff --git a/src/ext_impls/impl_zeroize.rs b/src/ext_impls/impl_zeroize.rs
diff --git a/src/ext_impls/mod.rs b/src/ext_impls/mod.rs
@@ -0,0 +1,20 @@
+#[cfg(feature = "alloc")]
+mod impl_alloc;
+
+#[cfg(feature = "const-default")]
+mod impl_const_default;
+
+#[cfg(feature = "serde")]
+mod impl_serde;
+
+#[cfg(feature = "zeroize")]
+mod impl_zeroize;
+
+#[cfg(feature = "subtle")]
+mod impl_subtle;
+
+#[cfg(feature = "arbitrary")]
+mod impl_arbitrary;
+
+#[cfg(feature = "bytemuck")]
+mod impl_bytemuck;
diff --git a/src/functional.rs b/src/functional.rs
@@ -96,6 +96,17 @@ pub trait FunctionalSequence<T>: GenericSequence<T> {
     {
         self.into_iter().fold(init, f)
     }
+
+    /// Folds (or reduces) a sequence of data into a single value, returning a `Result`.
+    ///
+    /// If the fold function errors or panics, any unused elements will be dropped.
+    #[inline(always)]
+    fn try_fold<U, E, F>(self, init: U, f: F) -> Result<U, E>
+    where
+        F: FnMut(U, Self::Item) -> Result<U, E>,
+    {
+        self.into_iter().try_fold(init, f)
+    }
 }
 
 impl<'a, T, S: GenericSequence<T>> FunctionalSequence<T> for &'a S where &'a S: GenericSequence<T> {}
diff --git a/src/lib.rs b/src/lib.rs
@@ -133,6 +133,9 @@
 //!     "const-default",    # Compile-time const default value support via trait
 //!     "alloc",            # Enables From/TryFrom implementations between GenericArray and Vec<T>/Box<[T]>
 //!     "faster-hex",       # Enables internal use of the `faster-hex` crate for faster hex encoding via SIMD
+//!     "subtle",           # Enables `subtle` crate support for constant-time equality checks and conditional selection
+//!     "arbitrary",        # Enables `arbitrary` crate support for fuzzing
+//!     "bytemuck",         # Enables `bytemuck` crate support
 //!     "compat-0_14",      # Enables interoperability with `generic-array` 0.14
 //!     "hybrid-array-0_4"  # Enables interoperability with `hybrid-array` 0.4
 //! ]
@@ -154,17 +157,7 @@ mod hex;
 mod impls;
 mod iter;
 
-#[cfg(feature = "alloc")]
-mod impl_alloc;
-
-#[cfg(feature = "const-default")]
-mod impl_const_default;
-
-#[cfg(feature = "serde")]
-mod impl_serde;
-
-#[cfg(feature = "zeroize")]
-mod impl_zeroize;
+mod ext_impls;
 
 use core::iter::FromIterator;
 use core::marker::PhantomData;
@@ -557,6 +550,7 @@ impl<'a, T: 'a, N: ArrayLength> IntoIterator for &'a GenericArray<T, N> {
     type IntoIter = slice::Iter<'a, T>;
     type Item = &'a T;
 
+    #[inline]
     fn into_iter(self: &'a GenericArray<T, N>) -> Self::IntoIter {
         self.as_slice().iter()
     }
@@ -566,6 +560,7 @@ impl<'a, T: 'a, N: ArrayLength> IntoIterator for &'a mut GenericArray<T, N> {
     type IntoIter = slice::IterMut<'a, T>;
     type Item = &'a mut T;
 
+    #[inline]
     fn into_iter(self: &'a mut GenericArray<T, N>) -> Self::IntoIter {
         self.as_mut_slice().iter_mut()
     }
@@ -611,14 +606,12 @@ where
             let mut array = MaybeUninit::<GenericArray<T, N>>::uninit();
             let mut builder = IntrusiveArrayBuilder::new_alt(&mut array);
 
-            {
-                let (builder_iter, position) = builder.iter_position();
+            let (builder_iter, position) = builder.iter_position();
 
-                builder_iter.enumerate().for_each(|(i, dst)| {
-                    dst.write(f(i));
-                    *position += 1;
-                });
-            }
+            builder_iter.enumerate().for_each(|(i, dst)| {
+                dst.write(f(i));
+                *position += 1;
+            });
 
             builder.finish_and_assume_init()
         }
@@ -637,10 +630,10 @@ where
         F: FnMut(B, Self::Item) -> U,
     {
         unsafe {
-            if mem::needs_drop::<T>() || mem::needs_drop::<B>() {
-                let mut left = ManuallyDrop::new(lhs);
-                let mut right = ManuallyDrop::new(self);
+            let mut left = ManuallyDrop::new(lhs);
+            let mut right = ManuallyDrop::new(self);
 
+            if mem::needs_drop::<T>() || mem::needs_drop::<B>() {
                 let mut left = IntrusiveArrayConsumer::new(&mut left);
                 let mut right = IntrusiveArrayConsumer::new(&mut right);
 
@@ -657,12 +650,8 @@ where
                     f(left_value, right_value)
                 }))
             } else {
-                // Despite neither needing `Drop`, they may not be `Copy`, so be paranoid
-                // and avoid anything related to drop anyway. Assume it's moved out on each read.
-                let left = ManuallyDrop::new(lhs);
-                let right = ManuallyDrop::new(self);
-
-                // Neither right nor left require `Drop` be called, so choose an iterator that's easily optimized
+                // Neither right nor left require `Drop` be called, so choose an iterator that's easily optimized,
+                // though we still keep them in `ManuallyDrop` out of paranoia.
                 //
                 // Note that because ArrayConsumer checks for `needs_drop` itself, if `f` panics then nothing
                 // would have been done about it anyway. Only the other branch needs `ArrayConsumer`
@@ -706,6 +695,43 @@ where
     }
 }
 
+unsafe impl<T, N: ArrayLength> FallibleGenericSequence<T> for GenericArray<T, N>
+where
+    Self: IntoIterator<Item = T>,
+{
+    #[inline(always)]
+    fn try_generate<F, E>(mut f: F) -> Result<Self::Sequence, E>
+    where
+        F: FnMut(usize) -> Result<T, E>,
+    {
+        unsafe {
+            let mut array = MaybeUninit::<GenericArray<T, N>>::uninit();
+            let mut builder = IntrusiveArrayBuilder::new_alt(&mut array);
+
+            let (builder_iter, position) = builder.iter_position();
+
+            if let Err(e) = builder_iter
+                .enumerate()
+                .try_for_each(|(i, dst)| match f(i) {
+                    // NOTE: Using a match here instead of ? results in better codegen
+                    Ok(value) => {
+                        dst.write(value);
+                        *position += 1;
+                        Ok(())
+                    }
+                    Err(e) => Err(e),
+                })
+            {
+                drop(builder); // explicitly drop to run the destructor and drop any initialized elements
+
+                return Err(e);
+            }
+
+            Ok(builder.finish_and_assume_init())
+        }
+    }
+}
+
 impl<T, U, N: ArrayLength> MappedGenericSequence<T, U> for GenericArray<T, N>
 where
     GenericArray<U, N>: GenericSequence<U, Length = N>,
@@ -768,6 +794,25 @@ where
             })
         }
     }
+
+    #[inline(always)]
+    fn try_fold<U, E, F>(self, init: U, mut f: F) -> Result<U, E>
+    where
+        F: FnMut(U, Self::Item) -> Result<U, E>,
+    {
+        unsafe {
+            let mut array = ManuallyDrop::new(self);
+            let mut source = IntrusiveArrayConsumer::new(&mut array);
+
+            let (mut array_iter, position) = source.iter_position();
+
+            array_iter.try_fold(init, |acc, src| {
+                let value = ptr::read(src);
+                *position += 1;
+                f(acc, value)
+            })
+        }
+    }
 }
 
 impl<T, N: ArrayLength> GenericArray<T, N> {
diff --git a/src/sequence.rs b/src/sequence.rs
