Working with Rust
Functions
A set of examples using functions in Rust.
Basic Function
The input parameters for a function must define the required incoming type.
fn main() {
add(2, 3);
}
fn add(x: i32, y: i32) {
let sum = x + y;
println!("{} + {}: {}", x, y, sum);
}
Function with Return Value
The return result for a function must define the type. Here's an example using an explicit return.
fn main() {
let x = 2;
let y = 3;
let sum = add(x, y);
println!("{} + {}: {}", x, y, sum);
}
fn add(x: i32, y: i32) -> i32 {
let sum = x + y;
return sum;
}
In Rust, the result of the last line of a function without a closing semi-colon will be used for the return value. So the add()
function above could be simplified to:
fn add(x: i32, y: i32) -> i32 {
x + y
}
Function with Multiple Values
You can return multiple values from a function using tuples. A tuple is a collection of variables of different types. A tuple is constructed using parentheses and can hold any number of values.
fn main() {
let names = parse_name("Marcus Kazmierczak");
println!("First: {}", names.0);
println!("Last : {}", names.1);
}
fn parse_name(s: &str) -> (&str, &str) {
let v = Vec<&str>: s.split(" ").collect();
return (v[0], v[1]);
}
Block Expression
Rust will treat anything within { }
as a block expression, this applies to functions, but you can also use it without functions.
fn main() {
let x = 5;
{
let x = 3;
println!("x: {}", x);
}
println!("x: {}", x);
}
// x: 3
// x: 5
Nesting Functions
You can define functions inside other functions.
fn main() {
fn add(x: i32, y: i32) -> i32 {
x + y
}
println!("1 + 2 = {}, add(1, 2));
}
Higher Order Functions
You can create a function that returns another function, this allows creating higher order functions and currying.
fn main() {
fn add(x: i32) -> impl Fn(i32) -> i32 {
return move |y| -> i32 { x + y };
};
let add_one = add(1);
let add_two = add(2);
println!("3 + 1 = {}", add_one(3));
println!("3 + 2 = {}", add_two(3));
println!("3 + 4 = {}", add(3)(4));
}