DEV Community: SomeB1oody

[Rust] 8.6. HashMap Pt.2 - Updating HashMaps

SomeB1oody — Sat, 11 Apr 2026 22:35:35 +0000

8.6.0. Chapter Overview

Chapter 8 is mainly about common collections in Rust. Rust provides many collection-like data structures, and these collections can hold many values. However, the collections covered in Chapter 8 are different from arrays and tuples.

The collections in Chapter 8 are stored on the heap rather than on the stack. That also means their size does not need to be known at compile time; at runtime, they can grow or shrink dynamically.

This chapter focuses on three collections: Vector, String, and HashMap (this article).

If you find this helpful, please like, bookmark, and follow. To keep learning along, follow this series.

8.6.1. Updating a HashMap

A variable-sized HashMap means that the number of key-value pairs can change. However, at any given moment, one key can correspond to only one value. When you want to update data in a HashMap, there are several possible cases:

The key you want to update already has a corresponding value in the HashMap:
- Replace the existing value with a new value
- Keep the existing value and ignore the new value
- Merge the existing value with the new value, which means modifying the existing value
The key does not exist: add a key-value pair

1. Replacing an Existing Value

If you insert a key-value pair into a HashMap, but the key already exists, the program assigns the new value to that key and overwrites the old one. Example:

use std::collections::HashMap;  

fn main() {  
    let mut scores = HashMap::new();  
    scores.insert(String::from("dev1ce"), 0);  
    scores.insert(String::from("dev1ce"), 60);  
    println!("{:?}", scores);  
}

Here the same key is assigned a value twice: first 0, then 60. The first value is overwritten by the second, which means the final value corresponding to "dev1ce" is 60.

Output:

{"dev1ce": 60}

2. Insert a Value Only if the Key Has No Existing Value

This is the most common case. In this situation, you first need to check whether the original HashMap already contains the key. If it does not, then insert the new value.

Rust provides the entry method to check whether the original HashMap already contains the key. Its argument is the key, and its return value is an Entry enum, which represents whether the value exists. Example:

use std::collections::HashMap;  

fn main() {  
    let mut scores = HashMap::new();  
    scores.insert(String::from("dev1ce"), 0);  
    let e = scores.entry(String::from("dev1ce"));  
    println!("{:?}", e);  
}

This is the case where the key already exists. Output:

Entry(OccupiedEntry { key: "dev1ce", value: 0, .. })

In other words, if the key already exists, the entry method returns the OccupiedEntry variant of the Entry enum and associates it with the existing key-value pair.

Now let’s try the case where the key does not exist. Code:

use std::collections::HashMap;  

fn main() {  
    let mut scores = HashMap::new();  
    scores.insert(String::from("dev1ce"), 0);  
    let e = scores.entry(String::from("Zywoo"));  
    println!("{:?}", e);  
}

Output:

Entry(VacantEntry("Zywoo"))

If the key does not exist, it returns the VacantEntry variant of the Entry enum and associates it with the new key.

Now that we can check whether the original HashMap already contains the key, how do we insert or skip insertion based on whether it exists?

Rust provides the or_insert method, whose argument is the value you want to add. It accepts an Entry enum and uses its two variants to decide whether to insert. If it receives OccupiedEntry (the key already exists), it keeps the existing value and does not insert a new one. If it receives VacantEntry (the key does not exist), it inserts the provided value. Most importantly, it returns a value: a mutable reference to the value for that key. If the key already exists, it returns a mutable reference to the value already in the HashMap; if the key does not exist, it first inserts the key-value pair and then returns a mutable reference to the inserted value. This behavior can be used to build simple counters, as we will see later.

Example:

use std::collections::HashMap;  

fn main() {  
    let mut scores = HashMap::new();  
    scores.insert(String::from("dev1ce"), 0);  

    scores.entry(String::from("Zywoo")).or_insert(100);  
    scores.entry(String::from("dev1ce")).or_insert(60);
    println!("{:?}", scores);  
}

The first entry statement looks up "Zywoo". Since it is not found, VacantEntry is returned, and or_insert receives it and creates the key-value pair ("Zywoo", 100) using the key associated with VacantEntry and the argument 100.
The second entry statement looks up "dev1ce". Since it is found, OccupiedEntry is returned, and or_insert receives it and stops the insertion of a new value, so ("dev1ce", 0) remains unchanged.

Output:

{"Zywoo": 100, "dev1ce": 0}

If this still feels complicated, you can think of scores.entry(String::from("Zywoo")).or_insert(100); as two lines of code:

let e = scores.entry(String::from("Zywoo"));
e.or_insert(100);

3. Updating Based on Existing Values

Let’s start with an example:

use std::collections::HashMap;  

fn main() {  
    let text = "That's one small step for [a] man, one giant leap for mankind.";  

    let mut map = HashMap::new();  

    for word in text.split_whitespace() {  
        let count = map.entry(word).or_insert(0);  
        *count += 1;  
    }  
    println!("{:#?}", map);  
}

First, a string literal containing a sentence is declared and assigned to text.
Then a HashMap called map is created.
Next comes the for loop. text.split_whitespace() splits text into an iterator over strings, and for is used to iterate over it.
During iteration, the code checks whether each word appears in the map. If it does, no new value is inserted. If it does not, 0 is inserted as the new value for that key. The key thing to understand is count: because the return value of or_insert is a mutable reference to the value for that key, each time a word appears, the code dereferences the mutable reference and adds 1, which is equivalent to completing one count.

8.6.2. Hash Functions

By default, HashMap uses a cryptographically strong hash function that can resist denial-of-service (DoS) attacks. However, this function is not the fastest hash algorithm available; its advantage is better security. If you think its performance is not good enough, you can also specify a different hasher to switch to another function. A hasher refers to a type that implements the BuildHasher trait.

[Rust Guide] 8.5. HashMap Pt.1 - Defining, Creating, Merging, and Accessing HashMaps

SomeB1oody — Sat, 11 Apr 2026 22:29:03 +0000

8.5.0. Chapter Overview

The collections in Chapter 8 are stored on the heap rather than on the stack. That also means their size does not need to be known at compile time; at runtime, they can grow or shrink dynamically.

This chapter focuses on three collections: Vector, String, and HashMap (this article).

If you find this helpful, please like, bookmark, and follow. To keep learning along, follow this series.

8.5.1. What Is a HashMap?

HashMap is written as HashMap<K, V>, where K stands for key and V stands for value. A HashMap stores data as key-value pairs, with one key corresponding to one value. Many languages support this kind of collection data structure, but they may call it something else—for example, the same concept in C# is called a dictionary.

The internal implementation of HashMap uses a hash function, which determines how keys and values are stored in memory.

In a Vector, we use indices to access data. But sometimes you want to look up data by key, and the key can be any data type, instead of by index, or you may not know which index the data is at. In that case, you can use a HashMap.

Note that HashMap is homogeneous, which means that all keys in one HashMap must be the same type, and all values must be the same type.

8.5.2. Creating a HashMap

Because HashMap is not used as often, Rust does not include it in the prelude. Before using it, you need to import HashMap by writing use std::collections::HashMap; at the top of the file.
To create an empty HashMap, use the HashMap::new() function.
To add data, use the insert() method.

Example:

use std::collections::HashMap;  

fn main() {  
    let mut scores: HashMap<String, i32> = HashMap::new();  
}

