Compound data types in Rust - Mini Project: Build & Apply

Working with Compound Data Types in Rust

📖 Scenario: You are building a simple program to store and display information about a book in a library system.

🎯 Goal: Create a compound data type using a struct to hold book details, then use it to store and print information about a specific book.

📋 What You'll Learn

Create a struct named Book with fields for title, author, and year

Create a variable of type Book with specific values

Access the fields of the Book variable

Print the book information in a readable format

💡 Why This Matters

🌍 Real World

Compound data types like structs help organize related information together, such as details about books, users, or products in real applications.

💼 Career

Understanding how to create and use structs is essential for Rust programming jobs, especially in systems programming, web backend, and data modeling.

1

Define the Book struct

Write a struct named Book with three fields: title and author of type String, and year of type u32.

Rust

// Define the Book struct with title, author, and year fields
// Your code here

Hint

Use struct Book { title: String, author: String, year: u32 } to define the compound data type.

2

Create a Book instance

Create a variable named my_book of type Book with title set to "The Rust Book", author set to "Steve", and year set to 2021.

Rust

struct Book {
    title: String,
    author: String,
    year: u32,
}

// Create my_book variable with the given values
// Your code here

Hint

Use let my_book = Book { title: String::from("The Rust Book"), author: String::from("Steve"), year: 2021 };

3

Access the fields of my_book

Create three variables named book_title, book_author, and book_year that get the values from my_book.title, my_book.author, and my_book.year respectively.

Rust

struct Book {
    title: String,
    author: String,
    year: u32,
}

let my_book = Book {
    title: String::from("The Rust Book"),
    author: String::from("Steve"),
    year: 2021,
};

// Get the fields from my_book into separate variables
// Your code here

Hint

Use let book_title = &my_book.title; and similar for author and year.

4

Print the book information

Use println! to display the book information in this exact format: "Title: The Rust Book, Author: Steve, Year: 2021" using the variables book_title, book_author, and book_year.

Rust

struct Book {
    title: String,
    author: String,
    year: u32,
}

let my_book = Book {
    title: String::from("The Rust Book"),
    author: String::from("Steve"),
    year: 2021,
};

let book_title = &my_book.title;
let book_author = &my_book.author;
let book_year = my_book.year;

// Print the book information in the required format
// Your code here

Hint

Use println!("Title: {}, Author: {}, Year: {}", book_title, book_author, book_year);

Practice

1. Which of the following best describes a tuple in Rust?

easy

A. A named collection of fields with the same type.

B. A dynamically sized list of elements all of the same type.

C. A fixed-size collection of values of possibly different types grouped together.

D. A function that returns multiple values.

Solution

1. Step 1: Understand tuple characteristics

   Tuples group multiple values of different types into one fixed-size compound value.

2. Step 2: Compare with other options

   A dynamically sized list of elements all of the same type describes arrays/vecs. A named collection of fields describes structs. A function that returns multiple values is unrelated to tuples.

3. Final Answer:

   A fixed-size collection of values of possibly different types grouped together. -> Option C

4. Quick Check:

   Tuple = fixed-size, mixed types [OK]

Hint: Tuples hold fixed mixed types by position [OK]

Common Mistakes:

• Confusing tuples with arrays (dynamic size, same type)
• Thinking tuples have named fields like structs
• Assuming tuples can change size after creation

2. Which of the following is the correct syntax to define a tuple with an integer and a string in Rust?

easy

A. let my_tuple = [42, "hello"];

B. let my_tuple = (42, "hello");

C. let my_tuple = {42, "hello"};

D. let my_tuple = <42, "hello">;

Solution

1. Step 1: Recall tuple syntax

   Tuples use parentheses () with comma-separated values, e.g., (value1, value2).

