Improve EncodedUint array conversions (#1068)

- Uses the same trick as `Array` to write bespoke `From` impls for
  `EncodedUint`, for all the sizes we do currently special-case
- Updates the `Array` impls to be defined in the same macro we already
  use for writing size-specific impls anyway

Author: tarcieri

src/array.rs

@@ -1,8 +1,8 @@
 //! Interop support for `hybrid-array`
 
-use crate::{EncodedUint, Encoding, Integer, Limb};
+use crate::{Encoding, Integer};
 use core::ops::Add;
-use hybrid_array::{Array, ArrayN, ArraySize, typenum::Unsigned};
+use hybrid_array::{Array, ArraySize, typenum::Unsigned};
 
 /// Alias for a byte array whose size is defined by [`ArrayEncoding::ByteSize`].
 pub type ByteArray<T> = Array<u8, <T as ArrayEncoding>::ByteSize>;
@@ -36,58 +36,3 @@ pub trait ArrayDecoding {
     /// Deserialize from a little-endian `Array`.
     fn into_uint_le(self) -> Self::Output;
 }
-
-macro_rules! from_impls_for_encoded_uint {
-    ( $($nlimbs:expr),+ ) => {
-        $(
-            impl From<EncodedUint<$nlimbs>> for ArrayN<u8, { $nlimbs * Limb::BYTES }> {
-                #[inline]
-                fn from(input: EncodedUint<$nlimbs>) -> Self {
-                    let mut output = Self::default();
-                    output.as_mut_slice().copy_from_slice(input.as_ref());
-                    output
-                }
-            }
-
-            impl From<ArrayN<u8, { $nlimbs * Limb::BYTES }>> for EncodedUint<$nlimbs> {
-                #[inline]
-                fn from(input: ArrayN<u8, { $nlimbs * Limb::BYTES }>) -> Self {
-                    let mut output = Self::default();
-                    output.as_mut().copy_from_slice(input.as_ref());
-                    output
-                }
-            }
-        )+
-    };
-}
-
-// Support up to 16 limbs for now (chosen somewhat arbitrarily)
-from_impls_for_encoded_uint!(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-
-#[cfg(test)]
-mod tests {
-    const LIMBS: usize = 4;
-    const BYTES: usize = super::Limb::BYTES * LIMBS;
-
-    type Array = super::ArrayN<u8, { BYTES }>;
-    type EncodedUint = super::EncodedUint<LIMBS>;
-
-    const ARRAY: Array = {
-        let mut i = 0;
-        let mut ret = [0u8; BYTES];
-        while i < BYTES {
-            ret[i] = i as u8;
-            i += 1;
-        }
-        hybrid_array::Array(ret)
-    };
-
-    #[test]
-    fn from_impls_for_encoded_uint() {
-        let encoded_uint = EncodedUint::from(ARRAY);
-        assert_eq!(encoded_uint.as_ref(), ARRAY.as_slice());
-
-        let array = Array::from(encoded_uint);
-        assert_eq!(array, ARRAY);
-    }
-}

src/uint.rs

@@ -8,8 +8,8 @@ pub use extra_sizes::*;
 pub(crate) use ref_type::UintRef;
 
 use crate::{
-    Bounded, Choice, ConstOne, ConstZero, Constants, CtEq, CtOption, FixedInteger, Int, Integer,
-    Limb, NonZero, Odd, One, Unsigned, Word, Zero, modular::MontyForm,
+    Bounded, Choice, ConstOne, ConstZero, Constants, CtEq, CtOption, EncodedUint, FixedInteger,
+    Int, Integer, Limb, NonZero, Odd, One, Unsigned, Word, Zero, modular::MontyForm,
 };
 use core::fmt;
 

src/uint/array.rs

@@ -1,13 +1,15 @@
 //! `hybrid-array` integration with `Uint`.
 // TODO(tarcieri): completely phase out `hybrid-array` when const generics are powerful enough
 
-use crate::{ArrayDecoding, ArrayEncoding, ByteArray};
-use hybrid_array::{Array, typenum};
+use crate::{ArrayDecoding, ArrayEncoding, ByteArray, EncodedUint, Limb};
+use hybrid_array::{Array, ArrayN, typenum};
 
 macro_rules! impl_uint_array_encoding {
     ($(($uint:ident, $bytes:path)),+) => {
         $(
-            impl ArrayEncoding for super::$uint {
+            use crate::$uint;
+
+            impl ArrayEncoding for $uint {
                 type ByteSize = $bytes;
 
                 #[inline]
@@ -36,7 +38,7 @@ macro_rules! impl_uint_array_encoding {
             }
 
             impl ArrayDecoding for Array<u8, $bytes> {
-                type Output = super::$uint;
+                type Output = $uint;
 
                 fn into_uint_be(self) -> Self::Output {
                     Self::Output::from_be_byte_array(self)
@@ -46,6 +48,24 @@ macro_rules! impl_uint_array_encoding {
                     Self::Output::from_le_byte_array(self)
                 }
             }
+
+            impl From<EncodedUint<{ $uint::LIMBS }>> for ArrayN<u8, { $uint::LIMBS * Limb::BYTES }> {
+                #[inline]
+                fn from(input: EncodedUint<{ $uint::LIMBS }>) -> Self {
+                    let mut output = Self::default();
+                    output.as_mut_slice().copy_from_slice(input.as_ref());
+                    output
+                }
+            }
+
+            impl From<ArrayN<u8, { $uint::LIMBS * Limb::BYTES }>> for EncodedUint< { $uint::LIMBS }> {
+                #[inline]
+                fn from(input: ArrayN<u8, { $uint::LIMBS * Limb::BYTES }>) -> Self {
+                    let mut output = Self::default();
+                    output.as_mut().copy_from_slice(input.as_ref());
+                    output
+                }
+            }
         )+
      };
 }
@@ -191,4 +211,31 @@ mod tests {
         let actual_bytes = expected_bytes.into_uint_le().to_le_byte_array();
         assert_eq!(expected_bytes, actual_bytes);
     }
+
+    mod encoded_uint {
+        const LIMBS: usize = 4;
+        const BYTES: usize = crate::Limb::BYTES * LIMBS;
+
+        type Array = hybrid_array::ArrayN<u8, { BYTES }>;
+        type EncodedUint = crate::EncodedUint<LIMBS>;
+
+        const ARRAY: Array = {
+            let mut i = 0;
+            let mut ret = [0u8; BYTES];
+            while i < BYTES {
+                ret[i] = i as u8;
+                i += 1;
+            }
+            hybrid_array::Array(ret)
+        };
+
+        #[test]
+        fn from_impls_for_encoded_uint() {
+            let encoded_uint = EncodedUint::from(ARRAY);
+            assert_eq!(encoded_uint.as_ref(), ARRAY.as_slice());
+
+            let array = Array::from(encoded_uint);
+            assert_eq!(array, ARRAY);
+        }
+    }
 }

src/uint/macros.rs

@@ -7,6 +7,24 @@ macro_rules! impl_uint_aliases {
             #[doc = $doc]
             #[doc="unsigned big integer."]
             pub type $name = Uint<{ nlimbs!($bits) }>;
+
+            impl From<EncodedUint<{ nlimbs!($bits) }>> for [u8; { nlimbs!($bits) * Limb::BYTES }] {
+                #[inline]
+                fn from(input: EncodedUint<{ nlimbs!($bits) }>) -> Self {
+                    let mut output = [0u8; nlimbs!($bits) * Limb::BYTES];
+                    output.as_mut_slice().copy_from_slice(input.as_ref());
+                    output
+                }
+            }
+
+            impl From<[u8; { nlimbs!($bits) * Limb::BYTES }]> for EncodedUint< { nlimbs!($bits) }> {
+                #[inline]
+                fn from(input: [u8; { nlimbs!($bits) * Limb::BYTES }]) -> Self {
+                    let mut output = Self::default();
+                    output.as_mut().copy_from_slice(input.as_ref());
+                    output
+                }
+            }
         )+
      };
 }