Here a variable named scores is created to store a HashMap. Because Rust is a strongly typed language, it must know what data types you are storing in the HashMap. Since there is no surrounding context for the compiler to infer from, you must explicitly declare the key and value types when you declare the HashMap. In this code, the keys of scores are set to String, and the values are set to i32.

Of course, if you later add data to this HashMap, Rust will infer the key and value types from the inserted data. Data is added with the insert() method. Example:

use std::collections::HashMap;  

fn main() {  
    let mut scores = HashMap::new();  
    scores.insert(String::from("dev1ce"), 0);
}

Because a key-value pair is inserted into scores on line 5, and the key String::from("dev1ce") is of type String while the value 0 is of type i32 (Rust’s default integer type is i32), the compiler will infer that scores is a HashMap<String, i32>, so there is no need to explicitly declare the type on the fourth line.

8.5.3. Combining Two Vectors into One HashMap

On a Vector whose element type is a tuple, you can use the collect method to build a HashMap. Put another way, if you have two Vectors and all of the values in them have a one-to-one correspondence, you can use collect to put the data from one Vector into the keys and the data from the other into the values of a HashMap. Example:

use std::collections::HashMap;  

fn main() {  
    let player = vec![String::from("dev1ce"), String::from("Zywoo")];  
    let initial_scores = vec![0, 100];  
    let scores: HashMap<_, _> = player.iter().zip(initial_scores.iter()).collect();  
}

The player Vector stores player names, and its elements are of type String.
The initial_scores Vector stores the score corresponding to each player.
player.iter() and initial_scores.iter() are iterators over the two Vectors. Using .zip() creates a sequence of tuples, and player.iter().zip(initial_scores.iter()) creates tuples with elements from player first and elements from initial_scores second. If you want to swap the order of the elements, you can simply swap the two iterators in the code. Then .collect() is used to convert the tuples into a HashMap.
One last thing to note is that .collect() supports conversion into many data structures. If you do not explicitly declare its type when writing the code, the program will fail. Here the type is specified as HashMap<_, _>. The two data types inside <> can be inferred by the compiler from the code, that is, from the two Vector types, so you can use _ as a placeholder and let it infer the types automatically.

8.5.4. HashMap and Ownership

For data types that implement the Copy trait, such as i32 and most simple data types, the value is copied into the HashMap, and the original variable remains usable. For types that do not implement Copy, such as String, ownership is transferred to the HashMap.

If you insert references into a HashMap, the value itself is not moved. During the lifetime of the HashMap, the referenced values must remain valid.

8.5.5. Accessing Values in a HashMap

You can access values with the get method. The get method takes a HashMap key as its argument, and it returns an Option<&V> enum. Example:

use std::collections::HashMap;  

fn main() {  
    let mut scores = HashMap::new();  
    scores.insert(String::from("dev1ce"), 0);  
    scores.insert(String::from("Zywoo"), 100);

    let player_name = String::from("dev1ce");  
    let score = scores.get(&player_name);  
    match score {  
        Some(score) => println!("{}", score),  
        None => println!("Player not found"),  
    };  
}

First, an empty HashMap called scores is created, and then two key-value pairs, ("dev1ce", 0) and ("Zywoo", 100), are inserted using insert. The key type is String, and the value type is i32.
Then a String variable named player_name is declared with the value "dev1ce".
Next, the get method on the HashMap is used to look up the value corresponding to the player_name key in scores (& means reference). But because get returns an Option enum, the Option value is first assigned to score and then unwrapped later.
Finally, a match expression is used to handle score. If the corresponding value is found, the score enum is the Some variant, and the value associated with Some is bound to score and then printed. If nothing is found, the score enum is the None variant, and "Player not found" is printed.

Output:

8.5.6. Iterating Over a HashMap

You usually iterate over a HashMap with a for loop. Example:

use std::collections::HashMap;  

fn main() {  
    let mut scores = HashMap::new();  
    scores.insert(String::from("dev1ce"), 0);  
    scores.insert(String::from("Zywoo"), 100);  
    for (k, v) in &scores {  
        println!("{}: {}", k, v);  
    }  
}

This for loop uses a reference to the HashMap, namely &scores, because after iterating you usually still want to keep using the HashMap. Using a reference means you do not lose ownership. The (k, v) on the left is pattern matching: the first value is the key, which is assigned to k, and the second is the value, which is assigned to v.

Output:

Zywoo: 100
dev1ce: 0

[Rust Guide] 8.4. String Type Pt.2 - Bytes, Scalar Values, Grapheme Clusters, and String Operations

SomeB1oody — Sat, 11 Apr 2026 22:20:17 +0000

8.4.0. Chapter Overview

The collections in Chapter 8 are stored on the heap rather than on the stack. That also means their size does not need to be known at compile time; at runtime, they can grow or shrink dynamically.

This chapter focuses on three collections: Vector, String (this article), and HashMap.

If you find this helpful, please like, bookmark, and follow. To keep learning along, follow this series.

8.4.1. You Cannot Use Indexing to Access `String`

String in Rust is different from that in other languages: you cannot access it by indexing. Example:

fn main() {  
    let s = String::from("6657 up up");  
    let a = s[0];  
}

Output:

error[E0277]: the type `str` cannot be indexed by `{integer}`
 --> src/main.rs:3:15
  |
3 |     let a = s[0];
  |               ^ string indices are ranges of `usize`
  |
  = help: the trait `SliceIndex<str>` is not implemented for `{integer}`, which is required by `String: Index<_>`
  = note: you can use `.chars().nth()` or `.bytes().nth()`
          for more information, see chapter 8 in The Book: <https://doc.rust-lang.org/book/ch08-02-strings.html#indexing-into-strings>
  = help: the trait `SliceIndex<[_]>` is implemented for `usize`
  = help: for that trait implementation, expected `[_]`, found `str`
  = note: required for `String` to implement `Index<{integer}>`

The error says that the String type cannot be indexed with an integer. Looking further down at the = help line, we can see that this type does not implement the Index<{integer}> trait.

8.4.2. Internal Representation of `String`

String is a wrapper around Vec<u8>, where u8 means a byte. We can use the len() method on String to return the string length. Example:

fn main() {  
    let len = String::from("Niko").len();  
    println!("{}", len);  
}

Output:

This string uses UTF-8 encoding, and len is 4, which means the string occupies 4 bytes. So in this example, each letter takes up one byte.

But that is not always the case. For example, if we change the string to another language (here, Russian written in Cyrillic):

fn main() {  
    let hello = String::from("Здравствуйте");  
    println!("{}", hello.len());  
}

If you count the letters in this string, there are 12, but the output is:

That means each letter in this language takes up two bytes (Chinese characters take three bytes each). The term used to refer to a “letter” here is a Unicode scalar value, and each Cyrillic letter here corresponds to two bytes.

From this example, you can see that numeric indexing into String does not always correspond to a complete Unicode scalar value, because some scalar values occupy more than one byte, while numeric indexing can only read one byte at a time.

Another example: the Cyrillic letter З corresponds to two bytes, whose values are 208 and 151. If numeric indexing were allowed, then taking index 0 of Здравствуйте would give you 208, which by itself is meaningless because it is missing the second byte needed to form a Unicode scalar value. So to avoid this kind of bug that would be hard to notice immediately, Rust bans numeric indexing on String, preventing misunderstandings early in development.

8.4.3. Bytes, Scalar Values, and Grapheme Clusters

