How to overload the 'new' method?

Question

I\'m just started to learn Rust and I\'m wondering if there is way to overload methods. At first I created a struct and used a \'impl\' to implement basic \'new\' method. Th

Answer 1

Rust indeed has overloading via traits, but you can't change the number of parameters, and their types can only be changed if they were declared as generic on the first place in the trait definition.

In cases like yours, it's common to have a method like new_with_nouns to specialize what you mean:

impl<'a> Words<'a> {
    fn new() -> Words { /* ... */ }
    fn new_with_nouns(nouns: Vec<&'a str>) -> Words<'a> { /* ... */ }
}

For more complex data structures, where the new_with_something pattern would lead to a combinatorial explosion, the builder pattern is common (here I'll assume that Words has a separator field, just to demonstrate):

struct WordsBuilder<'a> {
    separator: Option<&'a str>,
    nouns: Option<Vec<&'a str>>,
}

impl<'a> WordsBuilder<'a> {
    fn new() -> WordsBuilder<'a> {
        WordsBuilder { separator: None, nouns: None }
    }

    fn nouns(mut self, nouns: Vec<&'a str>) -> WordsBuilder<'a> {
        self.nouns = Some(nouns);
        self
    }

    fn separator(mut self, separator: &'a str) -> WordsBuilder<'a> {
        self.separator = Some(separator);
        self
    }

    fn build(self) -> Words<'a> {
        Words {
            separator: self.separator.unwrap_or(","),
            nouns:     self.nouns.unwrap_or_else(|| {
                vec!["test1", "test2", "test3", "test4"]
            })
        }
    }
}

This is similar to how the stdlib's thread::Builder works, for example.