Introduction to Rust Programming Language
Last Updated :
14 Nov, 2024
Rust is a blazing fast and memory-efficient static compiled language with a rich type system and ownership model. It can be used to power performance-critical services while guaranteeing memory-safety and thread-safety, empowering developers to debug at compile-time. In addition to that Rust has great documentation and a user-friendly compiler with top-end tools like integrated package managers and multi-editor with features like type inspection and auto-completion. Rust prevents all the crashes, and, interestingly, Rust is safe by default like JavaScript, Ruby, and Python. This is much more powerful than C/C++ because we cannot write the wrong parallel code you can never see fault in rust. It is very fast in representing a lot of programming paradigms very well.

But the question arises as there are already so many programming languages like Python, C++, Java, etc, then why the need for developing a new programming language? The answer to this is the other programming languages have a lot of control over the hardware that you are running, like, you can optimize it well, translate directly to assembly code, but it's not very safe.
So rust provides us all the controls that we can have and all the levels of security that we can achieve.
Rust is using Rust which means that all the standard compiler libraries are written in rust; there is a bit of use of the C programming language but most of it is Rust. The big project of Rust is "servo", It is a project to write out the totally parallel layout engine like Gecko in Firefox or WebKit in Safari.
Servo built the layout engine, something to render HTML from bottom to top.
Functions in Rust
Functions are the block of reusable code that can perform similar related actions. You have already seen one of the most important functions in the language: the main function, which is the entry point of many programs. You’ve also seen the “fn” keyword, which allows you to declare new functions. Rust code uses snake case as the conventional style for function and variable names. In snake case, all letters are lowercase and underscore separate words.
Syntax:
fn functionname(arguments){
code
}
Here,
- To create a function we need to use the fn keyword.
- The function name is written after the fn keyword.
- Arguments are passed after function name inside parenthesis.
- You can write function code in function block.
Example: The below function simply prints "Hello, World!" in the console:
Rust
fn main() {
println!("Hello, world!");
}
Output:
Hello, World!
Concept of Ownership
The concept of ownership is that when you own something you can decide to pass it to someone else, if you have a book, and you have done reading it you can permanently give it to someone and not worry about it.
Below is the Rust program to implement the approach:
Rust
fn helper() -> Box<i32> {
let three = Box::new(3);
three // Ownership is transferred implicitly
}
fn main() {
// Acquire ownership of the return value
let my_three = helper();
println!("{}",my_three);
}
Output:
3
Concept of Borrowing
Owned values in rust can be borrowed to allow usage for a certain period of time The "&" sign represents the borrowed reference. Borrowed values have a lifetime and are valid for that time only. Borrowing prevents moving. While there is an active borrow I can not transfer ownership. I still own it but cannot transfer it until I handed it in to really relinquish that borrowed.
Below is the Rust program to implement the approach:
Rust
fn main() {
let a: &i32;
{
// b lifetime is not same as a
let b = 3;
a = &b;
println!("{}",b);
}
println!("{}",a);
}
Here "a" and "b" has a different lifetime, so it will not work.
Rust
fn main() {
let a: &i32;
// a and b have same lifetime
let b = 3;
a = &b;
println!("{}",a);
println!("{}",b);
}
Output:
3
3
Here "a" and "b" have the same life, so it will work. Borrow can be nested. Through cloning, borrowed values can become owned.
Memory management in Rust
- Rust has fine-grain memory management but is automatically managed once created.
- In Rust when you allocate memory you never have to really free it you can decide when to free it but never call it. Rust takes care of it automatically.
- Each variable has a scope it is valid for, and it gets automatically deallocated once it goes out of scope.
- In rust, each program is allocated memory from the operating system.
- Rust also has a shared memory where we can have a reference piece of data, we can use ownership to keep track of reference count.
Different memory
1. Heap:
- It is the biggest memory block and is managed by the rust ownership model.
- At this place, all the dynamic data is stored.
2. Stack:
- All values in rust are allocated on the stack.
- At this, the static memory is allocated by default.
- There is one stack per thread.
- It includes structures and pointers to dynamic data.
Mutability
Values in rust are immutable by default and must be tagged as being mutable(if needed).
Below is the Rust program to implement Mutability:
Rust
fn main() {
let x = 2;
// It will show an error
x = 9;
println!("{}", x);
}
The above example will show an error because we have not tagged it as mutable.
Rust
fn main() {
let mut x = 2;
// This will work fine
x = 9;
println!("{}", x);
}
Output:
9
This will work fine as we have tagged it as being mutable. As in this case we are explicitly mutating it.
Structure in Rust
The structure is a user-defined data type in rust that is used to combine different data items of a different type. Structure defines data as a key-value pair. The struct keyword is used to define Structures in Rust.
Syntax:
struct Name_of_structure {
field1:data_type,
field2:data_type,
field3:data_type
}
Below is the Rust program to implement structure:
Rust
struct Employee {
name: String,
company: String,
employee_id: u32,
profile: String
}
fn main() {
let value = Employee {
name: String::from("Geek"),
company: String::from("Geeksforgeeks.org"),
employee_id: 007,
profile:String::from("Manager"),
};
println!("Employee: {} of {} Company bearing EmployeeID {} is of {} level.",
value.name,
value.company,
value.employee_id,
value.profile);
}
Output:
Employee: Geek of Geeksforgeeks.org Company bearing EmployeeID 7 is of Manager level.
This is an example of how we create structures in rust. This will compile perfectly.
Tuple
A tuple in rust is a finite heterogeneous compound data type, meaning it can store more than one value at once. In tuples, there is no inbuilt method to add elements into a tuple. We can use the index to get the value of a tuple, and we also can not iterate over a tuple using for loop.
Syntax:
("geeksforgeeks", 1, 'geek')
Below is the Rust program to implement Tuple:
Rust
// Rust program to get value from tuple
// using index
fn main() {
let gfg = ("cp", "algo", "FAANG", "Data Structure");
// complete tuple
println!("complete tuple = {:?} ", gfg );
// first value
println!("at 0 index = {} ", gfg.0 );
// second value
println!("at 0 index = {} ", gfg.1 );
// third value
println!("at 0 index = {} ", gfg.2 );
// fourth value
println!("at 0 index = {} ", gfg.3 );
}
Output:
complete tuple = ("cp", "algo", "FAANG", "Data Structure")
at 0 index = cp
at 0 index = algo
at 0 index = FAANG
at 0 index = Data Structure
Rust Type System
In Rust, every variable, value, and item has a type. The type defines how much memory it is holding and which operation can be performed on the value. The below table states all the types in Rust:
Type | Contents |
---|
Primitive Types | Boolean, Numeric, Textual, Never |
---|
Sequence Types | Tuple, Array, Slice |
---|
User-defined Types | Struct, Enum, Union |
---|
Function Types | Functions, Closures |
---|
Pointer Types | References, Raw pointers, Function pointers |
---|
Trait Types | Trait objects, Impl trait |
---|
Advantages of Rust
- Quick debugging and testing: Rust is a very fast language and supports quick and effective debugging.
- Rust supports more complex code as compared to other languages, so we can achieve more in less code.
- It enables cross-platform development.
- Ease of integration: Rust can be easily integrated with C and many other famous programming languages.
- Rust is safer than other programming languages.
- There is a wide community of developer which support Rust.
Disadvantages of Rust
- Due to complexity, it may take a longer time to learn Rust.
- In rust, code can be less efficient and also it takes more time to compile.
- As it is more complex, so it may take more time to complete apps written in Rust.
- It is a new language, so it will take more time to spread over and jobs in rust also may not be as much as in other popular programming languages.
- In some cases, rust can leak memory and become slower than a popular programming language.
- Hard to maintain due to its large code base.
Similar Reads
Non-linear Components In electrical circuits, Non-linear Components are electronic devices that need an external power source to operate actively. Non-Linear Components are those that are changed with respect to the voltage and current. Elements that do not follow ohm's law are called Non-linear Components. Non-linear Co
11 min read
Spring Boot Tutorial Spring Boot is a Java framework that makes it easier to create and run Java applications. It simplifies the configuration and setup process, allowing developers to focus more on writing code for their applications. This Spring Boot Tutorial is a comprehensive guide that covers both basic and advance
10 min read
Class Diagram | Unified Modeling Language (UML) A UML class diagram is a visual tool that represents the structure of a system by showing its classes, attributes, methods, and the relationships between them. It helps everyone involved in a projectâlike developers and designersâunderstand how the system is organized and how its components interact
12 min read
Steady State Response In this article, we are going to discuss the steady-state response. We will see what is steady state response in Time domain analysis. We will then discuss some of the standard test signals used in finding the response of a response. We also discuss the first-order response for different signals. We
9 min read
Backpropagation in Neural Network Back Propagation is also known as "Backward Propagation of Errors" is a method used to train neural network . Its goal is to reduce the difference between the modelâs predicted output and the actual output by adjusting the weights and biases in the network.It works iteratively to adjust weights and
9 min read
Polymorphism in Java Polymorphism in Java is one of the core concepts in object-oriented programming (OOP) that allows objects to behave differently based on their specific class type. The word polymorphism means having many forms, and it comes from the Greek words poly (many) and morph (forms), this means one entity ca
7 min read
3-Phase Inverter An inverter is a fundamental electrical device designed primarily for the conversion of direct current into alternating current . This versatile device , also known as a variable frequency drive , plays a vital role in a wide range of applications , including variable frequency drives and high power
13 min read
What is Vacuum Circuit Breaker? A vacuum circuit breaker is a type of breaker that utilizes a vacuum as the medium to extinguish electrical arcs. Within this circuit breaker, there is a vacuum interrupter that houses the stationary and mobile contacts in a permanently sealed enclosure. When the contacts are separated in a high vac
13 min read
AVL Tree Data Structure An AVL tree defined as a self-balancing Binary Search Tree (BST) where the difference between heights of left and right subtrees for any node cannot be more than one. Example of an AVL Tree:The balance factors for different nodes are : 12 :1, 8:1, 18:1, 5:1, 11:0, 17:0 and 4:0. Since all differences
4 min read
CTE in SQL In SQL, a Common Table Expression (CTE) is an essential tool for simplifying complex queries and making them more readable. By defining temporary result sets that can be referenced multiple times, a CTE in SQL allows developers to break down complicated logic into manageable parts. CTEs help with hi
6 min read