13 February 2023
Functions are a pretty basic feature of Rust and I’ve obviously been using them already. But there’s still some details that I want to go over before moving on to methods and closures.
Here’s a basic function:
fn add(a: i32, b: i32) -> i32 {
a + b
}
A function definition is introduced by the fn keyword. It has a name, a list of
parameters, each with a type, a return type, and a body that’s executed when the function is called.
The body consists of a list of statements separated by semicolons. The return value is either the
value of the last statement or a value returned explicitly with a return statement.
You always have to provide the types for parameters and return values since type inference in Rust is always limited to a single function.
If you’ve used Go before you may be wondering if we can define the function as add(a, b:
i32) and avoid repeating the parameter type. The answer is no: in Rust you always have to
spell out the types. I find that a bit unfortunate -- it’s a minor detail of course, but it seems
like a nice touch that Go doesn’t make you slavishly repeat the type.
You can define a function within another function, but unlike in Python or Go, the nested function doesn’t have access to the outer function’s arguments or local variables. The only benefit of a nested function is limiting its scope.
If a function “doesn’t return anything” then its return type is the unit type (). In
that case you can also leave out the return type, and that is indeed the idiomatic way to write it.
The unit type has exactly one value. What if there are zero possible return values? If you have a
function that never returns then its return type should be the empty type ! as in this
example:
fn panic_with_oops() -> ! {
panic!("oops!");
}
The main function can have any return type that implements the Termination trait.
Other than () the most common choice is Result<(), E>, where
E implements Debug. The way this works is that on Ok your
program exits with a “success” exit code; on Err it’ll print the error and exit with a
“failure” exit code. You can use that for simple error handling for command-line programs.
Functions can be passed around as function pointers. A function pointer type is written with
the fn keyword, like a function definition without the function name and body. The
following example uses a function pointer to modify each value in a tuple:
fn apply(f: fn(f64) -> f64, value: (f64, f64, f64)) -> (f64, f64, f64) {
let (x, y, z) = value;
(f(x), f(y), f(z))
}
Function pointer types aren’t used much in practice because the Fn, FnMut,
and FnOnce types from the std::ops module can do the same job
and they also work for methods and closures.