Const generic arbitrary

[cameron1024]

In the previous ticket, I added Strategy impls for const generic arrays of strategies, but forgot about Arbitrary 🤦

This one adds Arbitrary impls for const generic arrays of types which impl Arbitrary.

As with the previous PR, I don't think this is a breaking change.

[rex-remind101]

just to make sure i'm understanding, this change makes it so that Arbitrary is inherited across the board for const generic arrays so the user doesn't need to use a macro?

if so seems good to me. one thing i've noticed though is the macro arbitrary! seems to be used for these declarations internally instead. however, it seems pretty simple to just inherit the trait directly like you have here so i don't have a problem with that.

[cameron1024]

I don't think that's quite right:

The array macro only serves to write boilerplate impls.

It's roughly equivalent to :

impl<A: Arbitrary> Arbitrary for [A; 1] { ... }
impl<A: Arbitrary> Arbitrary for [A; 2] { ... }
// ...
impl<A: Arbitrary> Arbitrary for [A; 32] { ... }

except with less typing. array! was never exposed to users. There wasn't a macro they could use. Instead, they just couldn't have Arbitrary impls for arrays longer than 32 elements

The new code uses const generics to provide impls for [A; N], regardless the value of N.

Another way of thinking about it is that the previous code was a bit like this hypothetical syntax:

impl<A: Arbitrary, const N: usize> Arbitrary for [A; N] where A >= 1, A <= 32 {}

and this PR just removes that where clause. Of course this isn't supported at the language level, but conceptually we're just relaxing a constraint, so it shouldn't break compat

As for arbitrary!, I haven't looked at it in great detail, but I generally find looking at decl-macros that I didn't write pretty tricky, and avoid them where possible. IMO, this impl is pretty self-describing and readable

[rex-remind101]

Thanks for the explanation, that all makes good sense to me :)

[matthew-russo]

looks good to me