Rust - Functions

Functions are the building blocks of readable, maintainable, and reusable code. A function is a set of statements to perform a specific task. Functions organize the program into logical blocks of code. Once defined, functions may be called to access code. This makes the code reusable. Moreover, functions make it easy to read and maintain the program’s code.

A function declaration tells the compiler about a function s name, return type, and parameters. A function definition provides the actual body of the function.

Defining a Function

A function definition specifies what and how a specific task would be done. Before using a function, it must be defined. The function body contains code that should be executed by the function. The rules for naming a function are similar to that of a variable. Functions are defined using the fn keyword. The syntax for defining a standard function is given below

Syntax

fn function_name(param1,param2..paramN) {
   // function body
}

A function declaration can optionally contain parameters/arguments. Parameters are used to pass values to functions.

Example - Simple function definition

//Defining a function
fn fn_hello(){
   println!("hello from function fn_hello ");
}

Invoking a Function

A function must be called so as to execute it. This process is termed as function invocation. Values for parameters should be passed when a function is invoked. The function that invokes another function is called the caller function.

Syntax

function_name(val1,val2,valN)

Example: Invoking a Function

fn main(){
   //calpng a function
   fn_hello();
}

Here, the main() is the caller function.

Illustration

The following example defines a function fn_hello(). The function prints a message to the console. The main() function invokes the fn_hello() function.

fn main(){
   //calpng a function
   fn_hello();
}
//Defining a function
fn fn_hello(){
   println!("hello from function fn_hello ");
}

Output

hello from function fn_hello

Returning Value from a Function

Functions may also return a value along with control, back to the caller. Such functions are called returning functions.

Syntax

Either of the following syntax can be used to define a function with return type.

With return statement

// Syntax1
fn function_name() -> return_type {
   //statements
   return value;
}

Shorthand syntax without return statement

//Syntax2
fn function_name() -> return_type {
   value //no semicolon means this value is returned
}

lllustration

fn main(){
   println!("pi value is {}",get_pi());
}
fn get_pi()->f64 {
   22.0/7.0
}

Output

pi value is 3.142857142857143

Function with Parameters

Parameters are a mechanism to pass values to functions. Parameters form a part of the function’s signature. The parameter values are passed to the function during its invocation. Unless exppcitly specified, the number of values passed to a function must match the number of parameters defined.

Parameters can be passed to a function using one of the following techniques −

Pass by Value

When a method is invoked, a new storage location is created for each value parameter. The values of the actual parameters are copied into them. Hence, the changes made to the parameter inside the invoked method have no effect on the argument.

The following example declares a variable no, which is initially 5. The variable is passed as parameter (by value) to the mutate_no_to_zero()functionnction, which changes the value to zero. After the function call when control returns back to main method the value will be the same.

fn main(){
   let no:i32 = 5;
   mutate_no_to_zero(no);
   println!("The value of no is:{}",no);
}

fn mutate_no_to_zero(mut param_no: i32) {
   param_no = param_no*0;
   println!("param_no value is :{}",param_no);
}

Output

param_no value is :0
The value of no is:5

Pass by Reference

When you pass parameters by reference, unpke value parameters, a new storage location is not created for these parameters. The reference parameters represent the same memory location as the actual parameters that are suppped to the method. Parameter values can be passed by reference by prefixing the variable name with an & .

In the example given below, we have a variable no, which is initially 5. A reference to the variable no is passed to the mutate_no_to_zero() function. The function operates on the original variable. After the function call, when control returns back to main method, the value of the original variable will be the zero.

fn main() {
   let mut no:i32 = 5;
   mutate_no_to_zero(&mut no);
   println!("The value of no is:{}",no);
}
fn mutate_no_to_zero(param_no:&mut i32){
   *param_no = 0; //de reference
}

The * operator is used to access value stored in the memory location that the variable param_no points to. This is also known as dereferencing.

The output will be −

The value of no is 0.

Passing string to a function

The main() function passes a string object to the display() function.

fn main(){
   let name:String = String::from("TutorialsPoint");
   display(name); 
   //cannot access name after display
}
fn display(param_name:String){
   println!("param_name value is :{}",param_name);
}

Output

param_name value is :TutorialsPoint