There are three ways to view strings in Rust: bytes, scalar values, and grapheme clusters. Among them, grapheme clusters are the closest to what we usually call “letters.”

1. Bytes

Example:

fn main() {  
    let s = String::from("नमस्ते");  // Hindi written in Devanagari script
    for b in s.bytes() {  
        print!("{} ", b);  
    }  
}

This Devanagari string may look like it contains four letters. We use the .bytes() method to get the bytes it corresponds to. The output is:

224 164 168 224 164 174 224 164 184 224 165 141 224 164 164 224 165 135

These 18 bytes show how the computer stores the string.

2. Scalar Values

Now let’s view it as Unicode scalar values:

fn main() {  
    let s = String::from("नमस्ते");  
    for b in s.chars() {  
        print!("{} ", b);  
    }  
}

Using the .chars() method gives the scalar values corresponding to this string. The output is:

न म स ् त े

It has 6 scalar values, and some of them are combining marks rather than standalone letters. They only make sense when combined with the preceding characters.

This also explains why this Devanagari string takes 18 bytes: each of the 6 scalar values takes 3 bytes, and 6 × 3 gives 18 bytes.

3. Grapheme Clusters

Because obtaining grapheme clusters from a String is complicated, the Rust standard library does not provide this functionality. We will not demonstrate it here, but you can use a third-party crate from crates.io to implement it.

In short, if this string were printed as grapheme clusters, it would look like this:

8.4.4. Why `String` Cannot Be Indexed

Numeric indexing may return an incomplete value that cannot form a full Unicode scalar value, leading to bugs that are not immediately visible.
Indexing is supposed to take constant time, or O(1), but String cannot guarantee that, because it must traverse the entire contents from beginning to end to determine how many valid characters it contains.

8.4.5. Slicing `String`

You can use [] with a range inside it to create a string slice. For detailed coverage of string slices, see Chapter 4.5, Slices. Example:

fn main() {  
    let hello = String::from("Здравствуйте");  
    let s = &hello[0..4];  
    println!("{}", s);  
}

As mentioned earlier, one Cyrillic letter takes two bytes. This string slice takes the first 4 bytes of the string, which means the first two letters. The output is:

Зд

What if the string slice takes the first three bytes instead? That would mean the slice contains the first letter plus half of the second letter. What happens in that case? Look at the following example:

fn main() {  
    let hello = String::from("Здравствуйте");  
    let s = &hello[0..3];  
    println!("{}", s);  
}

Output:

byte index 3 is not a char boundary; it is inside 'д' (bytes 2..4) of `Здравствуйте`

The program triggers panic!, and the error message says that index 3 is not a char boundary. In other words, slicing must follow char boundaries. For Cyrillic, that means slicing in units of two bytes.

8.4.6. Iterating Over `String`

For scalar values, use the .chars() method. Example:

fn main() {  
    let s = String::from("नमस्ते");  
    for b in s.chars() {  
        print!("{} ", b);  
    }  
}

For bytes, use the .bytes() method. Example:

fn main() {  
    let s = String::from("नमस्ते");
    for b in s.bytes() {  
        print!("{} ", b);  
    }  
}

For grapheme clusters, the standard library does not provide a method, but you can use a third-party crate.

[Rust Guide] 8.3. String Type Pt.1 - String Creation, Updating, and Concatenation

SomeB1oody — Sat, 11 Apr 2026 22:11:56 +0000

8.3.0. Chapter Overview

The collections in Chapter 8 are stored on the heap rather than on the stack. That also means their size does not need to be known at compile time; at runtime, they can grow or shrink dynamically.

This chapter focuses on three collections: Vector, String (this article), and HashMap.

If you find this helpful, please like, bookmark, and follow. To keep learning along, follow this series.

8.3.1. Why Strings Are So Frustrating for Rust Developers

Rust developers, especially beginners, are often confused by strings for the following reasons:

Rust tends to expose possible errors.
String data structures are complex.
Rust strings use UTF-8 encoding.

8.3.2. What Is a String?

A string is a collection based on bytes, and it provides methods that can parse bytes into text.

At the core language level in Rust, there is only one string type: the string slice str, which usually appears in borrowed form, that is, &str.

A string slice is a reference to a UTF-8 encoded string stored somewhere else. For example, string literals are stored directly in Rust’s binary, so they are also a kind of string slice.

The String type comes from the standard library, not from the core language. It is growable, mutable, owned, and also uses UTF-8 encoding.

8.3.3. What Does “String” Actually Refer To?

When people say “string,” they usually mean both String and &str, not just one of them. Both types are heavily used in the standard library, and both use UTF-8 encoding. But here we mainly focus on String, because it is more complex.

8.3.4. Other String Types

The Rust standard library also provides other string types, such as OsString, OsStr, CString, and CStr. Note that these types all end with either String or Str, which is related to the naming pattern of String and string slices mentioned earlier.

In general, types ending with String are owned, while types ending with Str are usually borrowed.

These different string types can store text with different encodings or represent data in different memory layouts.

Some library crates provide more options for strings, but we will not cover them here.

8.3.5. Creating a New String

Because the essence of String is a collection of bytes, many operations from Vec<T> can also be used on String.

String::new() can be used to create an empty string. Example:

fn main(){
    let mut s = String::new();
}

In general, however, String is created from initial values. In that case, you can use the to_string method to create a String. This method can be used on types that implement the Display trait, including string literals. Example:

fn main() {  
    let data = "wjq";  
    let s = data.to_string();  
    let s1 = "wjq".to_string();  
}

data is a string literal. Using to_string converts it to a String and stores it in s. You can also write the string literal directly and then call .to_string(), which is the assignment performed for s1. These two operations have the same effect.

to_string is not the only method. Another way is to use the String::from function:

let s = String::from("wjq");

This function has the same effect as the to_string method.

Because strings are used so often, Rust provides many different general-purpose APIs for us to choose from. Some functions may seem redundant at first glance, but in practice they each have their own use. In real code, you can choose whichever style you prefer.

8.3.6. Updating `String`

As mentioned earlier, the size of String can grow or shrink. Because its essence is a collection of bytes, its contents can also be modified. Its operations are similar to those of Vector, and String can also be concatenated.

1. `push_str()`

First, let’s look at push_str(). It appends a string slice to a String. Example:

fn main() {  
    let mut s = String::from("6657");  
    s.push_str("up up");  
    println!("{}", s);  
}

Output:

6657up up

The signature of push_str is push_str(&mut self, string: &str). Its parameter is a borrowed string slice, and a string literal is a slice, so "up up" can be passed in. This method does not take ownership of the argument, so the passed-in value remains valid and can continue to be used.

2. `push`

The second method is push(), which appends a single character to a String. Example:

fn main() {  
    let mut s = String::from("665");  
    s.push('7');  
    println!("{}", s);  
}

Note: characters must use single quotes.

Output:

3. `+`

Rust allows you to concatenate strings using +. Example:

fn main() {  
    let s1 = String::from("6657");  
    let s2 = String::from("up up");  
    let s3 = s1 + &s2;  
    println!("{}", s3);  
}

Note: the value before the plus sign must be a String, and the value after the plus sign must be a string slice.

In this example, however, the type of the value after the plus sign is actually &String, not &str. That is because Rust uses deref coercion here to force &String into &str.

Of course, because s2 is passed in by reference, s2 is still valid after concatenation. But s1 has had its ownership moved into s3, so s1 becomes invalid after concatenation.

