TL;DR

Welcome 👋!

Rust is a biblically accurate programming language 😇!

Rust is a modern and powerful programming language that prioritizes performance and memory safety without sacrificing control or efficiency. It's an open-source language that's been steadily gaining popularity because of its ability to solve some of the most difficult problems that we as developers face, particularly when it comes to writing code that's both fast and safe. Unlike some older languages, e.g. C, that allow you to manipulate memory directly, which can lead to bugs and vulnerabilities if done incorrectly, Rust enforces strict safety rules at compile time. This means that many of the issues that would typically appear during runtime - such as memory leaks or data races - are caught early in the development process, even before the program starts running. The trade-off is that, while Rust is designed to help you write safer and more reliable code, it also requires you to think more deeply about how data is used and manipulated in your programs. This makes it a little harder to learn initially, especially if you come from a background in languages like Python, Ruby, or JavaScript, but once you grasp its concepts, you'll find that it can actually make your code cleaner and easier to maintain. Rust's combination of speed, safety, and concurrency makes it an ideal choice for a wide variety of applications, from operating systems and web servers to game engines and blockchain technology. Rust is particularly useful when building systems that require high performance without sacrificing safety or concurrency. It achieves this balance by using a set of concepts that, while initially tricky to learn, become second nature over time.

Table of Contents

Who Is This Article For?

Go to TOC

This article is primarily intended for those who have some experience with programming and are looking to learn a new language or dive deeper into systems-level programming. If you have a solid understanding of concepts in languages like C, C++, or Java, but you've never worked with Rust before, then this article will help you understand why Rust is becoming increasingly popular in the software development world. On the other hand, if you are coming from higher-level languages like Python, JavaScript, or Ruby, and you are curious about learning something that gives you more control over how your program interacts with the hardware, then this article is a perfect starting point. Understanding Rust can be incredibly rewarding because it helps you write code that is both fast and safe at the same time. However, Rust has a steep learning curve, especially if you've never dealt with concepts like ownership, borrowing, and lifetimes, which are central to its design. Rust's focus on memory safety and concurrency makes it an excellent choice for building complex applications that require both speed and reliability, such as game engines, web servers, and embedded systems. This article assumes that you have at least some basic familiarity with programming concepts, such as variables, loops, and functions, but it will guide you through everything you need to know to start writing Rust code. Even if you're new to systems programming or low-level languages, the principles and patterns used in Rust are incredibly valuable for all kinds of software development. The goal here is not to overwhelm you with every single detail but to provide you with the foundational knowledge and understanding to begin writing Rust code that is safe, efficient, and maintainable.

What Is Rust?

Go to TOC

A compiled programming language, waku waku!

Rust is a systems programming language that focuses on performance, reliability, and safety. It was created by Mozilla Research in 2006 and later developed by the Rust community. Its primary goal is to make it easier to write safe and concurrent programs without sacrificing performance. One of the key differentiators of Rust from other languages is its ownership system, which helps prevent bugs related to memory access, such as null pointer dereferencing or data races, both of which can lead to crashes or vulnerabilities in software. Rust achieves this by introducing a set of rules around ownership, borrowing, and lifetime of data. In Rust, data has an owner, and each piece of data can have only one owner at a time. When the owner of data goes out of scope, the data is automatically cleaned up, preventing memory leaks. This ownership system, while initially challenging to understand, is one of the reasons why Rust can prevent many common programming bugs that plague other languages. Additionally, Rust's borrowing system allows data to be temporarily shared without giving up ownership, which makes it possible to write concurrent programs safely. These concepts help ensure that your programs are free from memory-related errors without the need for a garbage collector, which is common in languages like Java or Python. Rust also excels at concurrency, meaning that it can handle multiple threads of execution simultaneously without the risk of data races, thanks to its strict rules for data access. This makes it ideal for building highly efficient and reliable systems that require heavy parallel processing, such as game engines or data processing pipelines. As a compiled language, Rust offers performance comparable to C and C++ while ensuring memory safety, which is something those older languages do not inherently guarantee.

fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // Ownership of s1 is transferred to s2

    // println!("{}", s1);  // This would throw an error because s1 is no longer valid
    println!("{}", s2);  // This prints "hello"
}

In the code example above, you can see Rust's ownership in action. The string s1 is created, and then its ownership is transferred to s2. Once ownership has been transferred, s1 is no longer valid and cannot be accessed, as shown in the commented-out line. This mechanism eliminates issues like double-free errors, which can occur in other languages when memory is deallocated more than once. Rust ensures that memory is freed at the right time, without relying on runtime checks or garbage collection. This is part of what makes Rust so efficient, as it avoids the overhead that garbage collection introduces in other languages, making it suitable for performance-critical applications.

Why Not Rust?

Go to TOC

Just steap learning curve, don't mind it!

