Introduction:

Coding practice is essential for improving your programming skills and gaining hands-on experience. In Rust, utilizing structs, enums, and patterns can enhance your ability to solve complex problems and write more efficient code. In this article, we will explore coding practice examples that involve working with structs, enums, and patterns, providing you with opportunities to apply these concepts in practical scenarios.

Example 1:

Student Management System Let's consider a scenario where you need to develop a simple student management system. We can start by defining a struct to represent a student's information:

struct Student {
    name: String,
    age: u32,
    grade: u32,
}

impl Student {
    fn new(name: String, age: u32, grade: u32) -> Student {
        Student { name, age, grade }
    }

    fn display_info(&self) {
        println!("Name: {}, Age: {}, Grade: {}", self.name, self.age, self.grade);
    }
}

fn main() {
    let student1 = Student::new("Alice".to_string(), 18, 12);
    let student2 = Student::new("Bob".to_string(), 17, 11);

    student1.display_info();  // Output: Name: Alice, Age: 18, Grade: 12
    student2.display_info();  // Output: Name: Bob, Age: 17, Grade: 11
}

In this example, we define a Student struct with name, age, and grade fields. The new associated function creates a new instance of the struct, and the display_info method prints the student's information.

Example 2:

File Processing with Enums and Patterns Let's consider a file processing scenario where you need to analyze different file types. We can use enums and pattern matching to handle each file type accordingly:

enum FileType {
    Text,
    Image,
    Video,
}

fn process_file(file_type: FileType, file_name: &str) {
    match file_type {
        FileType::Text => {
            println!("Processing text file: {}", file_name);
            // Additional text file processing logic
        }
        FileType::Image => {
            println!("Processing image file: {}", file_name);
            // Additional image file processing logic
        }
        FileType::Video => {
            println!("Processing video file: {}", file_name);
            // Additional video file processing logic
        }
    }
}

fn main() {
    let file1 = FileType::Text;
    let file2 = FileType::Image;
    let file3 = FileType::Video;

    process_file(file1, "document.txt");  // Output: Processing text file: document.txt
    process_file(file2, "image.png");     // Output: Processing image file: image.png
    process_file(file3, "video.mp4");     // Output: Processing video file: video.mp4
}

In this example, we define an enum FileType to represent different file types. The process_file function takes a FileType and a file name as input and processes the file based on its type using pattern matching.

Example 3:

Library Catalog System Let's imagine you are building a library catalog system. We can create structs and enums to represent books and their genres. Additionally, we can define methods to perform operations on the catalog:

struct Book {
    title: String,
    author: String,
    genre: Genre,
}

enum Genre {
    Fiction,
    NonFiction,
    ScienceFiction,
    Mystery,
}

impl Book {
    fn new(title: String, author: String, genre: Genre) -> Book {
        Book {
            title,
            author,
            genre,
        }
    }

    fn display_info(&self) {
        println!("Title: {}, Author: {}, Genre: {:?}", self.title, self.author, self.genre);
    }
}

struct Catalog {
    books: Vec<Book>,
}

impl Catalog {
    fn new() -> Catalog {
        Catalog { books: Vec::new() }
    }

    fn add_book(&mut self, book: Book) {
        self.books.push(book);
    }

    fn display_catalog(&self) {
        for book in &self.books {
            book.display_info();
        }
    }
}

fn main() {
    let mut catalog = Catalog::new();

    let book1 = Book::new("To Kill a Mockingbird".to_string(), "Harper Lee".to_string(), Genre::Fiction);
    let book2 = Book::new("Sapiens: A Brief History of Humankind".to_string(), "Yuval Noah Harari".to_string(), Genre::NonFiction);
    let book3 = Book::new("1984".to_string(), "George Orwell".to_string(), Genre::ScienceFiction);

    catalog.add_book(book1);
    catalog.add_book(book2);
    catalog.add_book(book3);

    catalog.display_catalog();
}

In this example, we define a Book struct with title, author, and genre fields. The Genre enum represents different book genres. The Catalog struct manages a collection of books. It provides methods to add books to the catalog and display the catalog's contents.

By utilizing structs, enums, and methods, we can create a library catalog system that maintains and presents information about various books in a structured manner.

Conclusion:

Exploring coding practice examples that involve structs, enums, and patterns allows you to solidify your understanding of these concepts and develop practical programming skills in Rust. By engaging in hands-on exercises, you can enhance your problem-solving abilities and become more proficient in writing clean, efficient, and maintainable code.

Take the opportunity to create your own scenarios and apply these concepts to solve different problems. The more you practice, the more comfortable you will become with utilizing structs, enums, and patterns in your Rust projects. Happy coding!

I hope this helps, you!!

More such articles:

https://medium.com/techwasti

https://www.youtube.com/@maheshwarligade

https://www.techwasti.com/

\==========================**=========================

If this article adds any value to you then please clap and comment.

Let’s connect on Stackoverflow, LinkedIn, & Twitter.