Introduction to Rust

Why Rust?

Rust is a modern programming language that focuses on three big things: safety, speed, and concurrency. It's often compared to languages like C and C++ because it gives you low-level control over your computer's hardware. But it also has a secret weapon: a very strict compiler.

The Rust compiler is famous for being picky. It checks your code for common bugs, like memory errors, before it even runs. This means if your code compiles, it's much less likely to crash unexpectedly.

This focus on safety doesn't come at the cost of performance. Rust code is incredibly fast and memory-efficient, making it great for everything from tiny embedded devices to massive web servers.

Setting Up Your Workspace

Getting started with Rust is straightforward. The official tool for managing Rust installations is called rustup. To install it, you'll typically run a single command in your terminal. On macOS, Linux, or other Unix-like systems, it's:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Once installed, rustup gives you access to the Rust compiler (rustc) and Rust's package manager and build tool, cargo. You'll use cargo for almost everything.

Let's create our first project. In your terminal, run:

cargo new hello_world

Cargo creates a new directory called hello_world with two files: Cargo.toml for project configuration and a src directory containing main.rs, our main source file. Cargo has already generated a "Hello, world!" program for us in main.rs:

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

To compile and run this program, navigate into the project directory (cd hello_world) and use a single command:

cargo run

You should see Hello, world! printed to your terminal. That's it! You've successfully built and run your first Rust program.

Rust's Core Building Blocks

Now let's look at the basic syntax and concepts you'll use every day.

Variables and Mutability

In Rust, variables are immutable by default. This means once you assign a value, you can't change it. This is a safety feature that helps prevent bugs.

// This is an immutable variable
let x = 5;

// The line below would cause a compiler error!
// x = 6;

If you need a variable you can change, you have to explicitly tell the compiler by using the mut keyword.

// This is a mutable variable
let mut y = 10;
y = 11; // This is perfectly fine.

Data Types

Rust is a statically typed language, which means it must know the types of all variables at compile time. However, the compiler is smart and can usually infer the type for you. Some basic types include:

Integers: i32 (32-bit signed integer) is a good default. Others include u64 (64-bit unsigned) and i8 (8-bit signed).
Floating-point numbers: f64 (double precision) and f32 (single precision).
Booleans: bool, which can be true or false.
Characters: char for single Unicode characters, like 'a' or '😻'.

let num: i32 = -50;
let pi: f64 = 3.14159;
let is_learning_rust: bool = true;
let letter: char = 'Z';

Functions

Functions are defined with the fn keyword. You specify the type of each parameter, and if the function returns a value, you specify its type after an arrow ->.

A cool feature of Rust is that the last expression in a function is automatically its return value. You don't need to write return or add a semicolon.

// This function takes two 32-bit integers
// and returns their sum as an i32.
fn add(a: i32, b: i32) -> i32 {
    a + b // No semicolon means this is the return value
}

fn main() {
    let sum = add(5, 7);
    println!("The sum is {}", sum); // Prints "The sum is 12"
}

Control Flow

Rust has the standard control flow structures you'd expect. The if expression lets you branch your code based on a condition.

let number = 6;

if number % 4 == 0 {
    println!("number is divisible by 4");
} else if number % 3 == 0 {
    println!("number is divisible by 3");
} else {
    println!("number is not divisible by 4 or 3");
}

For looping, Rust provides loop, while, and for. The for loop is the most common and is great for iterating over a collection of items, like an array.

let numbers = [10, 20, 30, 40, 50];

for element in numbers {
    println!("the value is: {}", element);
}

Basic Error Handling

Many operations in programming can fail, like reading a file that doesn't exist. Rust handles this with a special type called Result. A Result has two possible states:

Ok(value): The operation succeeded and contains the resulting value.
Err(error): The operation failed and contains information about the error.

To work with a Result, you can use a match expression, which is like a powerful switch statement. It forces you to handle every possible case, ensuring you don't forget to handle an error.

fn divide(numerator: f64, denominator: f64) -> Result<f64, String> {
    if denominator == 0.0 {
        // If division by zero, return an error
        Err(String::from("Cannot divide by zero!"))
    } else {
        // Otherwise, return the successful result
        Ok(numerator / denominator)
    }
}

fn main() {
    let result = divide(10.0, 2.0);

    match result {
        Ok(value) => println!("Result: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

This pattern makes error handling explicit and robust. The compiler won't let you ignore a potential failure, which helps you write more reliable software.

These are the fundamental pieces of Rust. By combining variables, functions, and control flow, you can start building powerful and safe applications.

Quiz Questions 1/5

Which command is used to create a new Rust project called my_app?

Quiz Questions 2/5

By default, variables in Rust are mutable.

Rust and AI Database Construction

Rust and AI Database Construction

Introduction to Rust

Why Rust?

Setting Up Your Workspace

Rust's Core Building Blocks