While Rust offers many benefits, it's not always the best choice for every project. One of the biggest drawbacks of Rust is its steep learning curve. Unlike higher-level languages like Python or JavaScript, Rust requires a deep understanding of memory management and the ownership model to write efficient and error-free code. For those who are just starting out in programming, Rust might feel overwhelming at first. The concepts of ownership, borrowing, and lifetimes are fundamental to writing safe and correct Rust code, but they can be difficult to grasp, especially if you don't have experience with lower-level programming concepts. Additionally, Rust's syntax is not as forgiving as some other languages. Small mistakes, like forgetting to mark a variable as mutable or trying to use a value after it's been moved, can lead to compiler errors that might be frustrating for beginners. This strictness is part of what makes Rust so reliable, but it can also make the development process slower, particularly when you're starting out. Another potential downside of Rust is that, while it's a fast and powerful language, its tooling ecosystem isn't as mature as some of the more established languages like Python or JavaScript. However, we are working on improving this area at Open Sass and making it easier to use Rust on the web. Although Rust's package manager, Cargo, is highly regarded, there may still be situations where finding the right libraries or frameworks for your project is more challenging than in more widely-used languages. Rust also lacks some of the higher-level abstractions that languages like Python provide, which can make it less suitable for quick prototypes or applications that don't require high performance. As a result, Rust is best suited for situations where performance, memory safety, and concurrency are critical, such as systems programming, embedded systems, web or game development. For simpler projects or applications that don't have rigid performance requirements, a language like Python, JavaScript, or Ruby might be a better fit. However, for those willing to invest the time and effort to learn its nuances, Rust can be an incredibly rewarding and powerful tool.

Personal Experience

Go to TOC

In my personal journey with Rust, I found that the language, while initially difficult to learn, has grown to be an invaluable tool for tackling complex projects. Like many developers, I started with higher-level languages, like Python, and was initially intimidated by Rust's focus on memory safety and ownership. At first, the compiler errors felt like roadblocks, but over time, I realized that these errors were not obstacles - they were guiding me toward better, safer code. One of the most rewarding moments in learning Rust was when I finally understood the borrowing and ownership system. It clicked when I saw how it could prevent data races and memory corruption, things that had been difficult to manage in other languages without introducing complex synchronization mechanisms. After gaining proficiency in Rust, I felt more confident tackling systems-level programming tasks, like building a web server or working with low-level hardware interactions, tasks that would have been much more error-prone and dangerous in languages like C. Even though Rust is a compiled language, it has a fast feedback loop through its excellent testing and error messages, which makes the development experience feel more like working with an interpreted language. Rust's tooling, including the Cargo package manager and rustfmt for automatic formatting, has made it easy to stay organized and productive. I also found that the Rust community is incredibly supportive, with a large and active group of developers who are always eager to help newcomers. Whether you're working on small open-source projects or large, complex systems, the community provides resources, tutorials, and documentation that can help you overcome challenges quickly. Overall, Rust has made me a better programmer by forcing me to think more carefully about memory management and concurrency, two areas that were previously abstracted away in higher-level languages.

Why I Switched to Rust

Go to TOC

Switching to Rust was a decision that, at first, seemed daunting but ultimately transformed the way I approached software development. Coming from a background in higher-level languages like Python and JavaScript, I was drawn to a more relaxed approach to memory management and error handling. However, as I began working on performance-critical projects, such as building a web server and optimizing algorithms, I started running into limitations with languages that abstracted away too much of the underlying system. I realized that while these languages are excellent for rapid development and prototyping, they often struggle when it comes to fine-tuning performance or ensuring reliability in large-scale, concurrent applications. This is where Rust came in. What drew me to Rust was its focus on both speed and safety. In particular, the ability to write concurrent programs without worrying about race conditions or memory corruption was a game-changer. The idea of having zero-cost abstractions, where I could write high-performance code without worrying about runtime overhead, was incredibly appealing. In addition, Rust's ownership system ensured that memory management would be handled automatically, without the need for a garbage collector or manual memory allocation. This was a massive improvement over other languages, where manual memory management often leads to bugs and security vulnerabilities. After diving deeper into Rust and understanding its core principles, I realized that it not only solved the performance issues I had been facing but also helped me write more reliable and maintainable code. I no longer had to worry about the kinds of memory errors or data races that could cause unpredictable behavior in my applications. While Rust does have a steep learning curve, the payoff was well worth it, and I quickly became a believer in its advantages. It wasn't just about the performance gains - it was about the clarity and correctness that came with the language's design. In the end, switching to Rust allowed me to approach software development with more confidence, knowing that my programs would be faster, safer, and more scalable.

How To Get Started

Go to TOC

