[WIP] feat: introduce ArbitraryInRange

src/error.rs

@@ -11,6 +11,8 @@ pub enum Error {
     NotEnoughData,
     /// The input bytes were not of the right format
     IncorrectFormat,
+    /// Cannot generate value in given range
+    InvalidRange,
 }
 
 impl fmt::Display for Error {
@@ -28,6 +30,7 @@ impl fmt::Display for Error {
                 f,
                 "The raw data is not of the correct format to construct this type"
             ),
+            Error::InvalidRange => write!(f, "Cannot generate a value in given range"),
         }
     }
 }

src/foreign/alloc/boxed.rs

@@ -1,44 +1,10 @@
 use {
-    crate::{size_hint, Arbitrary, Result, Unstructured},
+    crate::{Arbitrary, Result, Unstructured},
     std::boxed::Box,
 };
 
-impl<'a, A> Arbitrary<'a> for Box<A>
-where
-    A: Arbitrary<'a>,
-{
-    fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
-        Arbitrary::arbitrary(u).map(Self::new)
-    }
-
-    #[inline]
-    fn size_hint(depth: usize) -> (usize, Option<usize>) {
-        Self::try_size_hint(depth).unwrap_or_default()
-    }
-
-    #[inline]
-    fn try_size_hint(depth: usize) -> Result<(usize, Option<usize>), crate::MaxRecursionReached> {
-        size_hint::try_recursion_guard(depth, <A as Arbitrary>::try_size_hint)
-    }
-}
-
-impl<'a, A> Arbitrary<'a> for Box<[A]>
-where
-    A: Arbitrary<'a>,
-{
-    fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
-        u.arbitrary_iter()?.collect()
-    }
-
-    fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self> {
-        u.arbitrary_take_rest_iter()?.collect()
-    }
-
-    #[inline]
-    fn size_hint(_depth: usize) -> (usize, Option<usize>) {
-        (0, None)
-    }
-}
+implement_wrapped_new! { Box! }
+implement_from_iter! { Box<[A]> }
 
 impl<'a> Arbitrary<'a> for Box<str> {
     fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {

src/foreign/alloc/collections/binary_heap.rs

@@ -1,22 +1,3 @@
-use {
-    crate::{Arbitrary, Result, Unstructured},
-    std::collections::binary_heap::BinaryHeap,
-};
+use std::collections::binary_heap::BinaryHeap;
 
-impl<'a, A> Arbitrary<'a> for BinaryHeap<A>
-where
-    A: Arbitrary<'a> + Ord,
-{
-    fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
-        u.arbitrary_iter()?.collect()
-    }
-
-    fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self> {
-        u.arbitrary_take_rest_iter()?.collect()
-    }
-
-    #[inline]
-    fn size_hint(_depth: usize) -> (usize, Option<usize>) {
-        (0, None)
-    }
-}
+implement_from_iter! { BinaryHeap<A>: Ord }

src/foreign/alloc/collections/btree_set.rs

@@ -1,22 +1,3 @@
-use {
-    crate::{Arbitrary, Result, Unstructured},
-    std::collections::btree_set::BTreeSet,
-};
+use std::collections::btree_set::BTreeSet;
 
-impl<'a, A> Arbitrary<'a> for BTreeSet<A>
-where
-    A: Arbitrary<'a> + Ord,
-{
-    fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
-        u.arbitrary_iter()?.collect()
-    }
-
-    fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self> {
-        u.arbitrary_take_rest_iter()?.collect()
-    }
-
-    #[inline]
-    fn size_hint(_depth: usize) -> (usize, Option<usize>) {
-        (0, None)
-    }
-}
+implement_from_iter! { BTreeSet<A>: Ord }

src/foreign/alloc/collections/linked_list.rs

@@ -1,22 +1,3 @@
-use {
-    crate::{Arbitrary, Result, Unstructured},
-    std::collections::linked_list::LinkedList,
-};
+use std::collections::linked_list::LinkedList;
 
