Logo

Developer learning path

News
Rust

Defining and Calling Functions in Rust

Introduction to Rust Programming Language
What is Rust? Advantages of Rust History of Rust Installing Rust
Basics of Rust Programming Language
Data Types Variables and Constants Operators Control Flow
Ownership in Rust
What is Ownership? Borrowing and References Slices Memory Management in Rust Garbage Collection in Rust Drop Trait
Functions and Closures in Rust
Defining and Calling Functions Function Parameters and Return Values Closures Higher Order Functions
Structs and Enums in Rust
Structs Defining Structs Tuple Structs Struct Methods Enums Defining Enums Associated Data Enums as Structs
Traits and Generics in Rust
Traits Defining Traits Trait Objects Implementing Traits Generics Defining Generics Trait Bounds Advanced Lifetimes
Concurrency in Rust
What is Concurrency? Threads Creating Threads Communication Between Threads Message Passing Sync and Send Traits Mutexes and Atomic Types Channels
Error Handling in Rust
What are Errors? Panic Result Enum Unwrapping Results Propagating Errors Combinators
Testing and Debugging in Rust
Debugging Rust Code Writing Tests in Rust Unit Tests Integration Tests Running Tests Test Filters Test Options
Advanced Topics in Rust
Unsafe Rust Macros FFI Cargo Rust Standard Library Collections File IO Networking
Rust Applications
Developing Rust Application Rust Web Development Building GUI Applications using Rust
Conclusion
Recap of Rust Programming Language Future of Rust Programming Language.

Defining and Calling Functions

70

#description

Functions are a fundamental programming concept that allows developers to organize code and make it more modular. In this course on Rust, we will learn how to define and call functions.

Defining a function means creating a block of code that performs a specific task. In Rust, functions are defined with the fn keyword, followed by the function name and a set of parentheses that may include parameters. The function block is then enclosed in curly braces {}.

For example, the following code defines a simple function that takes two integer parameters and returns their sum:

 
                    
fn add_numbers(a: i32, b: i32) -> i32 {
    let result = a + b;
    return result;
}

To call a function, we use its name followed by parentheses. If the function requires arguments, we pass them inside the parentheses.

For example, to call the add_numbers function defined above, we would use the following code:

 
                    
let sum = add_numbers(2, 3);

This code assigns the value 5 to the variable sum, which is returned by the add_numbers function.

In Rust, functions can also be defined as "methods", which are functions that are associated with a particular struct or enum. Method calls are similar to regular function calls, but the method name is preceded by the name of the struct or enum that the method belongs to.

By understanding how to define and call functions in Rust, we gain the ability to write cleaner, more maintainable code.

March 27, 2023

If you don't quite understand a paragraph in the lecture, just click on it and you can ask questions about it.

If you don't understand the whole question, click on the buttons below to get a new version of the explanation, practical examples, or to critique the question itself.