Output:

6657up up

4. `format!`

The format! macro can concatenate strings more flexibly. Example:

fn main() {  
    let s1 = String::from("cn");  
    let s2 = String::from("Niko");  
    let s3 = String::from("fan club");  
    let s = format!("{} {} {}", s1, s2, s3);  
    println!("{}", s);  
}

It uses placeholders instead of variables, which is very similar to println!. The difference is that println! prints the result, while format! returns the concatenated string.

Output:

cn Niko fan club

Of course, the same effect can also be achieved with +, but the code is a little more cumbersome:

fn main() {  
    let s1 = String::from("cn");  
    let s2 = String::from("Niko");  
    let s3 = String::from("fan club");  
    let s = s1 + " " + &s2 + " " + &s3;  
    println!("{}", s);  
}

The best thing about format! is that it does not take ownership of any arguments, so all of those arguments can continue to be used afterward.

[Rust Guide] 8.2. Vector and Enum Applications

SomeB1oody — Sat, 11 Apr 2026 22:06:52 +0000

8.2.0. Chapter Overview

The collections in Chapter 8 are stored on the heap rather than on the stack. That also means their size does not need to be known at compile time; at runtime, they can grow or shrink dynamically.

This chapter focuses on three collections: Vector, String, and HashMap.

If you find this helpful, please like, bookmark, and follow. To keep learning along, follow this series.

8.2.1. How Vector and Enum Complement Each Other

Although Vector can grow or shrink dynamically, all of its elements must still be the same data type. But sometimes we need to store different types of data on the heap. What should we do in that case?

Remember the enum type introduced in [6.1. Enums]? Enum variants can carry attached data, and that attached data can be of different types. Most importantly, the variants all belong to the same enum type. In other words, all variants are the same type, so they can be stored in a Vector.

This allows us to use an enum to make it possible to store different data types inside a Vector.

8.2.2. `Vector` + `enum`

Let’s look at a practical example of using Vector plus an enum:

enum SpreadSheetCell {  
    Int(i32),  
    Float(f64),  
    Text(String),  
}  

fn main() {  
    let row = vec![  
        SpreadSheetCell::Int(5567),  
        SpreadSheetCell::Text("up up".to_string()),  
        SpreadSheetCell::Float(114.514),  
    ];  
}

This example simulates the behavior of Excel cells. A cell can store only one of the following: an integer, a floating-point number, or a string. So we define the SpreadSheetCell enum, which has three variants used to store integers (Int), floating-point numbers (Float), and strings (Text).

In the main function, we declare the variable row to store one row of cells. Because the number of cells in a row is not fixed, we need a Vector to store them. In this example, the Vector is initialized with three cells: the first stores the integer 5567, the second stores the string "up up", and the third stores the floating-point number 114.514.

Through this example, we can see that by using an enum that can carry data, we can indirectly store different data types in a Vector.

So why does Rust need to know the element type of a Vector at compile time? Because only then can Rust determine how much heap memory is needed to hold the Vector. In addition, if different element types were allowed in a Vector, some bulk operations on the elements might be valid for some types but invalid for others, which would cause the program to fail. Using an enum together with a match expression allows Rust to know all possible cases in advance at compile time, so it can handle them correctly at runtime.

In this example, Vector does make it possible to store different data types, but only if we know exactly what the possible data types are, in other words, if the set is exhaustive. If the type has infinitely many possibilities, or is non-exhaustive, then even an enum cannot help, because the enum cannot even be defined. For such cases, Rust provides traits, but that will be covered later.

[Rust Guide] 8.1. Vector

SomeB1oody — Sat, 11 Apr 2026 22:05:38 +0000

8.1.0. Chapter Overview

The collections in Chapter 8 are stored on the heap rather than on the stack. That also means their size does not need to be known at compile time; at runtime, they can grow or shrink dynamically.

This chapter focuses on three collections: Vector (this article), String, and HashMap.

If you find this helpful, please like, bookmark, and follow. To keep learning along, follow this series.

8.1.1. Using Vector to Store Multiple Values

Vector is written as Vec<T>, where T represents a generic type parameter that can be replaced with the desired data type during actual use.

Vector is provided by the standard library. It stores multiple values of the same type contiguously in memory. You can think of it as a resizable array.

To create a Vector, use the Vec::new function. See the example:

fn main() {  
    let v: Vec<i32> = Vec::new();
    let v = vec![1, 2, 3];
    let v = Vec::with_capacity(10);
}

let v: Vec<i32> = Vec::new(): Declares a Vector with i32 elements using Vec::new (commonly used).
let v = vec![1, 2, 3]: Creates a Vector with initial values using the vec! macro. Here, 1, 2, 3 are inserted into the vector. Using vec![] with no content is also valid (commonly used).
let v = Vec::with_capacity(10): Creates an empty vector with pre-allocated capacity for at least 10 elements. Suitable when you know the approximate number of elements, reducing reallocations and improving performance.

The first method (Vec::new()) requires explicit type annotation (Vec<i32>) because it creates an empty vector with no elements. Without contextual information for Rust to infer the type, it would cause an error. With context, Rust can infer the element type.

The second method (vec![]) doesn’t require explicit type annotation because the Rust compiler infers the element type (i32) from the initial values.

8.1.2. Updating a Vector

1. Adding Elements

Use the push method to add elements to the end of a vector:

fn main() {  
    let mut v = Vec::new();  
    v.push(1);  
}

Note: The vector must be mutable (declared with mut) to add elements.
In let mut v = Vec::new();, the element type is inferred as i32 from the subsequent push(1) operation.

Other methods for adding elements:

fn main() {  
    let mut v = Vec::new();  
    v.extend([1, 2, 3]);  // Batch insertion
    v.insert(1, 99);      // Insert at index (panics if out-of-bounds)

    let mut a = vec![1, 2, 3];
    let mut b = vec![4, 5, 6];
    a.append(&mut b);      // Moves all elements from `b` to `a` (empties `b`)
}

2. Removing Elements from a Vector

pop(): Removes and returns the last element wrapped in Option (covered in 6.2. The Option Enum). Returns None if empty.

fn main() {  
    let mut v = vec![1, 2, 3];
    let x = v.pop(); // Returns Some(3)
}

remove(index): Deletes the element at the specified index and returns it. Shifts subsequent elements left. Panics if index is invalid.

fn main() {  
    let mut v = vec![1, 2, 3];
    let x = v.remove(1); // Returns 2 (v becomes [1, 3])
}

clear(): Removes all elements. Length becomes 0, but capacity remains.

fn main() {  
    let mut v = vec![1, 2, 3];
    v.clear(); // v is now []
}

Like any struct, when a Vector goes out of scope, it and its elements are automatically cleaned up.

3. Reading Elements of a Vector

There are two ways to access values in a Vector: using indexing or the get method. For example, given a vector containing [1, 2, 3, 4, 5], access and print the third element:

fn main() {  
    let v = vec![1, 2, 3, 4, 5];  
    let third = &v[2];  // Indexing
    println!("The third element is {}", third);  

    match v.get(2) {    // get method with match
        Some(third) => println!("The third element is {}", third),  
        None => println!("There is no third element."),  
    };  
}

let third = &v[2];: Uses indexing to access the element at position 2 (third element). The & indicates a reference.
v.get(2): Uses the get method for access. Since it returns an Option type, we use match (covered in 6.3. The Match Control Flow Operator) to unpack it. If a value exists, it binds to third and prints; if not (None), it prints "There is no third element."