Getting started with Rust might seem intimidating, but it is actually quite straightforward once you break it down into manageable steps. The first thing you need to do is install Rust on your system. Fortunately, the Rust installation process is simple and well-documented, and the official website provides detailed instructions for various operating systems, including Windows, macOS, and Linux. The recommended way to install Rust is through the Rust toolchain installer called rustup, which handles everything from downloading the compiler to setting up the necessary components for your development environment. After installing rustup, you can begin writing Rust code with a simple text editor, but using an IDE with Rust support, such as Visual Studio Code with the Rust extension, can make your development experience smoother. This setup will allow you to take advantage of features like autocompletion, inline documentation, and error highlighting, which can help you become more productive. Once your environment is ready, you can create a new Rust project using Cargo, the built-in package manager and build system for Rust. Cargo handles all the dependencies, compilation, and testing of your projects, which simplifies the development process. When you create a new project with Cargo, it will generate the necessary directory structure, a Cargo.toml file for managing dependencies, and a basic main.rs file to get you started. From here, you can begin writing Rust code and testing it with Cargo's built-in testing framework. The official Rust documentation, known as The Rust Book, is an invaluable resource for beginners. It provides a comprehensive guide to the language and walks you through all of the core concepts, such as variables, functions, ownership, and error handling, step by step. Additionally, there are many online tutorials, forums, and video courses that can help you along the way. The Rust community is incredibly welcoming, and there's a strong support network for newcomers, whether you're asking questions on forums or reading blog posts and books from experienced developers. As you get more comfortable with the basics, you can explore more advanced topics like concurrency, memory management, and unsafe code, which are some of Rust's most powerful features. The key to getting started with Rust is persistence and practice. The language has a steep learning curve, but the more you code, the more comfortable you will become with its unique concepts and powerful features.

# Installing Rust on macOS and Linux via rustup
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Windows installation using rustup
https://forge.rust-lang.org/infra/other-installation-methods.html

This simple command installs Rust on your system using rustup.

Verifying Rust Installation

Go to TOC

After installing Rust using rustup, it's important to verify that everything has been installed correctly. The verification process is simple and can be done by checking the version of the Rust compiler (rustc) and the package manager (cargo) that rustup installs. First, open a terminal or command prompt and run the following command to check the version of the Rust compiler:

rustc --version

This command will display the version of rustc, the Rust compiler. If the installation was successful, you should see output similar to this:

rustc 1.85.1 (4eb161250 2025-03-15)

This confirms that the Rust compiler is installed and that it's ready to use. Additionally, you can verify that Cargo, Rust's package manager, is installed by running the following command:

cargo --version
# cargo 1.85.1 (d73d2caf9 2024-12-31)

This will display the version of Cargo, which should be installed automatically when you install rustup. Cargo is an essential tool for managing dependencies, building projects, and running tests, so it's important to make sure that it's working correctly. If you encounter any issues during installation or verification, the Rust website provides troubleshooting steps, and the community is active in helping resolve common issues. Once you've confirmed that both rustc and cargo are installed, you're ready to start building Rust projects!

cargo -h

Creating a Rust Project

Go to TOC

Once you have successfully installed Rust and verified that everything is working correctly, the next step is to create your first Rust project. This is done using Cargo, Rust's powerful package manager and build system. Cargo makes it easy to manage your Rust projects, handle dependencies, and compile your code into executable binaries. To create a new Rust project, simply run the following command in your terminal:

cargo new my_first_project

This will create a new directory called my_first_project with a basic Rust project structure. The directory will contain a Cargo.toml file, which is used to manage your project's dependencies, and a src folder with a main.rs file. The main.rs file contains a simple "Hello, World!" program to get you started. Inside main.rs, you will find the following code:

fn main() {
    println!("Hello, world!");
}

This is a very basic program that prints "Hello, world!" to the console when executed. To run your new project, navigate to the project directory and execute the following command:

cargo run

This will compile your program and execute it, displaying the output in your terminal. Cargo automatically handles compiling and running your program for you, making it much easier to get started with Rust development. If you want to build the project without running it, you can use the cargo build command, which will generate an executable file in the target/debug directory. As you progress with your Rust development, you can modify the main.rs file to add more functionality, or you can create additional files and modules to structure your code.

Linters and Formatters

Go to TOC

Linters and formatters are essential tools in Rust for ensuring that your code adheres to best practices and remains consistent throughout the development process. A linter is a tool that analyzes your code for potential errors, stylistic issues, or patterns that may lead to bugs. Rust's ecosystem provides several linters, with the most commonly used one being clippy. Clippy is a powerful linter that checks for a wide variety of potential mistakes and bad practices, helping you write cleaner, more efficient, and more idiomatic Rust code. When you run clippy, it performs a detailed static analysis of your Rust code, checking for common mistakes, like unnecessary allocations, non-idiomatic patterns, or code that may not be as efficient as it could be. It can also suggest more idiomatic solutions to problems, which can help you follow the best practices for writing Rust code. Here's a simple example of running clippy on your project:

cargo clippy

