Implemented Default for arrays up to [T; 32]

[withoutboats]

Implemented Default for arrays up to length 32 where T: Default using an additional macro.

[rust-highfive]

Thanks for the pull request, and welcome! The Rust team is excited to review your changes, and you should hear from @brson (or someone else) soon.

If any changes to this PR are deemed necessary, please add them as extra commits. This ensures that the reviewer can see what has changed since they last reviewed the code. The way Github handles out-of-date commits, this should also make it reasonably obvious what issues have or haven't been addressed. Large or tricky changes may require several passes of review and changes.

Please see the contribution instructions for more information.

[marcusklaas]

I'm not sure how exactly array_impls! works, but I think it should be possible to create array literals in macros.

[alexcrichton]

Could this reduce the verbosity a bit by taking a strategy similar to this peel! macro?

[withoutboats]

@alexcrichton I don't think so, because array syntax requires that each successive macro invocation insert a different integer literal.

I have managed to shorten it by removing all the ::default() calls. Now each macro invocation fits on one line, at least.

EDIT: well, maybe there's a way that's a bit more complicated than that, let me sketch it out and see.

@marcusklaas the problem with creating array literals is that for each item in the array, the macro invocation needs a token to expand to (unless the array is restricted to Copy types). You can see in the commit that, for example, the 32-len array needs 32 Ts, and the 31-len array needs 31 Ts.

---

Not clear on the stability tagging scheme and if this impl needs to be tagged with something. #[stable(since = "1.4.0")]?

[marcusklaas]

@withoutboats You're almost there! You can 'dynamically' create the integers by using peel!'s strategy. You have to pass along a $counter:expr argument to your macro, which you can either increment of decrement by 1 with each recursion!

I'll try to make something in play.

edit2: it works: https://play.rust-lang.org/?gist=33022e935f049b9a8e8c&version=nightly

[withoutboats]

Okay, this should be good now. I had no idea that [T; 2 + 2] was a valid type.

[alexcrichton]

Thanks! Could you also:

• Squash these commits together
• Tag the impl blocks with #[stable(since = "1.4.0", feature = "array_default")]

[withoutboats]

Done. 😄

[alexcrichton]

@bors: r+ 975a8ed

[bors]

⌛ Testing commit 975a8ed with merge 1e1b7f3...

[bors]

☀️ Test successful - auto-linux-32-nopt-t, auto-linux-32-opt, auto-linux-64-nopt-t, auto-linux-64-opt, auto-linux-64-x-android-t, auto-mac-32-opt, auto-mac-64-nopt-t, auto-mac-64-opt, auto-win-gnu-32-nopt-t, auto-win-gnu-32-opt, auto-win-gnu-64-nopt-t, auto-win-gnu-64-opt, auto-win-msvc-32-opt, auto-win-msvc-64-opt

[andrey-gvrd]

Can you give an example of usage? My attempt:

#[feature(array_default)]
fn main() {
    let mut s: [String; 2] = [Default::default(); 2];
}

Doesn't seem to work. I'm on rustc 1.5.0 (3d7cd77e4 2015-12-04).

[jonas-schievink]

@andrey-gvrd String isn't Copy. Quoting the array docs:

Arrays values are created either with an explicit expression that lists each element: [x, y, z] or a repeat expression: [x; N]. The repeat expression requires that the element type is Copy.

Use vec![Default::default(); 2] to create a Vec<String> instead.

[withoutboats]

@andrey-gvrd The way to use this is actually let mut s: [String; 2] = Default::default();. You do not need to use the array declaration syntax. You also don't need to use a feature, because this impl is stable.