Both methods achieve the same result but handle invalid access (e.g., out-of-bounds index) differently.

Testing with indexing (invalid access):

fn main() {
    let v = vec![1, 2, 3, 4, 5];
    let third = &v[100]; // Index 100 is out-of-bounds
    println!("The third element is {}", third);
}

Output:

index out of bounds: the len is 5 but the index is 100

The program triggers panic! and terminates.

Testing with get (invalid access):

fn main() {
    let v = vec![1, 2, 3, 4, 5];
    match v.get(100) {  // Index 100 is out-of-bounds
        Some(third) => println!("The third element is {}", third),  
        None => println!("There is no third element."),  
    };  
}

Output:

There is no third element.

Since get cannot access index 100, it returns None.

Guideline: Use indexing when out-of-bounds access should terminate the program via panic!. Otherwise, prefer get for safe handling.

8.1.3. Ownership and Borrowing Rules

Remember the borrowing rule discussed in Chapter 4.2. Ownership Rules, Memory, and Allocation? You cannot have mutable and immutable references in the same scope at the same time. This rule still applies to Vector. Example:

fn main() {
    let mut v = vec![1, 2, 3, 4, 5];
    let first = &v[0];
    v.push(6);
    println!("The first element is {}", first);
}

Output:

error[E0502]: cannot borrow `v` as mutable because it is also borrowed as immutable
 --> src/main.rs:4:5
  |
3 |     let first = &v[0];
  |                  - immutable borrow occurs here
4 |     v.push(6);
  |     ^^^^^^^^^ mutable borrow occurs here
5 |     println!("The first element is {}", first);
  |                                         ----- immutable borrow later used here

The push function has the signature &mut self, value: T. &mut means that push treats the passed-in variable as a mutable reference. In the example, v is used as a mutable reference here.
let first = &v[0]; makes first an immutable reference to v. Because the two references exist in the same scope, an error is produced.
println! treats the values passed to it as immutable references.

Because mutable and immutable references appear at the same time in this scope, the program fails to compile.

Someone might wonder: push adds things to the end of a Vector, and the earlier elements are not affected. Why does Rust make this so complicated?

That is because the elements of a Vector are stored contiguously in memory. If you add an element to the end and there happens to be something occupying the space after it, there may be no room for the new element. In that case, the system must reallocate memory and find a large enough area to hold the Vector after the new element is added. When that happens, the original memory block may be freed or reallocated, but the reference still points to the old memory address, creating a dangling reference (discussed in Chapter 4.4, Reference and Borrowing).

8.1.4. Iterating Over Values in a Vector

Using a for loop is the most common approach. Example:

fn main() {  
    let v = vec![1, 2, 3, 4, 5];  
    for i in &v {  
        println!("{}", i);  
    }  
}

Output:

Of course, if you want to modify elements inside the loop, that is also possible. You only need to make v mutable and change &v to &mut v:

fn main() {  
    let mut v = vec![1, 2, 3, 4, 5];  
    for i in &mut v {  
        *i += 10;  
    }  
    for i in v {  
        println!("{}", i);  
    }  
}

Note: the * in front of *i on the fourth line is there because i is essentially of type &mut i32. It stores a pointer rather than the actual i32 value, so you need to dereference it first and turn i into an mut i32 value to get the actual number before you can perform addition or subtraction.

Output:

[Rust Guide] 7.6. Splitting Modules Into Separate Files

SomeB1oody — Fri, 10 Apr 2026 21:41:49 +0000

If you find this helpful, please like, bookmark, and follow. To keep learning along, follow this series.

7.6.1 Moving Module Contents to Another File

If the module name is followed by ; instead of a code block when defining a module, Rust will look for a .rs file with the same name as the module under the src directory and load its contents. Whether the module’s contents are in the same file or in different files, the structure of the module tree does not change.

Take a look at an example:

mod front_of_house {  
    pub mod hosting {  
        pub fn add_to_waitlist() { }  
    }  
}  

pub use crate::front_of_house::hosting::add_to_waitlist;  

pub fn eat_at_restaurant() {  
    add_to_waitlist();  
}

This way, all modules are placed in the same file. If you want to move them into different files, do this:

Step 1: Create a New File

If you want to split out front_of_house, you need to create a .rs file with the same name under the src directory:

Step 2: Cut the Code

Cut the code that was originally under front_of_house from its original location into the front_of_house.rs file, that is, cut out this part:

pub mod hosting {  
        pub fn add_to_waitlist() { }  
    }

Step 3: Modify the Original Location

Open the original place where front_of_house was defined. At this point, you no longer need the code block after it, so delete it together with the {} and add a ; instead (do not touch other unrelated code). The original code is:

mod front_of_house {  
    pub mod hosting {  
        pub fn add_to_waitlist() { }  
    }  
}  

pub use crate::front_of_house::hosting::add_to_waitlist;  

pub fn eat_at_restaurant() {  
    add_to_waitlist();  
}

Change it to:

mod front_of_house;

pub use crate::front_of_house::hosting::add_to_waitlist;  

pub fn eat_at_restaurant() {  
    add_to_waitlist();  
}

7.6.2 Splitting Submodules

What if you have many modules under front_of_house? Then you will need to put these submodules into different files to better organize code. But how? Put all submodules in the folder src like what we just did? Then src contains too many files and the hierarchical relationship between the modules cannot be displayed.

Rust gives a pretty good solution for it: put all submodule files in a folder named by their father module. Specifically, you need to create a folder with the same name as the parent module first, and then use a .rs file inside that folder to store the submodule or items.

For example, if I want to split out hosting as a separate file, I do not just create a .rs file with the same name in src. I first need to create a folder with the same name as the parent module. In this example, the parent module is named front_of_house, so I need to create a folder named front_of_house.

Then create a .rs file in that folder with the same name as the item or module. In this example, since I want to split out hosting, the file should be named hosting.rs.

Store the contents of hosting in hosting.rs, which is:

pub fn add_to_waitlist() { }

Now you can delete the code block of hosting module in front_of_house.rs together with the {} and add a ;, same process as what we did to lib.rs. Change it from (front_of_house.rs):

pub mod hosting {  
    pub fn add_to_waitlist() { }  
}

to simply:

pub mod hosting;

Rust also support split modules in the form ofmodule_name/mod.rs. All modules are stored in mod.rs. Folder names imply module names. This method is still fully supported in Rust, but in modern Rust code, it is usually more like a continuation of the old-style module layout rather than the default preference.

If we use this method to split modules, it will look like:

7.6.3 Benefits of Splitting

As modules grow larger, this technique lets programmers move a module’s contents into other files.

[Rust Guide] 7.5. Keyword Use Pt. 2 - Re-exports

SomeB1oody — Fri, 10 Apr 2026 21:00:58 +0000

If you find this helpful, please like, bookmark, and follow. To keep learning along, follow this series.

7.5.1 Re-importing Names with `pub use`

After using use to bring a path into scope, that name is private within the lexical scope.

Using the code from the previous article as an example:

mod front_of_house {  
    pub mod hosting {  
        pub fn add_to_waitlist() { }  
        fn seat_at_table() { }  
    }  
}  

use crate::front_of_house::hosting::add_to_waitlist;  

pub fn eat_at_restaurant() {  
    add_to_waitlist();  
}