This command runs clippy on the current project, analyzing your code for potential issues. The tool will output warnings and suggestions, helping you identify where improvements can be made. For instance, clippy might suggest replacing a for loop with an iterator method to make the code more idiomatic and performant. This process helps us avoid many common pitfalls and ensures our code is optimized for both performance and clarity. In addition to clippy, the Rust ecosystem provides a code formatter called rustfmt. Rustfmt automatically formats your code to ensure consistent indentation, spacing, and line length according to Rust's style guidelines. Formatting your code is an important aspect of teamwork, as it ensures that everyone on a project follows the same conventions, making it easier to read, maintain, and contribute to the codebase. When you run rustfmt, it automatically formats your Rust files, ensuring that they conform to the official style guide. To format your code with rustfmt, you simply run:

cargo fmt

This command formats all the Rust files in the current project. rustfmt is highly customizable, allowing you to configure various options, such as line length and indentation style, to match the specific needs of your project or team. By using both clippy and rustfmt, we can significantly improve the quality of our code, ensuring that it is both correct and maintainable. This process not only helps avoid common mistakes but also promotes consistency and readability across the entire codebase. The use of linters and formatters is a crucial part of Rust's emphasis on safety and quality, helping us write code that is not only functional but also clean and easy to work with. In large codebases or team environments, using these tools ensures that everyone is on the same page, reducing friction and enhancing collaboration. It is also worth noting that both clippy and rustfmt are often integrated into development workflows and CI/CD pipelines, so code quality is automatically maintained throughout the development process.

Basic Rust Concepts

Go to TOC

Rust is a systems programming language that emphasizes memory safety, concurrency, and performance. Its core concepts revolve around ownership, borrowing, and lifetimes, which are designed to eliminate common bugs that other programming languages struggle with, such as data races, null pointer dereferencing, and memory leaks. Understanding these concepts is critical to becoming proficient in Rust. The concept of ownership in Rust means that each value in the program has a single owner, and the ownership can be transferred (moved) or borrowed. This ownership model ensures that there is exactly one owner of each value at any given time, making it impossible for multiple parts of the program to accidentally modify or access the same data concurrently. The rules of ownership are enforced at compile-time, which means that many common errors are caught before the program ever runs. Rust's ownership system is tightly integrated with its borrowing and lifetime mechanisms, which together form the foundation of memory safety in the language.

Borrowing allows one part of a program to temporarily access data without taking ownership of it. Rust distinguishes between two types of borrowing: immutable borrowing, where the data cannot be modified, and mutable borrowing, where the data can be modified. The borrow checker ensures that there is either only one mutable reference or multiple immutable references to a piece of data at any given time. This prevents data races and ensures that data is accessed safely across different threads or parts of the program. The concept of lifetimes is closely tied to borrowing, as it describes how long references to data are valid. Lifetimes are a way of ensuring that references don't outlive the data they point to, which prevents use-after-free errors and dangling pointers, common issues in other languages. Together, ownership, borrowing, and lifetimes enable Rust to offer memory safety guarantees without the need for a garbage collector, making it both efficient and reliable for building high-performance systems.

Rust also introduces the concept of pattern matching, which allows you to work with data in a concise and expressive way. Pattern matching in Rust is an incredibly powerful tool, enabling is to destructure data types, check conditions, and perform actions based on the structure and values of data. The match statement in Rust is a form of pattern matching that is used extensively throughout the language. It allows you to match against various possible values of an enum, struct, or other types, providing a clean and expressive way to handle different cases. Here's an example of using match with an enum:

enum Direction {
    Up,
    Down,
    Left,
    Right,
}

fn move_player(direction: Direction) {
    match direction {
        Direction::Up => println!("Moving up"),
        Direction::Down => println!("Moving down"),
        Direction::Left => println!("Moving left"),
        Direction::Right => println!("Moving right"),
    }
}

In this example, the match statement checks the value of the direction variable and executes the corresponding branch. Pattern matching helps reduce boilerplate code, making your programs more concise and easier to maintain. Along with match, Rust's if let and while let constructs provide further ways to destructure and handle data in a more flexible and readable manner. The language's emphasis on pattern matching makes it an excellent choice for writing concise, expressive, and error-free code.

Variables

Go to TOC

In Rust, variables are immutable by default, which means that once a value is assigned to a variable, it cannot be changed. This immutability is a key feature of Rust's design, as it promotes safety and predictability in code. When you declare a variable, Rust ensures that the value cannot be modified unless you explicitly declare it as mutable. This default immutability makes it easier to reason about how data is used in a program, as you don't have to worry about unexpected modifications happening elsewhere in the code. To declare a mutable variable, you use the mut keyword:

let mut x = 5;
x = 6;

In this case, x is mutable, meaning that its value can be changed. The let mut syntax indicates that x can be reassigned, and this is the only way to change a variable's value in Rust. If you try to modify an immutable variable, the Rust compiler will produce an error, ensuring that you don't unintentionally modify data. The immutability of variables in Rust encourages developers to use data in a more controlled and predictable way. It reduces the risk of bugs related to data being changed unexpectedly in other parts of the program, making the code more maintainable and reliable. However, if you need to modify a value, Rust provides the flexibility of using mutable variables, which are necessary for many situations, such as when managing state in a program.

