Forem: SheerLuck

Learn Rust Ownership and Borrowing By Building Mini Grep

SheerLuck — Thu, 09 Apr 2026 00:00:00 +0000

In this post, we are going to learn about the problem Rust is solving, Rust's ownership, borrowing concept and build a mini grep clone in Rust. I'm really excited for the project and I hope you are too. I won't go too deep in theory, just practical and we will build our knowledge of these concepts over time with more articles. Let's start.

You can get the complete source code here

The Problem Rust is Solving

Every program needs memory and you use memory to store data like strings, numbers, lists whatever. There is an important question we need to answer and that is who is responsible for freeing that memory when you're done with it?

There are two traditional answers.

The Programmer Does it Manually

Like in C programming language, you call malloc to allocate memory and free to release it. The best part of this thing is speed and control but the problem is that we can make mistakes and we might free memory twice or forget to free it or use it after freeing it.

These bugs are problematic. They're hard to reproduce and hard to debug.

The Language Does it Automatically

Like in Python programming language. There is a garbage collector runs in the background, figures out what memory is no longer reachable, and frees it. The best part is you basically can't have those dangerous memory bugs but the problem is performance. The garbage collector runs at unpredictable times, pauses your program and add overhead.

When it comes to Rust, it gives you memory safety without a garbage collector. It does this through a system. This system is built on three ideas: ownership, borrowing and slices.

Ownership

Here's the core idea: in Rust, every piece of data has exactly one variable that "owns" it. When that variable goes out of scope, the data is automatically freed. No GC needed, because the compiler can figure out exactly when each piece of data should be cleaned up just by looking at the code.

fn main() {
    let s = String::from("hello"); // s owns the string
} // s goes out of scope here and Rust automatically frees the string

I hope you understand the above example but now lets get to the interesting part.

What happens when you do this?

let s1 = String::from("hello");
let s2 = s1;

In most languages, you'd expect both s1 and s2 to point to the same string or s2 to be a copy of s1. In Rust, neither happens. **Ownership moves from s1 to s2.

After the second line, s1 no longer exists as far as the compiler is concerned. Try to use it and you get a compile error:

let s1 = String::from("hello");
let s2 = s1;
println!("{}", s1); // ERROR: value borrowed here after move

You might ask, why does Rust do this? Because String is heap allocated. If both s1 and s2 owned it, who would free it? If both tried, you'd have a double free bug.

So by keeping a single owner, Rust keeps it simple.

But for simple types like integers don't have this issue as they live on the stack, copying them is trivial and there's no heap memory to worry about. So, for those, Rust just copies:

let x = 5;
let y = x;
println!("{}", x); // Fine - integers are copied not moved

Technically, integers implement the Copy trait. String does not, so it moves instead. We will understand what trait is later in the series.

Borrowing

Now the question is, if ownership moves when you pass data around, how do you actually use data in function? If you pass a String into a function, does the function consume it?

fn print_it(s: String) {
    println!("{}", s);
} // s is dropped here

fn main() {
    let s = String::from("hello");
    print_it(s); // ownership moves into the function
    println!("{}", s); // ERROR: s was moved
}

Now, this is a problem. If you can't use s anymore once you pass it to a function, then its too much restrictive. You don't want every function call to permanently consume your data. To handle this situation, Rust gives you borrowing. This means instead of giving ownership, you lend a reference to the data.

fn print_it(s: &String) {
    println!("{}", s);
} // the reference goes out of scope, but the original string is unaffected

fn main() {
    let s = String::from("hello");
    print_it(&s); // lend a reference, don't move ownership
    println!("{}", s); // still works, s is still the owner
}

The & means "a reference to". You're not passing the string directly instead you are passing a pointer to the string and the compiler tracks this carefully. The function can look at the data through the reference but it doesn't own it, so it can't free it and ownership stays with the original variable.

This is called a shared reference or an immutable reference. Through this reference, you can read, but you can't modify. You can have as many of these as you want simultaneously because reading doesn't conflict with reading.

Mutable References

What if you need to modify data? There's a mutable reference for that:

fn add_world(s: &mut String) {
    s.push_str(" world");
}

fn main() {
    let mut s = String::from("hello");
    add_world(&mut s);
    println!("{}", s); // "hello world"
}

If you want mutable access, then you need to make the variable as mut mutable and give a mutable reference to the function. But there's a catch, you can have one mutable reference at a time, and you cannot have any immutable references at the same time. Wait, let me give you an example:

let mut s = String::from("hello");

let r1 = &s; // immutable borrow
let r2 = &mut s; // ERROR: can't borrow as mutable while immutable borrow exists

But why can't we do this, what's the issue? Because if you could read and write at the same time, you'd have a data race, you're reading data while something else is modifying it. The result is undefined and Rust makes this entire category of bug impossible at the compile time.

