Produce Option<Vec<String>> out of an Option<Vec<Custom>> in Rust

Question

I'm trying to do the equivalent of Ruby's Enumerable.collect() in Rust.

I have an Option<Vec<Attachment>> and I want to create a Option<Vec<String>> from it, with String::new() elements in case of None guid.

#[derive(Debug)]
pub struct Attachment {
    pub guid: Option<String>,
}

fn main() {
    let ov: Option<Vec<Attachment>> =
        Some(vec![Attachment { guid: Some("rere34r34r34r34".to_string()) },
                  Attachment { guid: Some("5345345534rtyr5345".to_string()) }]);

    let foo: Option<Vec<String>> = match ov {
        Some(x) => {
            x.iter()
                .map(|&attachment| attachment.guid.unwrap_or(String::new()))
                .collect()
        }
        None => None,
    };
}

The error in the compiler is clear:

error[E0277]: the trait bound `std::option::Option<std::vec::Vec<std::string::String>>: std::iter::FromIterator<std::string::String>` is not satisfied
  --> src/main.rs:15:18
   |
15 |                 .collect()
   |                  ^^^^^^^ the trait `std::iter::FromIterator<std::string::String>` is not implemented for `std::option::Option<std::vec::Vec<std::string::String>>`
   |
   = note: a collection of type `std::option::Option<std::vec::Vec<std::string::String>>` cannot be built from an iterator over elements of type `std::string::String`

If I remember what I've read from the documentation so far, I cannot implement traits for struct that I don't own.

How can I do this using iter().map(...).collect() or maybe another way?

Answer 1

Here is a solution that works:

#[derive(Debug)]
pub struct Attachment {
    pub guid: Option<String>,
}

fn main() {
    let ov: Option<Vec<Attachment>> =
        Some(vec![Attachment { guid: Some("rere34r34r34r34".to_string()) },
                  Attachment { guid: Some("5345345534rtyr5345".to_string()) }]);

    let foo: Option<Vec<_>> = ov.map(|x|
        x.iter().map(|a| a.guid.as_ref().unwrap_or(&String::new()).clone()).collect());

    println!("{:?}", foo);
}

One of the issues with the above code is stopping the guid being moved out of the Attachment and into the vector. My example calls clone to move cloned instances into the vector.

This works, but I think it looks nicer wrapped in a trait impl for Option<T>. Perhaps this is a better ... option ...:

trait CloneOr<T, U>
    where U: Into<T>,
          T: Clone
{
    fn clone_or(&self, other: U) -> T;
}

impl<T, U> CloneOr<T, U> for Option<T>
    where U: Into<T>,
          T: Clone
{
    fn clone_or(&self, other: U) -> T {
        self.as_ref().unwrap_or(&other.into()).clone()
    }
}

#[derive(Debug)]
pub struct Attachment {
    pub guid: Option<String>,
}

fn main() {
    let ov: Option<Vec<Attachment>> =
        Some(vec![Attachment { guid: Some("rere34r34r34r34".to_string()) },
                  Attachment { guid: Some("5345345534rtyr5345".to_string()) },
                  Attachment { guid: None }]);

    let foo: Option<Vec<_>> =
        ov.map(|x| x.iter().map(|a| a.guid.clone_or("")).collect());

    println!("{:?}", foo);
}

Essentially the unwrapping and cloning is hidden behind a trait implementation that attaches to Option<T>.

Here it is running on the playground.

Answer 2

You should read and memorize all of the methods on Option (and Result). These are used so pervasively in Rust that knowing what is present will help you immensely.

For example, your match statement is Option::map.

Since you never said you couldn't transfer ownership of the Strings, I'd just do that. This will avoid any extra allocation:

let foo: Option<Vec<_>> =
    ov.map(|i| i.into_iter().map(|a| a.guid.unwrap_or_else(String::new)).collect());

Note we don't have to specify the type inside the Vec; it can be inferred.

You can of course introduce functions to make it cleaner:

impl Attachment {
    fn into_guid(self) -> String {
        self.guid.unwrap_or_else(String::new)
    }
}

// ...

let foo: Option<Vec<_>> = ov.map(|i| i.into_iter().map(Attachment::into_guid).collect());

If you don't want to give up ownership of the String, you can do the same concept but with a string slice:

impl Attachment {
    fn guid(&self) -> &str {
        self.guid.as_ref().map_or("", String::as_str)
    }
}

// ...    

let foo: Option<Vec<_>> = ov.as_ref().map(|i| i.iter().map(|a| a.guid().to_owned()).collect());

Here, we have to use Option::as_ref to avoid moving the guid out of the Attachment, then convert to a &str with String::as_str, providing a default value. We likewise don't take ownership of the Option of ov, and thus need to iterate over references, and ultimately allocate new Strings with ToOwned.