What are Rust Functions?
Description
- The “fn” keyword allows us to declare new functions.
- Rust code uses snake case because the conventional style for function and variable names..
- All letters are lowercase and underscores separate the words in snake case.
Example
fn main() {
println!("Hello, world!");
another_function();
}
fn another_function() {
println!("Another function.");
}
Result:
Hello, world
Another function.
Note: The Rust doesn’t care where you define your functions after or before the main function
Function Parameters
- Function parameters are the special variables that are part of a function’s signature.
- We can provide it with concrete values for those parameters when a function has parameters.
- Technically, the concrete values are called arguments
- We can use both i.e parameter or argument in casual conversation.
- While calling a function, function’s parameter value h as to be set.
- fn main ( ) {}
- println!(“The value of x is: {}”, }
- The value of x is: 5.
- We must declare the type of each parameter in function’s signature.
Example
fn main ( ) {
another_function(5);
}
fn another_function(x: i32) {
println!("The value of x is: {}",
x);
}
Result:
The value of x is: 5
We must declare the type of each parameter in function’s signature.
Statements and Expressions
- Rust is an expression-based language
- The Function bodies are made up of series of statements optionally ending in an expression.
- Statements are instructions that perform some action and don’t return a worth .
- Expressions evaluate to a resulting value.
- The statement is to creating a variable and assigning a value to it with the let keyword.let y = 6;
- }
- fn main( ) {
- The let y = 6 statement doesn’t return a worth
- Note: Statement contains (;) at its end.
- Consider a simple math operation, such as 5 + 6, which is an expression that evaluates to the value 11.5
- }
- fn five() i32 {
- Expressions can be part of statements
- Note: Expression does not contain (;) at its end.fn main() {let y = {x +1 println!(“The value of y is:}
- The value of y is: 4
- Note: x+1 is an expression without semicolon. If we give a semicolon to the end of an expression then we turn it into a statement, which would then not return a value.
Example
fn main() {
let x = 5;
let y = {
let x = 3;
x + 1
};
println!("The value of y is:
{ }", y);
}
Result:
(“The value of y is:}
The value of y is: 4
Note: x+1 is an expression without semicolon. If we include a semicolon to the end of an expression then we turn it into a statement, which will then not return a value.
FUNCTION WITH RETURN VALUE
- Functions may return values to the code that calls them. We don’t name return values, but we do declare their type after an arrow ( ).fn five() i32 {}let x = five();x);Result:Note: We can’t use semicolon(;) after 5 because it is an expression.
Example
fn five() i32 {
5
}
fn main() {
let x = five();
println!("The value of x is: {}",
x);
}
Result:
The value of x is: 5
Note: We can’t use semicolon(;) after 5 because it is an expression.
