Why can't a range of char be collected?

问题

I'm trying to generate a vector containing lowercase ASCII characters. This more convoluted approach works:

let ascii_lowercase = (b'a'..=b'z').map(|b| b as char).collect::<Vec<char>>();

But this more straightforward one, which I came up with in the first place, does not:

let ascii_lowercase = ('a'..='z').collect::<Vec<char>>();

The error is:

error[E0599]: no method named `collect` found for type `std::ops::RangeInclusive<char>` in the current scope
 --> src/main.rs:2:39
  |
2 |     let ascii_lowercase = ('a'..='z').collect::<Vec<char>>();
  |                                       ^^^^^^^
  |
  = note: the method `collect` exists but the following trait bounds were not satisfied:
          `std::ops::RangeInclusive<char> : std::iter::Iterator`
          `&mut std::ops::RangeInclusive<char> : std::iter::Iterator`

Which is weird, because as far as I understand, there is a blanket implementation of Iterator for RangeInclusive.

Is it impossible to use a range of chars as an iterator? If so, why? If not, what am I doing wrong? I'm using stable Rust 2018 1.31.1.

回答1:

The expression b'a'..=b'z' has the type RangeInclusive<u8> (see on Playground) because the expression b'a' has the type u8: that's what the b in front of the character literal is for. On the other hand, the expression 'a'..='z' (without the bs) has the type RangeInclusive<char>.

[...] there is a blanket implementation of Iterator for RangeInclusive.

For one, this is not what we call "blanket implementation" (this is when the impl block is for T or for &T (or similar) with T being a generic type). But yes, there is an impl. But let's take a closer look:

impl<A> Iterator for RangeInclusive<A> 
where
    A: Step,   // <--- important

The A: Step bound is important. As you can see in the documentation for Step, this trait is implemented for all primitive integer types, but not for char. This means that there is no clear "add one" operation on characters. Yes, you could define it to be the next valid Unicode codepoint, but the Rust developers probably decided against that for a good reason.

As a consequence, RangeInclusive<char> does not implement Iterator.

So your solution is already a good one. I would probably write this:

(b'a'..=b'z').map(char::from).collect::<Vec<_>>()

The only real advantage is that in this version, char doesn't appear twice.

来源：https://stackoverflow.com/questions/53971954/why-cant-a-range-of-char-be-collected

标签

collections

rust

iterator