-impl<'a, A> Arbitrary<'a> for LinkedList<A>
-where
-    A: Arbitrary<'a>,
-{
-    fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
-        u.arbitrary_iter()?.collect()
-    }
-
-    fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self> {
-        u.arbitrary_take_rest_iter()?.collect()
-    }
-
-    #[inline]
-    fn size_hint(_depth: usize) -> (usize, Option<usize>) {
-        (0, None)
-    }
-}
+implement_from_iter! { LinkedList<A> }

src/foreign/alloc/collections/vec_deque.rs

@@ -1,22 +1,3 @@
-use {
-    crate::{Arbitrary, Result, Unstructured},
-    std::collections::vec_deque::VecDeque,
-};
+use std::collections::vec_deque::VecDeque;
 
-impl<'a, A> Arbitrary<'a> for VecDeque<A>
-where
-    A: Arbitrary<'a>,
-{
-    fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
-        u.arbitrary_iter()?.collect()
-    }
-
-    fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self> {
-        u.arbitrary_take_rest_iter()?.collect()
-    }
-
-    #[inline]
-    fn size_hint(_depth: usize) -> (usize, Option<usize>) {
-        (0, None)
-    }
-}
+implement_from_iter! { VecDeque<A> }

src/foreign/alloc/rc.rs

@@ -1,44 +1,10 @@
 use {
-    crate::{size_hint, Arbitrary, Result, Unstructured},
+    crate::{Arbitrary, Result, Unstructured},
     std::rc::Rc,
 };
 