For external code, eat_at_restaurant is accessible because it was declared with the pub keyword, but external code cannot see the add_to_waitlist used inside eat_at_restaurant, because items imported with use are private by default. If you want external code to access it as well, you need to add pub in front of use:

mod front_of_house {  
    pub mod hosting {  
        pub fn add_to_waitlist() { }  
        fn seat_at_table() { }  
    }  
}  

pub use crate::front_of_house::hosting::add_to_waitlist;  

pub fn eat_at_restaurant() {  
    add_to_waitlist();  
}

This allows external code to access the item brought in with use.

When we want to expose code publicly, we can use this technique to adjust the outward-facing API instead of following the internal code structure exactly. In this way, the internal structure and the outward view of the code may differ a bit. After all, the person writing the code and the person calling the code usually expect different things.

To summarize: pub use both re-exports the item into the current scope and makes that item available for external code to import into their scope.

7.5.2 Using External Packages

First, add the package name and version of the dependency to Cargo.toml, and Cargo will download that package and its dependencies from crates.io to your local machine (you can also use an unofficial crate and fetch it from GitHub, but that is strongly discouraged). Then use use in the code to bring the specific item into scope.

Do you remember the guessing game from Chapter 2? Back then we needed the rand package to generate random numbers. We will still use rand as an example:

Step 1: Modify `Cargo.toml`

Open your project’s Cargo.toml file, and under [dependencies], write the package name and version, connected with =:

[package]  
name = "RustStudy"  
version = "0.1.0"  
edition = "2021"  

[dependencies]  
rand = "0.8.5"

Step 2: Import the Package in Source Code

To use something from a package, just use use to import the corresponding path. Here I need the function that generates random numbers, so I import the parent module of that function, Rng, like this:

use rand::Rng;

The Rust standard library, std, is also treated as an external package, but it is built into Rust itself, so you do not need to add it to Cargo.toml. You can just import it in the source code with use, which is somewhat like libraries such as re, os, and ctype in Python.

For example, if we want to import the HashMap struct from the collections module under std, we write:

use std::collections::HashMap;

No changes to Cargo.toml are needed.

7.5.3 Cleaning Up Many `use` Statements with Nested Paths

Sometimes you use multiple items from the same package or module, and the beginning of the path is the same, but you still have to write it repeatedly. If there are many imports, writing them one by one is not practical. Rust therefore allows nested paths to simplify imports on a single line. This is similar to the brace expansion feature in bash.

The format is:

use common_part::{different_part1, different_part2, ...}

Look at an example:

use std::cmp::Ordering;
use std::io;

They share the common part std, so they can be rewritten with a nested path:

use std::{cmp::Ordering, io};

If one import is a subpath of another import, Rust also allows the self keyword when using nested paths, as shown below:

use std::io;
use std::io::Write;

This can be shortened to:

use std::io::{self, Write};

7.5.4 The Wildcard `*`

Using * brings all public items in a path into scope. For example, if I want to import all public items from the collections module under the std library, I can write:

use std::collections::*;

But this kind of import must be used very carefully, and is usually avoided.

Its use cases are:

Importing all tested code into the test module during testing
Sometimes used in prelude modules

[Rust Gudie] 7.4. Keyword Use Pt. 1 - Using Use and the As Keyword

SomeB1oody — Fri, 10 Apr 2026 20:57:14 +0000

If you find this helpful, please like, bookmark, and follow. To keep learning along, follow this series.

7.4.1 The Role of `use`

The role of use is to bring a path into the current scope. The imported item still follows privacy rules, which means only public parts can be brought in and used.

7.4.2 Using `use`

Look at an example:

mod front_of_house {  
    pub mod hosting {  
        pub fn add_to_waitlist() { }  
        fn seat_at_table() { }  
    }  
}  

use crate::front_of_house::hosting;  

pub fn eat_at_restaurant() {  
    hosting::add_to_waitlist();  
}

Here, we first declare a front_of_house module, and inside it we declare a public submodule hosting. Under hosting there are two functions: the public add_to_waitlist and the private seat_at_table.

Then we use the use keyword to bring the hosting submodule under front_of_house from crate (that is, the whole file) into the current scope. This is similar to creating a file link in a file system, and also somewhat like using namespace in C++.

After importing it this way, the name hosting can be used directly in the current scope, as if the hosting module had been defined at the crate root.

In the eat_at_restaurant function below, because hosting has already been brought into the current scope, when calling add_to_waitlist, you do not need to write an absolute path starting from crate, nor a relative path starting from front_of_house; you can start directly from hosting.

But note that the imported module still follows privacy rules, so the seat_at_table function still cannot be called.

use can use either an absolute path or a relative path. For example, the line above:

use crate::front_of_house::hosting;

can be changed to:

use front_of_house::hosting;

In general, however, absolute paths are used more often.

7.4.3 `use` Conventions

In the example above, we imported only up to the use level, but the function we call is only add_to_waitlist. Can we import add_to_waitlist directly? Actually, yes:

mod front_of_house {  
    pub mod hosting {  
        pub fn add_to_waitlist() { }  
        fn seat_at_table() { }  
    }  
}  

use crate::front_of_house::hosting::add_to_waitlist;  

pub fn eat_at_restaurant() {  
    add_to_waitlist();  
}

This is also fine, but it is not recommended.

If there is a lot of code, you may no longer know whether add_to_waitlist is defined locally or in another module. Therefore, for functions, the usual practice is to import their parent module and call the function through that parent module, to indicate that the function is not defined locally. But you only need to import up to the parent of the function; no need to import too much, otherwise there will be too much repeated typing.

For other items, such as structs and enums, it is generally better to import the full path, all the way to the item itself, rather than importing only the parent module. For example:

use std::collections::HashMap;  

fn main() {  
    let mut map = HashMap::new();  
    map.insert(1, 2);  
}

When using the HashMap struct from the standard library’s collections module, you import the item itself directly. When using it, you refer to it simply as HashMap, without the parent module.

If there are items with the same name, whether they are functions or not, import them through their parent modules to distinguish them. For example:

use std::fmt;  
use std::io;  

fn f1() -> fmt::Result { }  

fn f2() -> io::Result { }

fn main() { }

In this example (ignoring compilation issues; this is only a demonstration), I need both Result from fmt and Result from io, so I need to import the parent modules fmt and io.

If you do not want to write it this way, you can also use the as keyword.

7.4.4 The `as` Keyword

The as keyword can assign a local alias to an imported path. For example, let’s modify the example above:

use std::fmt::Result;  
use std::io::Result as IoResult;  

fn f1() -> Result { }  

fn f2() -> IoResult { }  
fn main() { }

This way, you do not need to import only the parent module; you can import the item directly.

[Rust Guide] 7.3. Path Pt. 2 - Accessing Parent Modules and Pub on Structs and Enums

SomeB1oody — Fri, 10 Apr 2026 20:52:16 +0000

If you find this helpful, please like, bookmark, and follow. To keep learning along, follow this series.

7.3.1 `super`

We can access items in a parent module’s path by using super at the start of a path, just like using .. syntax to start a file-system path. For example:

fn deliver_order() {}

mod back_of_house {
    fn fix_incorrect_order() {
        cook_order();
        super::deliver_order();
    }

    fn cook_order() {}
}

Of course, you can use an absolute path to achieve the same result:

fn deliver_order() {}

