The general problem here is that an array has a fixed size, known at compile-time, but the number of items in an iterator is not known at compile-time — even if it is an ExactSizeIterator, there's no const parameter for the size. Therefore, there are no infallible conversions from an iterator to an array.
However, there are fallible conversions available. The most straightforward commonly-useful one is impl<T, A, const N: usize> TryFrom<Vec<T, A>> for [T; N], which allows you to convert a Vec<T> to [T; N], failing if the vector is of the wrong length.
use std::convert::TryInto;
let arr: [i32; 5] = (1..=5).collect::<Vec<_>>()
.try_into().expect("wrong size iterator");
This has the disadvantage of making a temporary heap allocation for the Vec and discarding it. If you do want the array to live on the heap, then you might want to use TryFrom<Box<[T], Global>> for Box<[T; N], Global> instead, which allows you to get a boxed array from a boxed slice.
let arr: Box<[i32; 5]> = (1..=5)
.collect::<Box<[i32]>>()
.try_into().expect("wrong size iterator");
If you want the array to be stack allocated and to avoid temporary allocations, then you will have to work with std::iter::from_fn(), slightly awkwardly:
let mut iter = 1..=5;
let arr: [i32; 5] = std::array::from_fn(|_| iter.next().expect("too short"));
assert!(iter.next().is_none(), "too long");
(If you're confident in the length then there's no need to assert afterward, but an expect/unwrap inside is unavoidable.)
The second problem is trying to initialize an array from a simple map over an array on i32. This doesn't work:
let mut arr2: [i32; 5] = arr.iter().map(|&x| x + 1).collect();
This doesn't work for the same reason as the first: you can't currently collect directly into an array. Any of the techniques I mentioned above will also work for this case.
Since this question and answer were originally written, arrays have now gained a method map which you can use to do this without going through an iterator:
let mut arr2: [i32; 5] = arr.map(|x| x + 1);
Indeed even printing (without assigning) doesn't work:
This is actually a different problem than the others. println!("{:?}", some_iterator.collect()) will always fail, because you haven't specified what type to collect into. collect() never assumes a collection type; it always has to be specified or inferred from context.
If you specify a type, then you can print the results of the iterator; whether the original input was an array is irrelevant.
println!("{:?}", arr.iter().map(|&x| x + 1).collect::<Vec<_>>());