To give you a mental model of this borrowing concept:

You can have either many readers or one write, never both simultaneously. This is not enforced at runtime but by the compiler before your code runs.

Slices - Borrowing a Piece of Something

Sometimes you don't want to borrow an entire String, you just want to borrow part of it. That's what slices are for.

let s = String::from("hello world");
let hello = &s[0..5];
let world = &s[6..11];

hello here is of type &str. Note that, its not a new string, instead it's a reference that points directly into the memory of s.

A slice is a borrow. It points into someone else's data and that means while a slice is alive, the borrow checker won't let you modify or drop the original.

let mut s = String::from("hello world");
let word = &s[0..5]; // word borrows from s
s.clear() // ERROR: can't mutate s while word is borrowing from it
println!("{}", word)

If s.clear() were allowed, it would wipe out that word is pointing and you'd have a dangling reference (a pointer into freed memory). In C, this compiles and runs, and crashes or corrupts data unpredictably. In Rust, it doesn't compile. The borrow checker sees that word is still alive and still pointing into s, and it rejects the mutation.

&str vs &StringYou'll see both &str and &String in Rust code, and the distinction matters:&String is a reference to a heap allocated String object&str is a reference to a sequence of UTF-8 bytes

In practice, when writing functions that just need to read a string, you should prefer &str as the parameter type as it accepts both string literals and references to String values.

Let's now start building our grep clone but before that lets learn a little bit about mini grep.

Grep 101

grep is a command line tool that searches through text for lines that match a pattern. That's it. The name stands for Global Regular Expression Print. It reads input, tests every line against a pattern and prints the lines that match.

Open your terminal and try this:

echo -e "hello world\ngoodbye world\nhello rust" | grep "hello"

Output:

hello world
hello rust

It went through three lines and found two that contained the word "hello", and printed those. The third line didn't match so it was ignored. Now, lets try with a flag:

echo -e "hello world\ngoodbye world\nhello rust" | grep -v "hello"

output:

goodbye world

-v means invert, this print lines that do not match

Let's try another flag:

echo -e "hello world\ngoodbye world\nhello rust" | grep -c "hello"

output:

-c means count, this don't print lines instead just print how many matched

What are we Building

Before touching main.rs, let me tell you what we are building: Our program will:

accept a pattern and a path from the command line
accept optional flags
walk the directory (or read a single file) recursively
for each file, read its contents, search line by line
print results with filename, line number

Project Setup

Run this in your terminal:

cargo new rgrep
cd rgrep

Now open the Cargo.toml file and add the dependencies with this:

[package]
name = "rgrep"
version = "0.1.0"
edition = "2024"

[dependencies]
regex = "1"
walkdir = "2"

We have added three dependencies:

regex compiles and runs regular expression patterns against text
walkdir recursively walks a directory tree, giving you every file one by one

Imports

Open src/main.rs and delete everything. Write this:

use regex::Regex;
use std::env;
use std::fs;
use walkdir::WalkDir;

use regex::Regex is used for regex operations
use std::env is used access process environment like command line arguments and environment variables
use std::fs here fs stands for file system and we are using this to read files, write files, checking if path exists etc.
use walkdir::WalkDir this helps us to do recursive directory walk. Basically we can give it a directory and it'll return the every entry inside

Reading Command Line Arguments

fn main() {
    let args: Vec<String> = env::args().collect();
}

Here, env::args() returns an iterator over the command line arguments. For example, when a user runs:

cargo run -- -v "hello" ./src

the arguments are: ["rgrep", "-v", "hello", "./src"]. The first element is always the program's own name.

An iterator is something you can step through one element at a time. The .collect() exhausts the iterator and gathers every element into a collection.

The type annotation Vec<String> tells Rust what kind of collection you want. .collect() can produce several types, so you have to specify.

Vec<String> means a growable list of owned strings. You can check my previous article for more info.

Why `String` and not `&str`?

You might ask, why use String and not &str? To answer this, you need to understand what &str actually is. A &str is a reference, it does not own data, it points to data that already exists somewhere in memory and has a defined lifetime. String literals like "hello" work as &str because the compiler compiles them directly into the binary, so they live for the entire duration of the program.

Command line arguments are different, they come from the operating system at runtime. There is no pre-existing place in your program's memory where they live. Rust has to allocate heap memory to hold each argument string as it reads it. String is the type for heap-allocated, owned string data, it carries the data with it and is responsible for freeing it when it goes out of scope. &str cannot do this because it is just a pointer, and a pointer needs something to point to.

So Vec<String> is the only option here. Each String in the vector owns its argument data, and the vector owns all the Strings. When args goes out of scope, everything is cleaned up automatically.

Validating Argument Count