mod back_of_house {
    fn fix_incorrect_order() {
        cook_order();
        crate::deliver_order();
    }

    fn cook_order() {}
}

7.3.2 `pub struct`

If you put the pub keyword before struct, the struct becomes public, as shown below:

mod back_of_house {
    pub struct Breakfast {
        toast: String,
        seasonal_fruit: String,
    }
}

Note that although this struct is public, the fields inside a struct are private by default, unless you add the pub keyword.

In Rust, in most cases if something does not have pub, then it is private. (Special cases will be discussed later.)

Making a field public is also simple. Here is the code after changing toast in Breakfast to public:

mod back_of_house {
    pub struct Breakfast {
        pub toast: String,
        seasonal_fruit: String,
    }
}

Let’s look at a more complex example:

mod back_of_house {
    pub struct Breakfast {
        pub toast: String,
        seasonal_fruit: String,
    }

    impl Breakfast {
        pub fn summer(toast: &str) -> Breakfast {
            Breakfast {
                toast: String::from(toast),
                seasonal_fruit: String::from("peaches"),
            }
        }
    }
}

pub fn eat_at_restaurant(){
    let mut meal = back_of_house::Breakfast::summer("Rye");
    meal.toast = String::from("Wheat");
}

On top of the struct, we define an associated function summer, whose parameter is the string slice toast and whose return value is Breakfast. The value of Breakfast.toast will be the value of that argument, and the value of Breakfast.seasonal_fruit will be set to peaches. In essence, summer is a constructor that creates an instance of Breakfast.
In the eat_at_restaurant function, we first use a relative path to call summer and construct an instance, then assign it to the mutable variable meal. The toast field in meal is set to Rye, and seasonal_fruit is peaches as written in the constructor. On the next line, because the Breakfast struct is public, meal.toast can be modified directly, and here it is changed to Wheat.

Would writing meal.seasonal_fruit = String::from("buleberries"); inside the eat_at_restaurant function cause an error? The answer is yes, because fields inside a struct are private by default. seasonal_fruit was not declared public, so external code cannot modify it, and this line attempts to modify it, which causes an error.

7.3.3 `pub enum`

Just like struct, an enum also becomes public if you add the pub keyword. For example:

mod back_of_house {
    pub enum Appetizer {
        Soup,
        Salad,
    }
}

pub fn eat_at_restaurant() {
    let order1 = back_of_house::Appetizer::Soup;
    let order2 = back_of_house::Appetizer::Salad;
}

But unlike struct, where the fields are private by default, the variants of a public enum are public by default, so you do not need to put pub before each variant. This differs from Rust’s default-private rule because only public variants on a public enum are useful, while having some private fields in a struct does not affect its use.

But note that the prerequisite for variants of an enum to be public is that the enum itself is declared public.

[Rust Guide] 7.2. Path Pt. 1 - Relative Paths, Absolute Paths, and the Pub Keyword

SomeB1oody — Fri, 10 Apr 2026 20:46:58 +0000

If you find this helpful, please like, bookmark, and follow. To keep learning along, follow this series.

7.2.1 Introduction to Paths

In Rust, if you want to find something inside a module, you must know and use its path. Rust paths are similar to file-system paths and are somewhat like namespaces in other languages.

There are two kinds of paths:

Absolute paths: start from the crate root, using the crate name or the literal value crate (the example below will make this clear)
Relative paths: start from the current module, using self (itself), super (the parent), or the current module’s identifier

A path consists of at least one identifier, and identifiers are connected with ::.

7.2.2 Using Paths

Look at an example (lib.rs):

mod front_of_house {
    mod hosting {
        fn add_to_waitlist() {}

        fn seat_at_table() {}
    }
}

pub fn eat_at_restaurant(){
    crate::front_of_house::hosting::add_to_waitlist();
    front_of_house::hosting::add_to_waitlist();
}

hosting is a submodule of front_of_house, and two functions, add_to_waitlist and seat_at_table, are defined under hosting.

In the same scope as front_of_house, there is also a function called eat_at_restaurant. Inside that function, add_to_waitlist is called once with an absolute path and once with a relative path.

For the absolute path, the function eat_at_restaurant and the front_of_house module containing add_to_waitlist are in the same file, lib.rs, which means they are in the same crate (lib.rs implicitly forms the crate module, as explained in the previous article). So an absolute path starts with crate and proceeds level by level, separating each identifier with :::

crate::front_of_house::hosting::add_to_waitlist();

For the relative path, because the function eat_at_restaurant and the front_of_house module containing add_to_waitlist are at the same level, you can start directly from the module name and still proceed level by level with :::

front_of_house::hosting::add_to_waitlist();

In real projects, whether you use an absolute path or a relative path mainly depends on whether the code that defines the item (for example, add_to_waitlist) and the code that uses the item (for example, eat_at_restaurant) will move together. If they move together, meaning their relative path does not change, then use a relative path. Otherwise, use an absolute path. But most of the time, absolute paths are still used, because then the code that defines an item and the code that uses it can move independently of each other.

Let’s run the code next:

error[E0603]:module `hosting` is private

Both the absolute-path call and the relative-path call report this error. The meaning of the error is that the hosting module is private.

This is a good opportunity to talk about the concept of a privacy boundary.

7.2.3 Privacy Boundary

A module does more than organize code; it can also define privacy boundaries. If you want to make a function or struct private, you can place it inside a module, just like the functions in the previous example—they are inside the hosting module.

By default, Rust makes all items (functions, methods, structs, enums, modules, constants, and so on) private. For private items, external code cannot call them or depend on them. Rust does this because it wants internal details to stay hidden by default, so programmers can clearly know which internal implementations can be changed without breaking external code.

Rust’s privacy boundary also has a rule: parent modules cannot access private items in child modules, which is still meant to hide implementation details; child modules can use all items from ancestor modules, because child modules are defined in the context of their parent and other ancestor modules. To put it another way: a father cannot read his son’s diary, but the son can use his father’s money.

To make something public, add the pub keyword when defining the module.

7.2.4 The `pub` Keyword

Adding pub before mod makes a module public. Let’s slightly modify the previous code:

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}

        fn seat_at_table() {}
    }
}

pub fn eat_at_restaurant(){
    crate::front_of_house::hosting::add_to_waitlist();
    front_of_house::hosting::add_to_waitlist();
}

Note: both the hosting module and the add_to_waitlist() function need the pub keyword in front of them.

Compile again, and this time the compiler does not report an error. Someone may ask: why does front_of_house not need pub? It is private, but there is no error when calling it.

front_of_house does not need to be public because eat_at_restaurant is defined in its parent module, the crate root, and parent modules can refer to their child modules directly. However, hosting is inside front_of_house, so accessing it from the crate root counts as accessing it from outside front_of_house. Therefore, hosting must be pub. The same applies to add_to_waitlist().

[Rust Guide] 7.1. Package, Crate, and Module Definitions

SomeB1oody — Fri, 10 Apr 2026 20:09:32 +0000

If you find this helpful, please like, bookmark, and follow. To keep learning along, follow this series.

7.1.1 Rust Code Organization

Code organization mainly includes:

Which details can be exposed publicly, and which details are private
Which names are valid within a scope
...

These features are collectively called the module system, which includes the following concepts, from broadest to most specific:

Package: a Cargo feature that lets you build, test, and share crates. You can think of it as a project
Crate: a module tree that can produce either a library or an executable
Module: it lets you control code organization, scope, and private paths
Path: a way to name items such as structs, functions, or modules