Rust also offers the concept of shadowing, where you can declare a new variable with the same name as an existing one, effectively replacing it. This can be useful when you want to change the value of a variable but also keep the original type. Shadowing allows for reassignment of the variable without the need for mut, and it's important to note that shadowing does not mutate the original variable; instead, it creates a new binding. Here's an example of shadowing:

let x = 5;
let x = x + 1;

In this case, the second x shadows the first x, and the value of x is incremented by one. The original x is no longer accessible, and the new variable takes its place. Shadowing can be useful when transforming data through different stages or scopes, as it allows you to reuse variable names without worrying about modifying the original value.

Constants

Go to TOC

Constants in Rust are similar to variables, but with a key difference: they are always immutable and their values are fixed at compile time. Constants are declared using the const keyword, and they must always have an explicit type annotation. Unlike regular variables, constants can be used in contexts where a variable would not be allowed, such as array sizes or static memory locations. Constants are evaluated at compile time, which makes them more efficient than regular variables in certain cases. For example, a constant can be used to define a value that is needed across the entire program, like a fixed configuration value or a mathematical constant, and it will not take up memory at runtime.

const MAX_POINTS: u32 = 1_000_000;

Here, MAX_POINTS is a constant that cannot be changed during the program's execution, and its value is available for use anywhere in the program. Constants are particularly useful for defining values that will remain the same throughout the program's lifetime, such as mathematical constants like PI, conversion factors, or predefined configuration values. Since constants are evaluated at compile time, they provide performance benefits by reducing runtime overhead and ensuring that the values they represent are fixed before the program starts running. Another key advantage of constants is that they are available in both the global and local scopes, making them versatile and easy to work with.

Constants can be used in expressions, just like regular variables, and are available for use in all places where a constant value is needed, such as array sizes or memory allocation. The fact that they are immutable and evaluated at compile time ensures that they are always safe to use and will never result in unexpected behavior. Constants in Rust provide a level of predictability and stability to your program, making them an excellent choice for handling fixed values that do not change throughout the execution of the program. They also contribute to Rust's strong type system, ensuring that values are explicitly typed and used consistently across the codebase.

Functions

Go to TOC

Functions in Rust are used to encapsulate logic that can be reused throughout a program. Functions allow you to break down a complex problem into smaller, manageable pieces, promoting modularity and reusability in your code. Rust functions are declared using the fn keyword, followed by the function name, parameters, and return type. Functions can take any number of parameters and can return a value, though returning a value is optional. In Rust, every function has a clear and explicit return type, and the compiler enforces type safety by ensuring that the return type matches the expected type. Here's an example of a simple function:

fn add(x: i32, y: i32) -> i32 {
    x + y
}

This function takes two parameters, x and y, both of type i32, and returns their sum. The -> i32 part specifies that the function will return a value of type i32. Functions in Rust are very flexible, and you can define functions that don't return anything, in which case the return type is (), which is similar to void in other languages. Functions can also accept default values for their parameters, making them more flexible and reducing the need for multiple function overloads. This is particularly useful when you want to provide reasonable defaults while still allowing for customization when necessary.

Rust also supports closures, which are anonymous functions that can capture variables from their surrounding environment. Closures are particularly useful for passing short-lived functions as arguments to higher-order functions, and they can capture values either by reference or by value. Here's an example of a closure that captures a variable from its environment:

let add_one = |x: i32| x + 1;
println!("{}", add_one(5));  // Prints 6

Closures in Rust are versatile and can be used in many situations, such as when implementing callbacks or when performing short tasks that don't warrant a separate function declaration. Rust's functional programming capabilities, combined with its ownership and borrowing model, allow closures to be used safely and efficiently.

Assertions and the assert! Macro in Rust

Go to TOC

In Rust, performing checks on the correctness of our code is often essential, particularly when we want to validate certain assumptions or ensure that specific conditions hold true during execution. One of the key tools provided by the Rust language for such checks is the assert! macro. The assert! macro allows us to assert that a given condition evaluates to true. If the condition is false, the program will panic and terminate immediately, thereby signaling an issue that needs to be addressed. This mechanism is especially useful during development and debugging phases, where catching errors early on can prevent more serious issues later.

fn divide(numerator: f64, denominator: f64) -> f64 {
    assert!(denominator != 0.0, "Denominator must not be zero!"); // Assertion
    numerator / denominator
}

In the code snippet above, we are using the assert! macro to ensure that the denominator is not zero before performing a division. If the denominator is zero, the program will panic with the provided error message, which serves as a clear indicator of the problem. This feature is particularly valuable in preventing division by zero errors, which, without proper checks, could lead to undefined behavior or runtime exceptions that are difficult to debug.