if args.len() < 3 {
    println!("Usage: rgrep [OPTIONS] <pattern> <path>");
    eprintln!("Options: -v -c -l");
    std::process::exit(1);
}

args.len() returns how many arguments we have. The minimum valid call is:

rgrep "pattern" ./path

This gives us ["rgrep", "pattern", "./path"] a total of 3 elements. If there are fewer than three, the user didn't provide enough and we print an error and exit.

eprintln! is like println! but writes to stderr instead of stdout. Errors and usage messages conventionally go to stderr so they don't pollute the output when piping.

Finally, std::process::exit(1) terminates the program with exit code 1.

Parsing Flags

let mut invert = false;
let mut count_only = false;
let mut files_only = false;
let mut pattern_index = 1;

for i in 1..args.len() {
    match args[i].as_str() {
        "-v" => invert = true,
        "-c" => count_only = true,
        "-l" => files_only = true,
        _ => {
            pattern_index = i;
            break;
        }
    }
}

We start with four mutable variables. The first three tracks which flags were passed. pattern_index tracks where in args the pattern is. This starts with 1 because args[0] is always the program name

We are iterating over all the arguments and checking which flag is being passed by the user and then setting that to true. The _ is the catch-all, if its none of the above that means we have hit the pattern and we are recording its index and then stop the loop with break.

So, if the user runs rgrep -v -c "hello" ./src, after the loop: invert is true, count_only is true, pattern_index is 3 (pointing at "hello")

Extracting Pattern and Path

if pattern_index + 1 >= args.len() {
    eprintln!("Error: missing pattern or path");
    std::process::exit(1);
}

let pattern = &args[pattern_index];
let path = &args[pattern_index + 1];

After the flag loop, pattern_index is pointing to the pattern. The paths comes right after it at pattern_index + 1. If that index is out of bounds, the user forgot to provide one of them.

let pattern = &args[pattern_index] this is the borrowing concept. We don't need our own copy of the pattern, we just need to read it and act accordingly. So, pattern is a &String type, a reference that borrows from args. Same thing happens for path.

Compiling The Regex

let regex = match Regex::new(pattern) {
    Ok(r) => r,
    Err(e) => {
        eprintln!("Invalid pattern: {}", e);
        std::process::exit(1);
    }
};

Regex::new(pattern) takes the pattern string and compiles it into a Regex object. "Compiling" here means parsing the pattern syntax and building an internal state machine that can efficiently test strings against it.

Regex::new returns a Result<Regex, Error>, this is a enum with two variants: Ok(value) meaning success and Err(error) meaning failure. This is the way Rust handles operations that can fail.

match on a Result is the standard way to handle it:

Ok(r) - the pattern is compiled successfully, r is the Regex object
Err(e) - the pattern was invalid (malformed regex syntax). e is the error and we just print it and exit

If you don't understand clearly, no worries, we will learn more about it in a later article, for now just follow and finish the project

Walking the Directory

for entry in WalkDir::new(path).into_iter() {
    let entry = match entry {
        Ok(e) => e,
        Err(_) => continue,
    };

    if !entry.file_type().is_file() {
        continue;
    }

    let file_path = entry.path();
}

WalkDir::new(path).into_iter() starts a recursive walk at path and gives us entries one at a time. Each entry is a Result<DirEntry> because reading a directory can fail may be due to permissions, broken symlinks, etc.

We match on each entry. Success case gives us DirEntry and in case of failure, we continue to the next iteration

If !entry.file_type().is_file() gives us both files and directories, we only care about files so we skip anything that is not a file with continue

entry.path() gives us a &Path, its a borrowed reference to the file's path. Path is Rust's type for filesystem paths.

Reading Files

Once we get to know that we got a file and not a directory, we are keeping its file path and then we are now going to read that file's content:

let contents = match fs::read_to_string(file_path) {
    Ok(c) => c,
    Err(_) => continue,
};

fs::read_to_string(file_path) reads the entire file and returns Result<String>. On success, contents has the file's text and on failure case (again may be due to permission or something else), we just continue to the next iteration.

The Search Function

We want to search through the content and get back the matching lines. The question we need to ask is what should the search function take and what should it return?

It should take contents as a borrow that means &str because it only needs to read the text, not own it.

For the return value, each matching line is a slice of contents. This means a &str pointing directly into file's text but returning those slices requires lifetime annotations, which we haven't covered yet. So instead we return an owned String copy of each matching line. It's of course less efficient but its correct and simple for now.

fn search(contents: &str, regex: &Regex, invert: bool) -> Vec<(usize, String)> {
    let mut results: Vec<(usize, String)> = Vec::new();
    let mut line_number = 1;

    for line in contents.lines() {
        let is_match = regex.is_match(line);

        let should_include = if invert { !is_match } else { is_match };

        if should_include {
            results.push((line_number, line.to_string()));
        }

        line_number += 1;
    }
    results
}