7.1.2 Packages and Crates

There are two types of crates:

Binary: an executable program that can run independently. It must contain a main function as the entry point. It is usually used to implement a concrete application or command-line tool.
Library: a reusable code module that cannot be run directly. It does not have a main function; instead, it exposes public functions or modules for other code to call.

A crate root refers to the source file (that is, a .rs file), and it is also the entry file such as main.rs. The Rust compiler starts here when building the root module of the crate.

A package contains:

A Cargo.toml file that describes how to build these crates
Either one library crate or no library crate
Any number of binary crates
But at least one crate, whether library or binary

7.1.3 Cargo Conventions

If you open the Cargo.toml of a local Rust project, for example mine:

[package]  
name = "RustStudy"  
version = "0.1.0"  
edition = "2021"  

[dependencies]  
rand = "0.8.5"

you will notice that there is no mention of an entry file. That is because Cargo treats src/main.rs as the crate root of a binary crate by default, and the crate name is the same as the package name. In other words, the binary crate name and the package name are both RustStudy (as written on the second line of the TOML file). This reflects the idea that convention is better than configuration.

If this project, or package, has a lib.rs file under the src directory, that means the package contains a library crate, and that lib.rs is the crate root of the library crate. The crate name is also the same as the package name, which is RustStudy.

Cargo passes the crate root file to rustc to build the library or binary.

As mentioned earlier, a package can contain many binary crates. In that case, you can place source files (that is, .rs files) under the src/bin directory, and each file there is a separate binary crate (a separate program).

7.1.4 The Role of Crates

The role of a crate is to combine related functionality into a single scope, making it easier to share within a project. It also helps prevent naming conflicts. For example, to access the functionality of the rand crate, which generates random numbers, you need to use its name, rand.

7.1.5 Defining Modules to Control Scope and Privacy

A module is the feature that groups code inside a crate, dividing it into several modules. It improves readability and makes functionality easier to reuse. It can control the privacy of items—whether they are public or private.

To create a module, use the mod keyword, then write the module name after it, followed by curly braces.

Modules can also be nested, and the nested ones are called submodules. A module can contain definitions of other items such as structs, enums, constants, traits, and functions.

Let’s look at an example. Write this in lib.rs under the src directory:

mod front_of_house {
    mod hosting {
        fn add_to_waitlist() {}

        fn seat_at_table() {}
    }

    mod serving {
        fn take_order() {}

        fn serve_order() {}

        fn take_payment() {}
    }
}

In this example, hosting and serving are submodules of front_of_house, and front_of_house is the parent module. Several functions are defined under these two submodules.

main.rs and lib.rs are called crate roots. The contents of these two files implicitly form a module named crate, which sits at the root of the entire module tree (the top level in the diagram). The following is the module tree for the lib.rs example above:

crate
 └── front_of_house
     ├── hosting
     │   ├── add_to_waitlist
     │   └── seat_at_table
     └── serving
         ├── take_order
         ├── serve_order
         └── take_payment

DEV Community: SomeB1oody

[Rust] 8.6. HashMap Pt.2 - Updating HashMaps

8.6.0. Chapter Overview

8.6.1. Updating a HashMap

1. Replacing an Existing Value

2. Insert a Value Only if the Key Has No Existing Value

3. Updating Based on Existing Values

8.6.2. Hash Functions

[Rust Guide] 8.5. HashMap Pt.1 - Defining, Creating, Merging, and Accessing HashMaps

8.5.0. Chapter Overview

8.5.1. What Is a HashMap?

8.5.2. Creating a HashMap

8.5.3. Combining Two Vectors into One HashMap

8.5.4. HashMap and Ownership

8.5.5. Accessing Values in a HashMap

8.5.6. Iterating Over a HashMap

[Rust Guide] 8.4. String Type Pt.2 - Bytes, Scalar Values, Grapheme Clusters, and String Operations

8.4.0. Chapter Overview

8.4.1. You Cannot Use Indexing to Access String

8.4.2. Internal Representation of String

8.4.3. Bytes, Scalar Values, and Grapheme Clusters

1. Bytes

2. Scalar Values

3. Grapheme Clusters

8.4.4. Why String Cannot Be Indexed

8.4.5. Slicing String

8.4.6. Iterating Over String

[Rust Guide] 8.3. String Type Pt.1 - String Creation, Updating, and Concatenation

8.3.0. Chapter Overview

8.3.1. Why Strings Are So Frustrating for Rust Developers

8.3.2. What Is a String?

8.3.3. What Does “String” Actually Refer To?

8.3.4. Other String Types

8.3.5. Creating a New String

8.3.6. Updating String

1. push_str()

2. push

3. +

4. format!

[Rust Guide] 8.2. Vector and Enum Applications

8.2.0. Chapter Overview

8.2.1. How Vector and Enum Complement Each Other

8.2.2. Vector + enum

[Rust Guide] 8.1. Vector

8.1.0. Chapter Overview

8.1.1. Using Vector to Store Multiple Values

8.1.2. Updating a Vector

1. Adding Elements

2. Removing Elements from a Vector

3. Reading Elements of a Vector

8.1.3. Ownership and Borrowing Rules

8.1.4. Iterating Over Values in a Vector

[Rust Guide] 7.6. Splitting Modules Into Separate Files

7.6.1 Moving Module Contents to Another File

Step 1: Create a New File

Step 2: Cut the Code

Step 3: Modify the Original Location

7.6.2 Splitting Submodules

7.6.3 Benefits of Splitting

[Rust Guide] 7.5. Keyword Use Pt. 2 - Re-exports

7.5.1 Re-importing Names with pub use

7.5.2 Using External Packages

Step 1: Modify Cargo.toml

Step 2: Import the Package in Source Code

7.5.3 Cleaning Up Many use Statements with Nested Paths

7.5.4 The Wildcard *

[Rust Gudie] 7.4. Keyword Use Pt. 1 - Using Use and the As Keyword

7.4.1 The Role of use

7.4.2 Using use

7.4.3 use Conventions

7.4.4 The as Keyword

[Rust Guide] 7.3. Path Pt. 2 - Accessing Parent Modules and Pub on Structs and Enums

7.3.1 super

7.3.2 pub struct

7.3.3 pub enum

[Rust Guide] 7.2. Path Pt. 1 - Relative Paths, Absolute Paths, and the Pub Keyword

7.2.1 Introduction to Paths

7.2.2 Using Paths

7.2.3 Privacy Boundary

7.2.4 The pub Keyword

8.4.1. You Cannot Use Indexing to Access `String`

8.4.2. Internal Representation of `String`

8.4.4. Why `String` Cannot Be Indexed

8.4.5. Slicing `String`

8.4.6. Iterating Over `String`

8.3.6. Updating `String`

1. `push_str()`

2. `push`

3. `+`

4. `format!`

8.2.2. `Vector` + `enum`

7.5.1 Re-importing Names with `pub use`

Step 1: Modify `Cargo.toml`

7.5.3 Cleaning Up Many `use` Statements with Nested Paths

7.5.4 The Wildcard `*`

7.4.1 The Role of `use`

7.4.2 Using `use`

7.4.3 `use` Conventions

7.4.4 The `as` Keyword

7.3.1 `super`

7.3.2 `pub struct`

7.3.3 `pub enum`

7.2.4 The `pub` Keyword