Rust's assertion mechanism is advantageous because it enables us to catch errors early in the development cycle. Assertions act as a safety net to verify that the code behaves as expected, especially before the program reaches production, where errors can lead to significant performance or reliability issues. By using assert!, we can ensure that assumptions about their program are validated during runtime, reducing the chances of introducing bugs into the final codebase.

The let Keyword and Type Inference

Go to TOC

Rust is a systems programming language designed with a strong emphasis on safety, performance, and concurrency. One of its goals is to make the development experience as productive as possible while maintaining a high level of performance. One of the ways Rust achieves this is through type inference, which allows us to write cleaner, more concise code without sacrificing safety or clarity.

When you declare a variable in Rust using the let keyword, the compiler automatically infers the type of the variable based on the value assigned to it. This reduces the need for explicitly specifying the type in many cases, allowing for more flexible and readable code. However, we still have the option to specify the type explicitly when necessary, especially in cases where ambiguity might arise or for more complex data structures.

fn main() {
    let fraction = 3.0; // Rust infers that `fraction` is of type f64
    println!("Fraction value: {}", fraction);
}

In this example, the variable fraction is assigned the value 3.0, which is a floating-point number. Because of Rust's type inference system, the type of fraction is automatically inferred to be f64 (a 64-bit floating-point number). The compiler determines this based on the fact that 3.0 is a floating-point literal. This eliminates the need for us to manually specify f64, making the code more concise and easier to maintain.

While Rust's type inference system is highly effective and handles most cases, there are scenarios where we might want to explicitly specify the type, such as when dealing with complex data structures, generics, or ambiguous situations. In these cases, the explicit type declaration helps ensure clarity and prevents unintended behavior due to type mismatches.

Functions and Returning Values

In Rust, functions are an essential part of structuring code and enabling code reuse. Functions are defined using the fn keyword, followed by the function name and its parameters enclosed in parentheses. The return type of a function is specified using the -> syntax, but it is not always necessary to specify it explicitly. Rust has a unique approach to function returns: if a function returns a value, the value is typically the result of the last expression in the function body. Rust does not require an explicit return keyword to return values, though it can still be used for clarity or to break early from a function.

fn square(x: i32) -> i32 {
    x * x // The last expression is implicitly returned
}

In this example, the function square takes an integer x and returns its square by multiplying x by itself. Since x * x is the last expression in the function body, Rust automatically returns this value, making the code clean and concise. The return keyword is not needed because Rust implicitly returns the result of the last expression in the function body. This approach is a key feature of Rust's emphasis on simplicity and efficiency.

By eliminating the need for an explicit return keyword, Rust helps reduce boilerplate code while still maintaining clarity. This results in more compact and readable functions, while also enforcing Rust's focus on performance by reducing unnecessary overhead in the code.

Rust's Type System

Rust's type system is one of its defining features, ensuring that errors related to data types are caught at compile time rather than runtime. This strong and static type system makes Rust a safer and more predictable language for building systems-level software. The system ensures that data is handled appropriately by enforcing strict typing rules, preventing issues such as null pointer dereferencing or type mismatches, which are common in languages with weaker typing systems.

Rust's type system is composed of two major categories: scalar types and compound types.

Scalar Types:

  • Integers: Represent whole numbers, such as i32 (signed 32-bit integer) or u64 (unsigned 64-bit integer).
  • Floating-Point Numbers: Represent real numbers with decimal points, using types like f32 (32-bit floating-point number) and f64 (64-bit floating-point number).
  • Booleans: Represent truth values, either true or false, using the bool type.

Compound Types:

  • Tuples: A collection of values that can be of different types. Tuples allow for grouping related data together in a single unit.
  • Arrays and Vectors: Collections of values of the same type. Arrays have a fixed size, while vectors can grow or shrink dynamically.

Rust's type system prevents a wide variety of errors by ensuring that every value has a well-defined type and that operations on these values are type-safe. The compiler checks these types at compile time, meaning that we can catch and fix potential issues before the program is run. This is a significant advantage over dynamically typed languages, where many errors are only detected during runtime, making debugging more challenging.

if Statements and Control Flow

Go to TOC

Control flow is fundamental in programming, and Rust provides familiar constructs for making decisions based on conditions. One of the most commonly used control flow structures is the if statement, which allows us to execute different blocks of code depending on whether a condition is true or false.

Rust's if statement follows a straightforward syntax:

if condition {
    // Code to execute if condition is true
} else {
    // Code to execute if condition is false
}

The if statement evaluates the condition first. If the condition evaluates to true, the code inside the block executes. If the condition is false, the code in the else block runs. Rust also supports the use of else if to handle multiple conditions.

fn classify_number(num: i32) {
    if num > 0 {
        println!("Positive");
    } else if num < 0 {
        println!("Negative");
    } else {
        println!("Zero");
    }
}

In this example, the function classify_number checks whether the input number num is positive, negative, or zero, and prints the corresponding result. The use of if, else if, and else allows for clear and structured decision-making. This provides an efficient way to implement branching logic in your programs, ensuring that code execution follows the correct path based on specific conditions.