-impl<'a, A> Arbitrary<'a> for Rc<A>
-where
-    A: Arbitrary<'a>,
-{
-    fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
-        Arbitrary::arbitrary(u).map(Self::new)
-    }
-
-    #[inline]
-    fn size_hint(depth: usize) -> (usize, Option<usize>) {
-        Self::try_size_hint(depth).unwrap_or_default()
-    }
-
-    #[inline]
-    fn try_size_hint(depth: usize) -> Result<(usize, Option<usize>), crate::MaxRecursionReached> {
-        size_hint::try_recursion_guard(depth, <A as Arbitrary>::try_size_hint)
-    }
-}
-
-impl<'a, A> Arbitrary<'a> for Rc<[A]>
-where
-    A: Arbitrary<'a>,
-{
-    fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
-        u.arbitrary_iter()?.collect()
-    }
-
-    fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self> {
-        u.arbitrary_take_rest_iter()?.collect()
-    }
-
-    #[inline]
-    fn size_hint(_depth: usize) -> (usize, Option<usize>) {
-        (0, None)
-    }
-}
+implement_wrapped_new! { Rc! }
+implement_from_iter! { Rc<[A]> }
 
 impl<'a> Arbitrary<'a> for Rc<str> {
     fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {

src/foreign/alloc/string.rs

@@ -1,8 +1,20 @@
 use {
-    crate::{Arbitrary, Result, Unstructured},
-    std::string::String,
+    crate::{Arbitrary, ArbitraryInRange, Result, Unstructured},
+    std::{ops::RangeBounds, string::String},
 };
 
+impl<'a> ArbitraryInRange<'a> for String {
+    type Bound = char;
+
+    fn arbitrary_in_range<R>(u: &mut Unstructured<'a>, range: &R) -> Result<Self>
+    where
+        R: RangeBounds<Self::Bound>,
+    {
+        u.arbitrary_in_range_iter::<Self::Bound, _>(range)?
+            .collect()
+    }
+}
+
 impl<'a> Arbitrary<'a> for String {
     fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
         <&str as Arbitrary>::arbitrary(u).map(Into::into)

src/foreign/alloc/sync.rs

@@ -1,44 +1,10 @@
 use {
-    crate::{size_hint, Arbitrary, Result, Unstructured},
+    crate::{Arbitrary, Result, Unstructured},
     std::sync::Arc,
 };
 
-impl<'a, A> Arbitrary<'a> for Arc<A>
-where
-    A: Arbitrary<'a>,
-{
-    fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
-        Arbitrary::arbitrary(u).map(Self::new)
-    }
-
-    #[inline]
-    fn size_hint(depth: usize) -> (usize, Option<usize>) {
-        Self::try_size_hint(depth).unwrap_or_default()
-    }
-
-    #[inline]
-    fn try_size_hint(depth: usize) -> Result<(usize, Option<usize>), crate::MaxRecursionReached> {
-        size_hint::try_recursion_guard(depth, <A as Arbitrary>::try_size_hint)
-    }
-}
-
-impl<'a, A> Arbitrary<'a> for Arc<[A]>
-where
-    A: Arbitrary<'a>,
-{
-    fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
-        u.arbitrary_iter()?.collect()
-    }
-
-    fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self> {
-        u.arbitrary_take_rest_iter()?.collect()
-    }
-
-    #[inline]
-    fn size_hint(_depth: usize) -> (usize, Option<usize>) {
-        (0, None)
-    }
-}
+implement_wrapped_new! { Arc! }
+implement_from_iter! { Arc<[A]> }
 
 impl<'a> Arbitrary<'a> for Arc<str> {
     fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {

src/foreign/alloc/vec.rs

@@ -1,22 +1,3 @@
-use {
-    crate::{Arbitrary, Result, Unstructured},
-    std::vec::Vec,
-};
+use std::vec::Vec;
 
-impl<'a, A> Arbitrary<'a> for Vec<A>
-where
-    A: Arbitrary<'a>,
-{
-    fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
-        u.arbitrary_iter()?.collect()
-    }
-
-    fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self> {
-        u.arbitrary_take_rest_iter()?.collect()
-    }
-
-    #[inline]
-    fn size_hint(_depth: usize) -> (usize, Option<usize>) {
-        (0, None)
-    }
-}
+implement_from_iter! { Vec<A> }

src/foreign/core/array.rs

@@ -1,5 +1,5 @@
 use {
-    crate::{size_hint, Arbitrary, Result, Unstructured},
+    crate::{size_hint, Arbitrary, ArbitraryInRange, Result, Unstructured},
     core::{
         array,
         mem::{self, MaybeUninit},
@@ -45,20 +45,47 @@ where
     }
 }
 
+impl<'a, T, const N: usize> ArbitraryInRange<'a> for [T; N]
+where
+    T: ArbitraryInRange<'a>,
+{
+    type Bound = T::Bound;
+
+    #[inline]
+    fn arbitrary_in_range<R>(u: &mut Unstructured<'a>, range: &R) -> Result<Self>
+    where
+        R: std::ops::RangeBounds<Self::Bound>,
+    {
+        try_create_array(|_| T::arbitrary_in_range(u, range))
+    }
+
+    #[inline]
+    fn arbitrary_in_range_take_rest<R>(mut u: Unstructured<'a>, range: &R) -> Result<Self>
+    where
+        R: std::ops::RangeBounds<Self::Bound>,
+    {
+        let mut array = Self::arbitrary_in_range(&mut u, range)?;
+        if let Some(last) = array.last_mut() {
+            *last = T::arbitrary_in_range_take_rest(u, range)?;
+        }
+        Ok(array)
+    }
+}
+
 impl<'a, T, const N: usize> Arbitrary<'a> for [T; N]
 where
     T: Arbitrary<'a>,
 {
     #[inline]
     fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
-        try_create_array(|_| <T as Arbitrary<'a>>::arbitrary(u))
+        try_create_array(|_| T::arbitrary(u))
     }
 
     #[inline]
     fn arbitrary_take_rest(mut u: Unstructured<'a>) -> Result<Self> {
         let mut array = Self::arbitrary(&mut u)?;
         if let Some(last) = array.last_mut() {
-            *last = Arbitrary::arbitrary_take_rest(u)?;
+            *last = T::arbitrary_take_rest(u)?;
         }
         Ok(array)
     }
@@ -70,7 +97,7 @@ where
 
     #[inline]
     fn try_size_hint(depth: usize) -> Result<(usize, Option<usize>), crate::MaxRecursionReached> {
-        let hint = <T as Arbitrary>::try_size_hint(depth)?;
+        let hint = T::try_size_hint(depth)?;
         Ok(size_hint::and_all(&array::from_fn::<_, N, _>(|_| hint)))
     }
 }