( Back to 28-Tutorial-Tuple-onwards.md )
Functions are reusable blocks of code that perform a specific task. For example, if we want to create a program to add two numbers, then we can create a Rust function to add numbers. Now, we can reuse this same function whenever we add two numbers.
Creating a function in Rust helps divide our code into smaller blocks and makes our code look cleaner and easier to understand.
Not only in Rust, but functions are also one of the core building blocks of any programming language.
In Rust, we use the fn keyword to define a function. The syntax of a function is,
fn function_name(arguments) {
// code
}Let's see an example.
fn greet() {
// code
}Here,
-
fn- keyword used to create a function in Rust -
greet()- name of the function -
// code- function body -
{ }- start and end of the function body
Now let's complete the greet() function to print "Hello, World!".
// define a function
fn greet() {
println!("Hello, World!");
}
fn main() {
}When we run this code, we will not get any output. This is because here we are just defining a function. To execute a function, we need to call it.
We use the name of the function and parentheses () to call a function.
// call a function
greet();Let's complete the above example now.
// define a function
fn greet() {
println!("Hello, World!");
}
fn main() {
// function call
greet();
}Hello, World!Here, we have created a greet() function that prints "Hello, World!" on the screen. Notice that we are calling the function from inside main().
If you look carefully, you can see the syntax of main() looks similar to a function.
fn main() {
// function call
greet();
}In Rust, main() is also a function known as a built-in function that has a special meaning. It is the entry point (start) of every Rust program.
Rust code uses a small case as the convention for defining a function name. An extended function name with multiple words will have underscores in between words.
// function to add two numbers
fn add() {
let a = 5;
let b = 10;
let sum = a + b;
println!("Sum of a and b = {}", sum);
}
fn main() {
// function call
add();
}Sum of a and b = 15In the above example, we have created a function named add(). The function adds two numbers and prints the sum.
Here's how the program works,
From the definition, we know that a function should be reusable. However, the add() function in our previous example can only be used to perform the addition of 5 and 10.
// function to add two numbers
fn add() {
let a = 5;
let b = 10;
let sum = a + b;
println!("Sum of a and b = {}", sum);
}This function is not dynamic to be reused.
To deal with this and make our functions more dynamic, we can create functions that accept external values. These external values are called function parameters.
Here's how we can create a function with parameters.
// function with parameters
fn add(a: i32, b: i32) {
let sum = a + b;
println!("Sum of a and b = {}", sum);
}Here,
-
aandbare function parameters -
i32is the data type of parameters
To call this function, we should provide some value during the function call.
add(2, 11);Here, 2 and 11 are known as function arguments that are passed to the add function.
Sum of a and b = 13// define an add function that takes in two parameters
fn add(a: i32, b: i32) {
let sum = a + b;
println!("Sum of a and b = {}", sum);
}
fn main() {
// call add function with arguments
add(2, 11);
}Sum of a and b = 13Here's how the program works,
 -> i32 {
let sum = a + b;
// return a value from the function
return sum;
}Here, -> i32 before the opening curly bracket { indicates the function's return type. In this case, the function will return an i32 value.
We have then used the return keyword to return the sum variable from the function.
The function returns the value to the place from where it is called, so the returned value needs to be stored somewhere.
// store the returned value in a variable
let sum = add(3, 5);// define an add function that takes in two parameters with a return type
fn add(a: i32, b: i32) -> i32 {
let sum = a + b;
// return a value from the function
return sum;
}
fn main() {
// function call
let sum = add(3, 5);
println!("Sum of a and b = {}", sum);
}Sum of a and b = 8Here's how the program works,
In the above example, when we reach the `return` statement in the add function, it returns the `sum` variable. The returned value is stored in the `sum` variable inside `main()`.In computer programming, a variable's scope defines the region in which the variable is available for use. For example,
fn main() {
// this variable has scope inside the main function block
let age = 31;
…
}Here, the age variable has scope inside the body {...} of the main() function,
Each variable in Rust has a scope that is valid inside a block. A block is a collection of statements enclosed by curly braces {}.
Let's look at how variable scope works with an example,
fn main() {
// scope of outer_var variable is inside the main function code block
let outer_var = 100;
// start of the inner code block
{
// scope of inner_var variable is only inside this new code block
let inner_var = 200;
println!("inner_var = {}", inner_var);
}
// end of the inner code block
println!("inner_var = {}", inner_var);
println!("outer_var = {}", outer_var);
}Here, if we try to print the inner_var outside of the inner code block, the program fails to compile, and we encounter an error.
error[E0425]: cannot find value `inner_var` in this scope
--> main.rs:13:32
|
13 | println!("inner_var = {}", inner_var);
| ^^^^^^^^^ help: a local variable with a similar name exists: `outer_var`
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0425`.The Rust compiler could not find inner_var in scope as we tried to print the variable outside the inner code block.
To fix this, we can do the following,
fn main() {
// scope of outer_var variable is inside the main function code block
let outer_var = 100;
// start of the inner code block
{
// scope of inner_var variable is only inside this new code block
let inner_var = 200;
println!("inner_var = {}", inner_var);
println!("outer_var inside inner block = {}", outer_var);
}
// end of the inner code block
println!("outer_var = {}", outer_var);
}inner_var = 200
outer_var inside inner block = 100
outer_var = 100We removed the println!("inner_var = {}", inner_var); from the outer code block and the program now works as expected.
Additionally, we can access the outer_var inside the inner code block because its scope is in the main() function.
Here is how variable scope works in the above program,
In Rust, when a variable declared within a particular scope has the same name as a variable declared in the outer scope, it is known as variable shadowing.
We can use the same variable name in different scope blocks in the same program.
Let's take a look at an example,
fn main() {
let random = 100;
// start of the inner block
{
println!("random variable before shadowing in inner block = {}", random);
// this declaration shadows the outer random variable
let random = "abc";
println!("random after shadowing in inner block = {}", random);
}
// end of the inner block
println!("random variable in outer block = {}", random);
}random variable before shadowing in inner block = 100
random after shadowing in inner block = abc
random variable in outer block = 100Here, the random variable declared in the outer block is shadowed in the inner block. Let's look at what that means,
let random = "abc";The random variable value inside the inner block will shadow the value of the outer block so that the inner block will have the "abc" value. However, the value of the random variable remains the same outside of the inner block.
We can freeze a variable in Rust by using shadowing and immutability. Once a variable is frozen, we cannot change the variable value in the inner scope.
Let's see an example.
fn main() {
let mut age = 1;
// start of the inner block
{
// shadowing by immutable age variable
let age = age;
// error, age variable is frozen in this scope
age = 2;
println!("age variable inner block = {}", age);
// age variable goes out of scope
}
// end of the inner block
// age variable is not frozen in outer block
age = 3;
println!("integer variable outer block = {}", age);
}warning: value assigned to `age` is never read
--> main.rs:7:13
|
7 | let age = age;
| ^^^
|
= help: maybe it is overwritten before being read?
= note: `#[warn(unused_assignments)]` on by default
error[E0384]: cannot assign twice to immutable variable `age`
--> main.rs:10:9
|
7 | let age = age;
| ---
| |
| first assignment to `age`
| help: consider making this binding mutable: `mut age`
...
10 | age = 2;
| ^^^^^^^ cannot assign twice to immutable variable
error: aborting due to 1 previous error; 1 warning emitted
For more information about this error, try `rustc --explain E0384`.In the above example, we have assigned the mutable variable of the outer block named age to the same immutable variable in the inner scope.
fn main() {
let mut age = 100;
{
let age = age;
…
}
…
}In doing this,
we are shadowing the mutable age variable
with an immutable variable named age.
Now the age variable freezes inside the inner block because the inner age variable is pointing to the same value as the age variable in the outer block.
Thus, we cannot change the value of age inside the inner block and encounter an error.
Once we get out of the inner block, the value of age can be changed.
Let's look at the working version of the variable freezing example.
fn main() {
let mut age = 100;
{
// shadowing by immutable age variable
let age = age;
println!("age variable inner block = {}", age);
// age goes out of scope
}
// age variable is not frozen in this scope
age = 3;
println!("age variable outer block = {}", age);
}age variable inner block = 100
age variable outer block = 3