How do I collect from multiple iterator types?

Question

I am attempting to implement a new trait for a String that has a function that capitalizes the first letter of each String and un-capitalizes the rest. I am basing the function's interface on to_uppercase() and to_lowercase() in the Rust Standard Library.

use std::io;

trait ToCapitalized {
    fn to_capitalized(&self) -> String;
}

impl ToCapitalized for String {
    fn to_capitalized(&self) -> String {
        self.chars().enumerate().map(|(i, c)| {
            match i {
                0 => c.to_uppercase(),
                _ => c.to_lowercase(),
            }
        }).collect()
    }
}

fn main() {
    let mut buffer = String::new();
    io::stdin().read_line(&mut buffer).ok().expect("Unable to read from stdin.");

    println!("{}", buffer.to_capitalized());
}

This code is based on a suggestion given here, but the code is outdated and causes multiple compilation errors. The only issue I am having with my implementation now is the following error:

src/main.rs:10:13: 13:14 error: match arms have incompatible types [E0308]
src/main.rs:10             match i {
                           ^
src/main.rs:10:13: 13:14 help: run `rustc --explain E0308` to see a detailed explanation
src/main.rs:10:13: 13:14 note: expected type `std::char::ToUppercase`
src/main.rs:10:13: 13:14 note:    found type `std::char::ToLowercase`
src/main.rs:12:22: 12:38 note: match arm with an incompatible type
src/main.rs:12                 _ => c.to_lowercase(),

So in short, the return values of fn to_uppercase(&self) -> ToUppercase and fn to_lowercase(&self) -> ToLowercase can't be collected together because the map now has multiple return types.

I've attempted trying to cast them to another common Iterator type such as Bytes and Chars, but these iterator types can't be collected to form a String. Any suggestions?

Dogbert · Answer 1 · 2016-07-13T05:02:26.987

2

Here's how I would do it:

trait ToCapitalized {
    fn to_capitalized(&self) -> String;
}

impl ToCapitalized for String {
    fn to_capitalized(&self) -> String {
        match self.chars().next() {
            Some(c) => {
                c.to_uppercase()
                    .chain(self.chars().skip(1).flat_map(|c| c.to_lowercase()))
                    .collect()
            }
            None => String::new(),
        }
    }
}

fn main() {
    println!("{}", "fOoBaR".to_string().to_capitalized());
}

This will be a little slower than the ideal solution, as it decodes the first char twice, but it's quite readable IMO.

Output:

Foobar

edited Jul 13 '16 at 05:02

answered Jul 13 '16 at 04:56

Dogbert

212,659
41
396
397

@Jared it won't leak memory (the Boxes would get deallocated as soon as `collect` is done using them), but it would be terribly inefficient. Please see the edited answer. – Dogbert Jul 13 '16 at 05:03

score 2 · Answer 2 · answered Jul 13 '16 at 04:59

Casting is rarely a good approach to solving type issues in Rust. The correct solution here would be to write (or find a crate that defines) a type that unifies disparate iterator types. But that would require effort, so it's simpler to just throw collect out the window:

trait ToCapitalized {
    fn to_capitalized(&self) -> String;
}

impl ToCapitalized for String {
    fn to_capitalized(&self) -> String {
        let mut r = String::with_capacity(self.len());
        for (i, c) in self.chars().enumerate() {
            match i {
                0 => r.extend(c.to_uppercase()),
                _ => r.extend(c.to_lowercase()),
            }
        }
        r
    }
}

fn main() {
    let buffer = String::from("canberra");
    println!("{}", buffer.to_capitalized());
}

This is, more or less, what collect would do anyway if you had some type to represent "either ToUppercase or ToLowercase". In the vast majority of cases, this will also only perform a single allocation.

There probably is an Iterator type somewhere in the stdlib, but I doubt any of us will be able to find it. Honestly, I feel that there are too many, but I digress. This looks like the best solution because it simply forgoes the collect call for a similar for loop, which I think would be the smartest approach. Thanks for your input. — Jared, Jul 13 '16 at 05:04

Jared · Accepted Answer · 2016-07-16T04:19:21.787

After looking at the implementation for pub fn to_uppercase(&self) -> String here, I devised a solution that is a bit of a hybrid between Dogbert and DK.'s solutions and the implementation given in the standard library. It even works with Unicode!

fn to_capitalized(&self) -> String {
    match self.len() {
        0 => String::new(),
        _ => {
            let mut s = String::with_capacity(self.len());
            s.extend(self.chars().next().unwrap().to_uppercase());
            s.extend(self.chars().skip(1).flat_map(|c| c.to_lowercase()));
            return s;
        }
    }
}

Working Rust Playground Example

Edit: For greater visibility, Shepmaster's simplified and optimized solution:

fn to_capitalized(&self) -> String {
    let mut s = String::with_capacity(self.len());
    let mut chars = self.chars(); 

    s.extend(chars.by_ref().take(1).flat_map(|c| c.to_uppercase()));
    s.extend(chars.flat_map(|c| c.to_lowercase()));

    s
}

[Can be simplified and slightly optimized](https://play.rust-lang.org/?gist=dfa85b1d5e07d8e5e29785c5e530ee76). — Shepmaster, Jul 13 '16 at 12:00

How do I collect from multiple iterator types?

3 Answers3

Linked