We are borrowing contents, regex as we only need to read them. The function is returning Vec<(uszie, String)>, this is a vector of tuples. Each tuple is a line number. contents.lines() gives each line as a &str slice pointing into contents.

Inside the loop, we are matching the regex with that line, then checking the invert flag and accordingly decides if we need to include the line and line number in the result or not.

line.to_string() converts the borrowed &str slice into an owned String. This is the copy that we take so we don't need to worry about the slice outliving contents. Finally, we are just returning the results

Run The Project

cargo run -- "fn" ./src

You should get something like this:

./src/main.rs:8: fn search(contents: &str, regex: &Regex, invert: bool) -> Vec<(usize, String)> {
./src/main.rs:27: fn main() {

You can try using flags too like this:

cargo run -- -c "fn" ./src

you should get something like this:

./src/main.rs: 2

Conclusion

This was a long one too but I think now you have some practical knowledge on ownership and borrowing. I'm not going too much theoretical as that'll be just boring. We'll learn more about Result in a later article. In the next one, we will build a JSON Parser by learning about structs, enums and pattern matching. See you soon.

Scalars Explained

SheerLuck — Sun, 05 Apr 2026 00:00:00 +0000

In this series we are going to learn all the maths that is required to learn machine learning or deep learning. All the post, will explain the concept, will have geometric intuition or understanding and then python code implementation. We will start from linear algebra.

What is a Scalar?

Before going to vectors, lets first understand what is a scalar? A scalar is a single real number. That is the complete definition. When we write: $$s \in \mathbb{R} $$

We are saying: $s$ is an element of the set of all real numbers.

Scalar has only one piece of information: its value.

Scalars live in $\mathbb{R}$ (the real number line). It includes every decimal, every fraction, every irrational number. Basically everything on a continuous number line.

What Can You Do With Scalars

The standard arithmetic operations all apply:

Operation	Notation	Example
Addition	$a + b$	$3 + 5 = 8$
Subtraction	$a-b$	$3-5=-2$
Multiplication	$a.b$	$3.5=15$
Division	$a/b$	$3/5=0.6$

These operations always produce another scalar. The output stays in $\mathbb{R}$.

Why Scalars Are Not Enough

Let's say you want to describe how an object is moving through 3D space. The object moves at 60 km/h. But 60 km/h where? Diagonally upward? A scalar cannot encode this. You need to know both how much (magnitude) and which way (direction)

In ML, you have a house with features: area = 1200 sq ft, bedrooms = 3, age = 10 years, price = $250,000. These are four separate scalars. But a model needs to process them together as one object, not as four disconnected numbers. A scalar cannot represent structured, multi-dimensional data.

This is the fundamental limitation of scalars:

A scalar carries magnitude (size/value) only. It carries no directional or structural information.

The Two Things We Need That Scalars Cannot Provide

Direction - When a quantity has both a size and direction like displacement, velocity, force. Here, a single number is insufficient. You need a mathematical object that encodes both simultaneously.
Structure across multiple dimensions - When data has multiple features that belong together as one unit like a data point in ML, you need an object that holds all dimensions at once and supports operations across them.

Both the things can be done with vectors , which is what we study from next article.

Conclusion

This was a quick one. In the next one you'll learn about vectors and vector spaces. See you soon.

Learn Rust Basics By Building a Brainfuck Interpreter

SheerLuck — Sat, 04 Apr 2026 00:00:00 +0000

Hi, In this series we are going to learn Rust programming language by building exciting projects per article. For every article, we will first learn some concepts and then build a mini project. I promise you these mini projects will be exciting. The only prerequisite is, you should know any one programming language like just basics of it as this series will focus on teaching rust and not programming from zero.

My motive is to explain how to do a certain thing in Rust, so I won't explain how a loop works or how a function works. I'll just explain how to work with variables, functions, loops etc in Rust but I'll explain Rust specific concepts in detail.

In this post, we are going to build a brainfuck language interpreter in Rust. But before that, we will learn about variables and mutability, scalar types, compound types, functions, basic string handling (we will dive deep in the next article), println! & basic macros. We will also learn about cargo and control flow in rust like if and else blocks, loops, and match (this is interesting).

You can get the source code from here

Let's start, I can't wait.

How Rust Works and Cargo

What happens when you write a Rust program?

Rust is a compiled language. This means before the program can run, it has to be translated from human readable Rust code into machine code that your CPU can directly execute. This translation is done by the Rust compiler called rustc.

Cargo

Cargo is Rust's official build system and package manager. It does multiple things:

creates new projects with a standard folder structure
compiles the rust code by invoking rustc under the hood
downloads and manages external libraries(in rust world we call them crates )
run tests, benchmarks and documentation generation

When you'll install Rust (via rustup), Cargo comes with it automatically.

Let me show you some of the common commands that you'll be using constantly:

Command	What it does
`cargo new project_name`	creates a new project folder with boilerplate
`cargo run`	compiles and immediately runs the binary
`cargo check`	checks for errors without producing a binary
`cargo build`	compiles your project, produces a binary

Project Structure

Let's try to create a project with Cargo: Open up your terminal and run the following command:

cargo new hello

It'll create a new Rust project called hello. Now, open the project folder in your preferred editor and you'll see a folder structure like this:

hello/
├── Cargo.toml
└── src/
    └── main.rs

Let me explain what each of these files are:

`Cargo.toml`

This is the manifest file for your project. It's written in TOML format (a simple config format). It contains:

[package]
name = "hello"
version = "0.1.0"
edition = "2024"

[dependencies]

name - the name of your project
version - your project's version
edition - which edition of Rust you are using
[dependencies] - this is where you list down the external crates your project needs. Initially its empty.

`src/main.rs`

This is the entry point of every Rust program. Cargo generates this for you:

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

fn is the keyword to define a function in Rust. main is the name of the function. The curly braces {} defines the body of the function.

println!("Hello, world!"); - println! is a macro, not a regular function. Notice there is a ! right before the parentheses !(). Macros are just code that generates other code at compile time. You don't need to understand how they work internally right now. Just keep in mind that println! prints a line of text to the terminal followed by a new line.

The text inside the quotes is a string literal. if you want to print values inside the string, you use {} as a placeholder:

println!("The value is {}", 42);

Variables and Mutability

Declaring Variables

In Rust, you declare a variable with let:

let x = 5;

This creates a variable named x and binds the value 5 to it.

Variables are Immutable by Default

This is one of Rust's core design decisions. Once you bind a value to a variable, you cannot change it unless you explicitly say you want to.

let x =5;
x = 6; // ERROR: cannot assign twice to immutable variable

To make a variable mutable, you need to add mut keyword:

let mut x = 5;
x = 6; // OK this is fine

Shadowing

Rust allows you to shadow a variable. This means you can declare a new variable with the same name which replaces the previous one:

let x = 5;
let x = x + 1; // this is a new `x`, not mutating the old one
let x = x * 2;
println!("{}", x); // prints 12

You need to understand that shadowing is different than mut. With shadowing, you are creating a brand new variable (and can even change its type). But with mut, you're modifying the same variable in place.

Data Type

Rust is statically typed. This means every variable has a type known at compile time. Most of the time the compiler can infer the type from context, so you don't have to write it explicitly. But you can always annotate it:

let x: i32 = 5;

The : i32 after the variable name is the type annotation.

Integer Types

Rust has multiple integer types. They differ in size (how many bits they use) and whether they can hold negative numbers:

Type	Size	Range
i8	8-bit signed	-128 to 127
i16	16-bit signed	-32,768 to 32,767
i32	32-bit signed	~-2 billion to ~2 billion
i64	64-bit signed	very large range
u8	8-bit unsigned	0 to 255
u16	16-bit unsigned	0 to 65,535
u32	32-bit unsigned	0 to ~4 billion
u64	64-bit unsigned	ver large range
usize	pointer-sized	depends on your OS (64-bit on 64-bit systems)

i32 is the default integer type when Rust infers. usize is special because its used for indexing into collections (arrays, vectors etc) because its size matches memory address size of your machine.

Boolean

let is_active: bool = true;
let is_done = false;

Only two values are there for boolean type in Rust: true or false

Character

let c: char = 'A';

Rust's char type represents a single Unicode scalar value. It uses single quotes (double quotes are for strings). A char is 4 bytes in Rust, not 1, because it can hold any unicode character.

Floating Point

let f: f64 = 3.14;

f32 and f64 are 32-bit and 64-bit floating point numbers. The default is f64 because on modern hardware it's roughly as fast as f32 but more precise.

Compound Types

Tuples

A tuple groups multiple values of potentially different types into one compound value. Let me show you an example:

let tup: (i32, f64, bool) = (500, 6.4, true);

One thing to note about tuples is that they have a fixed length. Once they are declared, then you cannot add or remove elements to the tuple.

But you can access elements from tuple, to do that you can use the dot notation with the index:

let x = tup.0; // 500
let y = tup.1 // 6.4
let x = tup.2 // true

You can also destructure a tuple. Destructuring means unpacking the tuple elements in individual variables:

let (a,b,c) = tup;
println!("{}", a); // 500

Arrays

An Array holds multiple values of the same type, with a fixed length.

let arr: [i32; 5] = [1,2,3,4,5];

The type annotation [i32; 5] means its an array of i32 with exactly 5 elements.

To access elements in array, you can use these []:

let first = arr[0]; // 1
let second = arr[1]; // 2

If you try to access an index that's out of bounds, then Rust will panic ( crash at runtime with an error message )

You can also create an array where every element is the same value:

let zeros = [0u8; 25]; // 25 elements all set to 0

This means, create an array of type u8 with 25 elements and intialize all the elements to 0.

Functions

Defining Functions

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

To define a function in rust you need to use the fn keyword. add is the function's name. (x: i32, y: i32) are the parameters. Parameter types are always required. -> i32 this means the function returns an i32 type and the body is inside the {}.

Return Values

In Rust, the last expression is a function body is automatically returned, that's why we didn't have a return keyword in the above function.

Statements end with a semicolon ; and do not produce a value but Expressions do not end with a semicolon and produce a value.

If you add a semicolon to the last line, it becomes a statement, produces no value and the function now returns () (this is called a unit type, basically nothing) instead of i32 and this would be a compilation error.

You can also keep it simple and use the return keyword:

fn check(x: i32) -> i32 {
    if x < 0 {
        return 0; // explicit return
    }
    x // implicit return
}

Control Flow

If/Else

let number = 7;
if number < 5 {
    println!("less than 5");
} else if number == 5 {
    println!("exactly 5");
} else {
    println!("greater than 5");
}

In Rust, the condition doesn't need parentheses but the body must be inside the curly braces.

`If` is an Expression

This is important to remember that in Rust, if is not just a statement, its an expression that produces a value:

let result = if number % 2 == 0 { "even" } else { "odd" };

Note that both the branches should produce the same type otherwise the compilation will fail.

Loop

loop runs a block of code forever until you explicitly break out of it:

let mut count = 0;
loop {
    count += 1;
    if count == 5 {
        break;
    }
}

loop can also return a value through break:

let result = loop {
    count += 1;
    if count == 10 {
        break count * 2; // returns this value from the loop
    }
}

While Loop

While loop runs as longs as a condition is true:

let mut n = 3;
while n > 0 {
    println!("{}", n);
    n -= 1;
}

For Loop

The most common loop in Rust. The for loop iterates over a collection or a range:

// iterating over an array
let arr = [10, 20, 30];
for element in arr {
    println!("{}", element);
}

// iterating over a range
for i in 0..5 {
    println!("{}", i); // prints 0, 1, 2, 3, 4
}

// 0..=5 includes 5 (inclusive on both ends)
for i in 0..=5 {
    println!("{}", i); // prints 0, 1, 2, 3, 4, 5
}

0..5 is a range, it starts from 0 and goes up to but not including 5. But 0..=5 is an inclusive range that includes 5.

Match

match is Rust's pattern matching construct. It compares a value against a series of patterns and executes the code for the first pattern that matches:

let x = 3;

match x {
    1 => println!("one"),
    2 => println!("two"),
    3 => println!("three"),
    4 => println!("four"),
    _ => println!("other")
}

Each line inside the match is called an arm : pattern => code_ is the wildcard pattern, it matches anything. It's used as a catch all default case. One thing you need to remember is that match is exhaustive. This means you must cover all the possible values. If you don't the compiler will reject your code.

Like if, match is also an expression and can return a value:

let name = match x {
    1 => "one",
    2 => "two",
    _ => "other",
};

you can also match multiple patterns with |:

match x {
    1 | 2 => println!("one or two"),
    3..=9 => println!("three through nine"),
    _ => println!("something else"),
}

Vectors (Brief Introduction)

Arrays have a fixed size known at compile time but sometimes you need a collection that can grow. This is where you can use a Vec<T>:

let mut v: Vector<char> = Vec::new();
v.push('a');
v.push('b');
println!("{}", v.len()); // 2

Vec::new() creates an empty vector
.push(value) adds an element to the end
.pop() removes and returns the last element
.len() returns the number of elements

Basic String Types

Rust has two main string types:

&str this is a string slice. It is an immutable reference to a sequence of UTF-8 bytes. String literals like "hello" have type &str.
String this is a heap allocated growable string. We will dive deep into these in the next article but for now just understand that if you need to have string literals, just use &str. If you need to build a string dynamically, then use the String type.

To iterate over each character of a string, you can use chars():

let s = "hello";
for c in s.chars() {
    println!("{}", c);
}

This is great, now you know everything to build your project. We are going to build a Brainfuck Interpreter in Rust.

The Brainfuck Interpreter

Before writing any code, lets fully understand what we've building.

What is Brainfuck?

Brainfuck is a programming language with only 8 instructions. The entire language fits in 8 characters. Despite that, it can compute anything a normal programming language can.

A brainfuck program operates on:

A memory tape - an array of cells, each holding a number (a u8, so values 0-255).
A data pointer - an index that points to the current cell on the tape. It starts at 0 (the leftmost cell)
A program - a string of characters, most of which are instructions

The 8 Instructions

Character	What it does
>	Move the data pointer one cell to the right
<	Move the data pointer one cell to the left
+	Increment the value at the current cell by 1
-	Decrement the values at the current cell by 1
.	Output the current cell's value as an ASCII character
,	Read one byte of input and store it in the current cell
[	If the current cell is 0, jump forward to the matching]
]	If the current cell is non-zero, jump back to the matching [

Every other character in a Brainfuck program is a comment, these gets simply ignored.

How Loop Works

[ and ] together form a loop. Let me explain:

When you hit [: check the current cell. If its 0, skip everything until the matching ]. If its non zero, enter the loop body.
When you hit ]: check the current cell. If its non-zero, jump back to the matching [. If its 0, exit the loop. This is basically a while (cell != 0) {...} loop.

What We Need to Build

A memory tape
A data pointer
A way to iterate through the program instruction by instruction basically a program counter (pc) as a usize
Bracket matching when we hit [ or ], we need to find the matching counterpart. We will precompute this into a map before running.

Create the Project

Let's start build our brainfuck interpreter. Open up your terminal and create a new project:

cargo new brainfuck-interpreter
cd brainfuck-interpreter

Open the project in your preferred editor and open the src/main.rs file and delete all the code

The Memory Tape and Pointers

Type this into src/main.rs:

fn main() {
    let program = "++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.";

    let mut tape = [0u8; 30000];
    let mut dp: usize = 0;
    let mut pc: usize = 0;
}

Now, let me explain what we just did:

let program = "..." this is a brainfuck program that prints "Hello World!". It's just a &str(string literal). Our interpreter will read through it character by character.
let mut tape = [0u8; 30000] this is our memory tape. This creates an array of 30,000 elements, each of them initialized to 0, and each of them is of type u8(values 0-255). We need mut because instructions + and - will modify the cells.
let mut dp: usize = 0 dp stands for data pointer. It's the index into tape that points to the current cell. It starts at 0. Its usize because array indices in Rust must be usize.
let mut pc: usize = 0 pc stands for program counter. Its the index into program pointing at the current instruction. It starts at 0.

Precomputing Bracket Matches

Before we run the program, we'll precompute where every [ matches with its ] and vice versa. This way, when we need to jump, we just do a lookup instead of scanning through the program every time. We'll store this in a Vec where the index is the position of [ or ] and the value is the position of its matching counterpart.

Add this before main, as a separate function:

fn build_bracket_map(program: &str) -> Vec<usize> {
    let bytes = program.as_bytes();
    let len = bytes.len();
    let mut map = vec![0usize; len];
    let mut stack: Vec<usize> = Vec::new();

    for i in 0..len {
        match bytes[i] {
            b'[' => {
                stack.push(i);
            }
            b']' => {
                let open = stack.pop().expect("Unmatched ]");
                map[open] = i;
                map[i] = open;
            }
            _ => {}
        }
    }
    if !stack.is_empty() {
        panic!("Unmatched [");
    }
    map
}

Now, let me explain everything:

fn build_bracket_map(program: &str) -> Vec<usize> this function takes a &str(the program text) and returns a Vec<usize>(the bracket map)
let bytes = program.as_bytes() here as_bytes() converts the &str into a slice of raw bytes &[u8]. This lets us compare characters as byte values using b'[' syntax(a byte literal). Its slightly more efficient than working with char here and brainfuck only uses ASCII characters so its completely valid.
let mut map = vec![0usize; len] here vec![value; len] is a macro that creates a Vec with count elements all set to value. So this creates a vector of len zeroes. Here, every position starts as 0.
let mut stack: Vec<usize> = Vec::new() this is our stack for tracking open brackets. When we see a [, we push its position. When we see a ], we pop the most recent [ position because that is its matching opening bracket.
for i in 0..len loop here we iterate through every index of the program
- match bytes[i] we match on the byte at position i
- b'[' => stack.push(i) when we see an open bracket, we push its index onto the stack.
- b']' when we see a close bracket
  - stack.pop() removes and returns the last pushed index(the matching [)
  - .expect("Unmatched ]") if the stack is empty, there's no matching [, so we crash with this error message. .expect() is a method on Option that either unwraps the value or panics with your message. We'll cover Option deeply later, but for now pop() returns None if the stack is empty and expect() handles that.
  - map[open] = i this means at the [ position, the jump target is ]
  - map[i] = open this means at the ] position, the jump target is [
- _ => {} for any other character, we will just ignore and do nothing
if !stack.is_empty() {panic!(...)} after processing the whole program, if the stack still has entries, that means there are unmatched [. panic! crashes the program with a message

The Main Execute Loop

Now back inside main function, after the variable declarations, call build_bracket_map and then write the execution loop:

fn main() {
    let program = "++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.";

    let mut tape = [0u8; 30000];
    let mut dp: usize = 0;
    let mut pc: usize = 0;

    let bracket_map = build_bracket_map(program);
    let bytes = program.as_bytes();

    while pc < bytes.len() {
        match bytes[pc] {
            b'>' => dp += 1,
            b'<' => dp -= 1,
            b'+' => tape[dp] = tape[dp].wrapping_add(1),
            b'-' => tape[dp] = tape[dp].wrapping_sub(1),
            b'.' => print!("{}", tape[dp] as char),
            b',' => { /* input not needed for Hello World */ }
            b'[' => {
                if tape[dp] == 0 {
                    pc = bracket_map[pc];
                }
            }
            b']' => {
                if tape[dp] != 0 {
                    pc = bracket_map[pc];
                }
            }
            _ => {}
        }
        pc += 1;
    }

    println!();
}

Now, let me explain this:

while pc < bytes.len() this keep executing as long as the program counter hasn't gone past the end of the program.
b'>' => dp += 1 moves the data pointer right, just incrementing the index
b'<' => dp -= 1 moves the data pointer left, just decrementing the index
b'+' => tape[dp].wrapping_add(1) this increments the current cell. We use .wrapping_add(1) instead of tape[dp] += 1 because our cells are u8(0-255). If the value is 255 and you add 1, a normal += would panic in debug mode due to integer overflow. The .wrapping_add instead wraps around to 0. This is standard brainfuck behaviour.
b'-' =? tape[dp].wrapping_sub(1) this decrements the current cell. Same idea as add operation.
b'.' => print!("{}", tape[dp] as char) this prints the current cell as an ASCII character. tape[dp] as char is a type cast from u8 to char type. For example, the value 72 becomes H. print!(without ln) prints without creating a newline.
b',' we leave it as an empty block as we are not taking input dynamically.
b'[' if the current cell is 0, then jump to the matching ] by setting pc = bracket_map[pc]. The pc += 1 at the bottom of the loop then moves us past the ].
b']' if the current cell is non-zero, then jump back to the matching [
_ => {} we are using this again to ignore any non instruction character
pc += 1 after processing each instruction, move the program counter to the next character
println!() after the program finishes, it prints a newline so your terminal prompt appears on a fresh line.

Finally, we covered a bunch of stuff and also built our project. Now lets try running it and see it in action. In your terminal, type:

cargo run

You should see an output like:

Compiling brainfuck-interpreter v0.1.0 (/Users/.../.../.../brainfuck-interpreter)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.10s
     Running `target/debug/brainfuck-interpreter`
Hello World!

Conclusion

In this post, you understood most of basic common things in Rust and build a simple brainfuck interpreter in Rust. In the next one, you are going to learn about ownership, borrowing and slices and build a mini grep clone that's gonna be fun. I hope to see you soon. Till then, goodbye!

Forem: SheerLuck

Learn Rust Ownership and Borrowing By Building Mini Grep

The Problem Rust is Solving

The Programmer Does it Manually

The Language Does it Automatically

Ownership

Borrowing

Mutable References

Slices - Borrowing a Piece of Something

Grep 101

What are we Building

Project Setup

Imports

Reading Command Line Arguments

Why String and not &str?

Validating Argument Count

Parsing Flags

Extracting Pattern and Path

Compiling The Regex

Walking the Directory

Reading Files

The Search Function

Run The Project

Conclusion

Scalars Explained

What is a Scalar?

What Can You Do With Scalars

Why Scalars Are Not Enough

The Two Things We Need That Scalars Cannot Provide

Conclusion

Learn Rust Basics By Building a Brainfuck Interpreter

How Rust Works and Cargo

What happens when you write a Rust program?

Cargo

Project Structure

Cargo.toml

src/main.rs

Variables and Mutability

Declaring Variables

Variables are Immutable by Default

Shadowing

Data Type

Integer Types

Boolean

Character

Floating Point

Compound Types

Tuples

Arrays

Functions

Defining Functions

Return Values

Control Flow

If/Else

If is an Expression

Loop

While Loop

For Loop

Match

Vectors (Brief Introduction)

Basic String Types

The Brainfuck Interpreter

What is Brainfuck?

The 8 Instructions

How Loop Works

What We Need to Build

Create the Project

The Memory Tape and Pointers

Precomputing Bracket Matches

The Main Execute Loop

Conclusion

Why `String` and not `&str`?

`Cargo.toml`

`src/main.rs`

`If` is an Expression