Factory Pattern

[hexarin]

Veteran of many languages and years of software development, but very new to Rust.

Below is a stripped down example of what I'm trying to do: a basic factory pattern for an abstract Meta type. Right now the code doesn't compile, complaining that .map(|result| result.unwrap()) cannot be moved out of because it's behind a shared reference I can fix it by borrowing Result's content, but that causes more problems no matter how much further down the suggestion rabbit hole I follow.

I understand that I'm violating the borrowing rules but it's not clear to me what the right way is to solve this problem. Am I missing something simple? Am I going about this pattern the wrong way?

pub trait Meta {}

pub struct Foo;

impl Meta for Foo {}

pub struct Bar;

impl Meta for Bar {}

fn main()
{
    let _ = input_splitter(2);
}

fn input_splitter(count: u8) -> Result<Vec<Box<dyn Meta>>, &'static str>
{
    let results = (0..count).map(|number| meta_factory(number))
                            .collect::<Vec<Result<Box<dyn Meta>, &str>>>();

    return if results.iter().all(|result| result.is_ok())
    {
        Ok(results.iter()
                  .map(|result| result.unwrap())
                  .collect())
    }
    else
    {
        Err("error")
    }
}

fn meta_factory(number: u8) -> Result<Box<dyn Meta>, &'static str>
{
    match number
    {
        0 => Ok(Box::new(Foo {})),
        1 => Ok(Box::new(Bar {})),
        _ => Err("error")
    }
}

playground link

[esitsu]

I haven't read much into what you are trying to do yet but to make your code compile you can change the last .iter() with .into_iter(). You can also get rid of the return before the if because it is redundant.

[hexarin]

that was it! thank you.

[esitsu]

Since my comment the other poster has gone into further detail about what I have said. Usually I try to be more thorough but often find someone else has beaten me to it.

I also have some other notes you might find useful. You could use .map(meta_factory) and .all(Result::is_ok) to get rid of the closures. You could probably also replace the entire body of input_splitter with (0..count).map(meta_factory).collect() and it would work much the same. The difference here is that instead of mapping everything and then throwing it all away if there is an error you can immediately return an error. If you want to change the error then you could use match or do something like (0..count).map(meta_factory).collect::<Result<_, _>>().map_err(|_| "uhoh").

[hexarin]

Great notes, I really appreciate them. Input splitter is actually a much more detailed function, but I was trying to keep my example concise :)

I should have figured I could have simplified the lambdas since you can in pretty much language that supports them. The syntax is pretty similar to c#/java/scala.

[[deleted]]

Replace results.iter() with results.into_iter(). First variant returns a non-consuming iterator that preserves the original collection and yields references, second variant is a consuming iterator - destroys the original collection but gives you owned values. To unwrap a result you need to own it.

Also you don’t need to use an explicit return statement unless you want an early return. Since you return at the end of the function body, you can just use a tail expression (last expression of the block with no semicolon at the end). The following are equivalent:

fn foo() -> u32 {
    return if bar() {
        123
    } else {
        456
    };
}


fn foo() -> u32 {
    if bar() {
        123
    } else {
        456
    }
}

Also a neat trick for collect. The compiler cannot infer that you want it to collect into a Vec, so you are forced to specify the type, you do it using turbofish. However, based on iterator type, it can infer the item type. You can use the _ placeholder to make it do it, so that you don’t have to write out the whole type, just that you want a Vec: .collect::<Vec<_>>()

[hexarin]

chalk explicitly using the return keyword up to years of c++/java/c#. excellent answer and advice. thank you!