Rust Currying with Default Arguments

Currying is a technique in functional programming that allows a function to be partially applied by fixing some of its arguments, resulting in a new function that takes in the remaining arguments. Rust provides support for currying through the use of closures and partial function application.

In this tutorial, we'll explore how to use Rust's currying features to define functions with default arguments.

Defining a Curried Function

To define a curried function in Rust, we can use closures and partial application. Here's an example that defines a function that takes two arguments:

fn add(x: i32, y: i32) -> i32 {
    x + y
}

let add_two = |x| |y| add(x, y);

assert_eq!(add_two(2)(3), 5);

In this example, we define a closure that takes in an x argument and returns another closure that takes in a y argument. The inner closure calls the add function with both arguments and returns the result.

To use this curried function, we can first call it with one argument to get a new closure that takes the second argument:

let add_to_two = add_two(2);

assert_eq!(add_to_two(3), 5);

Adding Default Arguments

To add default arguments to a curried function, we can simply use the |x| ... syntax to specify the default value for x:

let add_with_default = |x = 0| |y| add(x, y);

assert_eq!(add_with_default()(3), 3);
assert_eq!(add_with_default(2)(3), 5);

In this example, we define a new closure add_with_default that has a default value of 0 for the x argument. When called with no arguments, this closure returns another closure that takes in the y argument and calls the add function with the default value of x and y. If called with one argument, the closure returns another closure that takes in the y argument and calls add with the given x and y values.

Conclusion

Currying is a powerful tool for creating modular, reusable functions. By using closures and partial application, Rust makes it easy to define curried functions with default arguments. With these features, you can create flexible, configurable functions that can be used in a wide variety of contexts.