Enums in Rust

Go to TOC

Rust's enum types are a powerful feature that allows us to define types that can represent multiple different variants, each potentially holding different types of data. Unlike enums in languages like C or C++, where each variant is a simple label, Rust's enums can carry associated data with each variant, making them much more flexible and expressive.

pub enum Hobbies {
    Coding,
    Reading,
    Hiking,
}

Here, the Hobbies enum defines three variants: Coding, Reading, and Hiking. These variants don't contain any associated data, but Rust allows each variant to hold data if necessary.

pub enum ArithmeticOperation {
    Add(i64, i64),
    Subtract(i64, i64),
    Division(i64, i64),
}

In this case, the ArithmeticOperation enum defines three arithmetic operations: Add, Subtract, and Division, each of which holds two i64 values. This allows for a more complex and flexible representation of arithmetic operations, enabling us to handle different operations in a single, unified type.

fn evaluate_operation(operation: ArithmeticOperation) -> i64 {
    match operation {
        ArithmeticOperation::Add(x, y) => x + y,
        ArithmeticOperation::Subtract(x, y) => x - y,
        ArithmeticOperation::Division(x, y) => x / y,
    }
}

fn main() {
    let add_operation = ArithmeticOperation::Add(5, 3);
    let result = evaluate_operation(add_operation);
    println!("Result: {}", result); // Output: Result: 8
}

This example demonstrates how pattern matching works with enums. The match expression allows us to destructure the ArithmeticOperation enum and perform the appropriate action based on the variant. Pattern matching is a powerful tool in Rust and makes working with enums straightforward and intuitive.

Rust Generics

Go to TOC

Generics are a core feature of Rust, allowing developers to write flexible and reusable code while maintaining type safety. With generics, we can create functions, structs, and enums that work with multiple data types without duplicating code or losing the benefits of Rust's strong typing system.

fn max<T: PartialOrd>(a: T, b: T) -> T {
    if a >= b {
        a
    } else {
        b
    }
}

In this example, the max function is generic and can accept any type T that implements the PartialOrd trait, which is required for types that can be compared and partially ordered (e.g., NaN cannot be ordered). This allows the function to compare two values of any type that supports ordering, providing a reusable solution that works for a wide variety of data types.

let int_result = max(5, 10); // T is i32
let float_result = max(3.4, 2.1); // T is f64
println!("Max integer: {}", int_result);
println!("Max float: {}", float_result);

Here, we demonstrate how the max function can work with different types of data. By leveraging generics, we avoid the need to write separate max functions for i32, f64, or any other type, making the code more maintainable and reusable. Rust's generics system provides a powerful and flexible way to write type-safe code that can work with any data type.

Optional Enums (Option)

Go to TOC

Rust's Option enum is one of its most powerful and widely-used features. It represents an optional value - either a value of type T or nothing at all (None). This is particularly useful for situations where a value may be missing, such as when querying a database or performing a search.

pub enum Option<T> {
    Some(T),
    None,
}

The Option enum has two variants: Some, which holds a value of type T, and None, which represents the absence of a value. This enum is commonly used for error handling and dealing with optional data.

fn divide(numerator: i64, denominator: i64) -> Option<i64> {
    if denominator == 0 {
        None // Return None if the denominator is zero
    } else {
        Some(numerator / denominator) // Return Some with the result
    }
}

fn main() {
    let result = divide(10, 2);
    match result {
        Some(value) => println!("Quotient: {}", value),
        None => println!("Cannot divide by zero"),
    }
}

In this example, the divide function returns an Option. If the denominator is zero, the function returns None, signaling an error. Otherwise, it returns the quotient wrapped in Some. The match expression is used to handle both cases of the Option, ensuring that the program handles both valid and invalid scenarios in a type-safe and predictable manner. This approach is a great example of how Rust uses enums to handle errors in a way that avoids the pitfalls of null pointers or exceptions common in other languages.

Traits

Go to TOC

Rust's type system is robust, allowing you to set constraints on the data types used in your programs. This is achieved through traits, which act as interfaces or agreements that define the behavior of a type. A trait specifies which functionalities a type must implement to conform to it.

A commonly used trait in Rust is the PartialOrd trait. As we saw in the previous example with the max function, the PartialOrd trait defines an ordering for a type, making it possible to compare values of that type. This allows us to write functions like max and min, which work with values that can be ordered.

In the generic max function example, we add a constraint that T must implement the PartialOrd trait. This ensures that we can compare the values correctly, as they are ordered relative to each other.

The following is an example of a while loop that works with the Iterator type, which implements the IntoIterator trait in Rust's standard library. The IntoIterator trait converts collections like arrays into iterators, enabling the use of for-loops:

let seasons: [&str; 4] = ["Winter", "Spring", "Summer", "Fall"];
let mut iter = seasons.into_iter();  // Convert `seasons` array into an `Iterator`

while let Some(season) = iter.next() {  // Loop until the iterator is empty
    println!("{}", season);
}