2. Step 2: Check each option

   let my_tuple = (42, "hello"); uses parentheses correctly. let my_tuple = [42, "hello"]; uses square brackets (arrays). let my_tuple = {42, "hello"}; uses braces (blocks or structs). let my_tuple = <42, "hello">; uses angle brackets which are invalid here.

3. Final Answer:

   let my_tuple = (42, "hello"); -> Option B

4. Quick Check:

   Tuple syntax uses () [OK]

Hint: Tuples use parentheses () not brackets [] or braces {} [OK]

Common Mistakes:

• Using square brackets [] instead of parentheses ()
• Using braces {} which define blocks or structs
• Using angle brackets <> which are invalid here

3. What is the output of the following Rust code?

let person = ("Alice", 30);
println!("{} is {} years old", person.0, person.1);

medium

A. Alice is 30 years old

B. ("Alice", 30) is {} years old

C. person.0 is person.1 years old

D. Compilation error due to tuple access

Solution

1. Step 1: Understand tuple indexing

   Tuple elements are accessed by position using dot and index, e.g., person.0 is "Alice", person.1 is 30.

2. Step 2: Analyze the println! macro

   The placeholders {} are replaced by person.0 and person.1 values, printing "Alice is 30 years old".

3. Final Answer:

   Alice is 30 years old -> Option A

4. Quick Check:

   Tuple access person.0 and person.1 works [OK]

Hint: Access tuple elements by .0, .1, etc. [OK]

Common Mistakes:

• Trying to access tuple elements by name instead of position
• Confusing tuple with array indexing syntax
• Expecting tuple to print as a whole automatically

4. Identify the error in this Rust struct definition and fix it:

struct Point {
    x: i32,
    y i32,
}

medium

A. Trailing comma after last field is not allowed.

B. Struct fields cannot be integers.

C. Struct names must be lowercase.

D. Missing colon after y in struct field declaration.

Solution

1. Step 1: Check struct field syntax

   Each field must have a name, colon, and type. The field 'y i32' is missing a colon.

2. Step 2: Validate other options

   Fields can be integers (i32). Struct names are PascalCase by convention. Trailing commas are allowed in Rust structs.

3. Final Answer:

   Missing colon after y in struct field declaration. -> Option D

4. Quick Check:

   Field syntax requires colon between name and type [OK]

Hint: Struct fields need name: type syntax [OK]

Common Mistakes:

• Omitting colon between field name and type
• Thinking trailing commas are errors
• Using lowercase struct names (allowed but not idiomatic)

5. Given the struct and tuple below, which code correctly creates a struct instance from the tuple values?

struct Color {
    red: u8,
    green: u8,
    blue: u8,
}

let rgb = (255, 100, 50);

hard

A. let color = Color { red: rgb.0, green: rgb.1, blue: rgb.2 };

B. let color = Color(rgb.0, rgb.1, rgb.2);

C. let color = Color { 255, 100, 50 };

D. let color = (red: 255, green: 100, blue: 50);

Solution

1. Step 1: Understand struct initialization

   Structs with named fields require field names and values in braces, e.g., Color { red: val, green: val, blue: val }.

2. Step 2: Use tuple values correctly

   Tuple elements are accessed by position: rgb.0, rgb.1, rgb.2. let color = Color { red: rgb.0, green: rgb.1, blue: rgb.2 }; uses this correctly.

3. Step 3: Check incorrect options

   let color = Color(rgb.0, rgb.1, rgb.2); uses tuple struct syntax, but Color is not a tuple struct. let color = Color { 255, 100, 50 }; omits field names. let color = (red: 255, green: 100, blue: 50); is invalid syntax.

4. Final Answer:

   let color = Color { red: rgb.0, green: rgb.1, blue: rgb.2 }; -> Option A

5. Quick Check:

   Struct init needs field names with values [OK]

Hint: Use field names when creating structs from tuples [OK]

Common Mistakes:

• Trying to initialize struct without field names
• Using tuple struct syntax for normal structs
• Incorrect syntax for struct initialization