Discussion: Functions with many parameters about patterns HOT 9 CLOSED

pub struct DoSomething<..> { ..paramaters.. }
impl<..> DoSomething<..> {
    pub fn go(self) { ... }
}

And choose the parameter names well, so that you can maximize field puns.

If you're okay with nightly then #![feature(unboxed_closures)] and #![feature(fn_traits)] let you write DoSomething { .. }() but imho that's kinda a poor reason for going to nightly.

from patterns.

My first thought would be, would it make sense for the parameters to be part of a struct that you construct and pass in? It would depend on what the actual parameters represent of course.

Another option could potentially be the builder pattern. Something like this:

foo()
    .parameter_0(1)
    .parameter_1(2)
    .parameter_2(3)
    .parameter_3(4)
    .parameter_4(5)
    .parameter_5(6)
    .parameter_6(7)
    .build();

EDIT: See #64 for reasons against builder patterns for some use cases.

from patterns.

@longfellowone Do you have a required flow of the parameters?

Then there could be multiple structs (like a state machine) to ensure them have each mandatory parameter. Like most of the http crates that we have, it is required to have a url before sending.

from patterns.

My first thought would be, would it make sense for the parameters to be part of a struct that you construct and pass in? It would depend on what the actual parameters represent of course.

Another option could potentially be the builder pattern. Something like this:

foo()
    .parameter_0(1)
    .parameter_1(2)
    .parameter_2(3)
    .parameter_3(4)
    .parameter_4(5)
    .parameter_5(6)
    .parameter_6(7)
    .build();

EDIT: See #64 for reasons against builder patterns for some use cases.

And how would you deal with mandatory parameters?

from patterns.

And how would you deal with mandatory parameters?

I don't think I'd use it in that case.

from patterns.

And how would you deal with mandatory parameters?

foo("mandatory1", "mandatory2")
    .parameter_0(1)
    .parameter_1(2)
    .parameter_2(3)
    .parameter_3(4)
    .parameter_4(5)
    .parameter_5(6)
    .parameter_6(7)
    .build();

from patterns.

I am thinking about how to solve this issue.
Maybe we can have an anti-pattern called "Too Many Arguments In Functions"?
It could explain all the approaches proposed in this issue.

from patterns.

And how would you deal with mandatory parameters?

foo("mandatory1", "mandatory2")
    .parameter_0(1)
    .parameter_1(2)
    .parameter_2(3)
    .parameter_3(4)
    .parameter_4(5)
    .parameter_5(6)
    .parameter_6(7)
    .build();

What I have is a mathematical calculation that requires about 7 mandatory parameters that have no reasonable defaults. And 5 parameters that are optional

from patterns.

Put those 7 parameters in a struct and give the struct to foo

from patterns.