Alternatively, using a for loop simplifies the syntax:

let seasons: [&str; 4] = ["Winter", "Spring", "Summer", "Fall"];
for season in seasons.into_iter() {  // Loop through the iterator
    println!("{}", season);
}

This demonstrates how the IntoIterator trait converts a collection into an iterator and allows us to iterate over it cleanly.

The Iterator trait itself defines two important components:

  1. Item type: The type of value produced during iteration. For example, if iterating over a vector of integers, the Item type would be i32.
  2. next method: This method returns an Option<:item>, yielding either Some(v) for the next value or None to indicate the end of the iteration.

Here's how we can define a custom iterator for a vector of integers:

struct IntegerVector {
    vector: Vec<&'static i32>,
    index: usize,
}

impl Iterator for IntegerVector {
    type Item = &'static i32;

    fn next(&mut self) -> Option<Self::Item> {
        if self.index >= self.vector.len() {
            None
        } else {
            let item = self.vector[self.index];
            self.index += 1;
            Some(item)
        }
    }
}

You can then use this iterator like this:

let vector = vec![&1, &2, &3];
let mut iter = IntegerVector { vector, index: 0 };

while let Some(val) = iter.next() {
    println!("{}", val);
}

This example shows how to implement and use a custom iterator, leveraging the flexibility of Rust's iterator traits.

Ownership

Go to TOC

In Rust, ownership is a central concept that ensures memory safety without the need for a garbage collector. The core rule is that each value can have only one owner at a time, which ensures that the value is freed properly when no longer needed.

Consider this simple example:

fn main() {
    let s = String::from("hello");  // s owns the string "hello"
    let t = s;  // t now owns the string "hello"
    println!("{}", s);  // This won't compile because s no longer owns the string
    println!("{}", t);  // This will print "hello"
}

In this example, ownership of the string is transferred from s to t. After the transfer, s is no longer valid, and any attempt to use it will result in a compile-time error. Rust's ownership model prevents issues like memory leaks and dangling pointers, making memory management more efficient.

Borrowing

Go to TOC

Borrowing in Rust allows functions to access data without taking ownership, which prevents unnecessary data copies and enables safer memory access. Borrowing can be either mutable or immutable, depending on whether the data can be modified.

Here's an example of immutable borrowing:

fn calculate_length(s: &String) -> usize {
    s.len()  // We only borrow the reference to the string
}

fn main() {
    let s = String::from("hello");
    let len = calculate_length(&s);  // Pass a reference to s
    println!("The length of '{}' is {}.", s, len);  // s is still usable
}

In this case, the calculate_length function borrows the string s without taking ownership, meaning s can still be used after the function call.

Lifetimes

Go to TOC

Lifetimes are a way for Rust to track how long references to data are valid. They help prevent dangling references, ensuring that data is not accessed after it is no longer valid.

The following is an example of a function with a lifetime annotation:

fn print_string<'a>(s: &'a str) {
    println!("{}", s);  // Print the string
}

fn main() {
    let s = String::from("Hello, world!");
    print_string(&s);  // Pass a reference to the string
}

In this case, the 'a lifetime annotation tells Rust that the reference s is valid for at least as long as the print_string function is using it.

Lifetimes also apply to mutable references:

fn mutate_string<'a>(s: &'a mut String) {
    s.push_str(", world!");  // Modify the string
}

fn main() {
    let mut s = String::from("Hello");
    mutate_string(&mut s);  // Pass a mutable reference
    println!("{}", s);  // Prints "Hello, world!"
}

In this example, the mutable reference s is valid for as long as the mutate_string function uses it, ensuring the memory is safely managed.

Wrap Up

Go to TOC

Congratulations, comrade 🫡! You've successfully learned some of the core concepts in Rust, including traits, ownership, borrowing, and lifetimes. With these foundational tools in your toolkit, you're now ready to take on more advanced projects and explore more complex domains like web development, game design, or even data science. Rust's efficiency and safety features will help you write faster, more reliable code while avoiding common pitfalls like memory leaks or race conditions. The possibilities are endless, and the cosmos is your canvas!

So, now that you're equipped with these skills, what's next? Keep building, keep experimenting, and don't forget to make use of Rust's powerful documentation. It's there to guide you as you grow your skills.

But hey, remember. Rust isn't just about writing code. It's about writing efficient, safe, and blazingly fast code that's built to last. As Rustaceans (that's you now!) we must carry the science of memory safety forward. So, let's keep pushing boundaries and make the web, data science, and everything in between that much better with the power of Rust!

We are Open SASS, babe!.

We're working tirelessly on making Rust web development extremely easy for everyone.

If you made it this far, it would be nice if you could join us on Discord.

Together, let's move the web beyond JavaScript, and into something that actually compiles.

Feel free to share this. Fork it. Turn it into a meme. Tattoo it on your CI pipeline. Tell your manager Rust is your spirit animal now.