Functions that may or may not take an argument - rust

Question

I'm designing an API and I currently wish to have a function that may or may not accept an argument with default behavior for empty arguments. Using enums works ok, but that requires the user to enter certain arguments which will add up quickly. My current implementation is this:
enum ArgType {
Square,
Circle,
Triangle,
}
fn draw_image(arg: ArgType) {
match arg {
ArgType::Square => println!("Square!"),
ArgType::Circle => println!("Circle!"),
ArgType::Triangle => println!("Triangle!"),
_ => println!("Empty argument, initiating default behavior!"),
}
}
fn main() {
let circle = ArgType::Triangle;
draw_image(Triangle);
draw_image(); // Does not compile
}

Answer 1

You could use an Option<T>.
fn draw_image(arg: Option<ArgType>) {
match arg.unwrap_or(ArgType::DefaultArgType) {
ArgType::Square => println!("Square!"),
ArgType::Circle => println!("Circle!"),
ArgType::Triangle => println!("Triangle!"),
}
}
//...
draw_image(Some(ArgType::Circle));
draw_image(None); // will use the default ArgType
If you don't want to use a default ArgType, but instead want a completely separate functionality, I'd just define another function that immediately invokes the default behaviour.
fn draw_image_default() {
//...
}

Answer 2

What you are describing is a functionality called "function overloading".
Rust explicitely does not allow that. A longer discussion about the reasoning behind it can be found here.
As a direct alternative, you can represent optional parameters via the Option type. It can either be Some(value) or None.
With it, your code would look like this:
pub enum ArgType {
Square,
Circle,
Triangle,
}
fn draw_image(arg: Option<ArgType>) {
match arg {
Some(ArgType::Square) => println!("Square!"),
Some(ArgType::Circle) => println!("Circle!"),
Some(ArgType::Triangle) => println!("Triangle!"),
None => println!("Empty argument, initiating default behavior!"),
}
}
fn main() {
let triangle = ArgType::Triangle;
draw_image(Some(triangle));
draw_image(None);
}
Triangle!
Empty argument, initiating default behavior!

Answer 3

As others have said, function overloading is not possible in Rust and you can use Option to represent optional parameters. However this can be unwieldy if you have a lot of parameters and you expect that your users will only use a few at a time. In that case, typing all the None values for the other parameters can be quite tedious. In order to avoid that you can use the builder pattern, where you initialize a struct with the default values, then call methods to set the parameters you want and have an execute method to do the work:
#[derive (Debug)]
pub enum ArgType {
Default,
Square,
Circle,
Triangle,
}
#[derive (Debug)]
pub enum ArgColor {
Default,
White,
Black,
}
pub struct ImageDraw {
ty: ArgType,
col: ArgColor,
// ...
}
impl ImageDraw {
fn default() -> Self {
ImageDraw { ty: ArgType::Default, col: ArgColor::Default, /* ... */ }
}
fn with_type (self, ty: ArgType) -> Self {
ImageDraw { ty, ..self }
}
fn with_color (self, col: ArgColor) -> Self {
ImageDraw { col, ..self }
}
fn draw (self) {
println!("Drawing {:?} in {:?}", self.ty, self.col);
}
}
fn main() {
ImageDraw::default()
.with_type (ArgType::Triangle)
.with_color (ArgColor::White)
.draw();
ImageDraw::default()
.with_type (ArgType::Circle)
.draw();
ImageDraw::default()
.with_color (ArgColor::Black)
.draw();
}
Playground