# Day 23:Practice working with advanced data types.

Welcome to Day 23 of our Rust programming journey! Today, we'll delve into advanced data types in Rust, including enums, structs, and more, exploring their usage, advantages, and practical applications.

## **Enumerations (Enums) in Rust**

### **Definition and Declaration**

Enums allow developers to define a type by enumerating its possible variants.

#### Usage:

```rust
enum TrafficLight {
    Red,
    Yellow,
    Green,
}

let current_light = TrafficLight::Red;
```

### **Pattern Matching with Enums**

Pattern matching in Rust is powerful and often used with enums to handle different cases.

#### Usage:

```rust
match current_light {
    TrafficLight::Red => println!("Stop!"),
    TrafficLight::Yellow => println!("Prepare to stop."),
    TrafficLight::Green => println!("Go!"),
}
```

## **Structs in Rust**

### **Declaration and Initialization**

Structs allow the creation of custom data types with named fields.

#### Usage:

```rust
struct Person {
    name: String,
    age: u32,
}

let new_person = Person {
    name: String::from("Alice"),
    age: 30,
};
```

### **Methods and Associated Functions**

Structs can have methods that operate on instances of the struct, along with associated functions.

#### Usage:

```rust
impl Person {
    // Method
    fn introduce(&self) {
        println!("Hi, I'm {} and I'm {} years old.", self.name, self.age);
    }

    // Associated function
    fn create(name: String, age: u32) -> Person {
        Person { name, age }
    }
}

let person = Person::create(String::from("Bob"), 25);
person.introduce();
```

## **Options and Results**

### **Option**

`Option<T>` represents an optional value, either `Some` containing a value or `None`.

#### Usage:

```rust
fn find_element(arr: &[i32], target: i32) -> Option<usize> {
    for (index, &element) in arr.iter().enumerate() {
        if element == target {
            return Some(index);
        }
    }
    None
}
```

### **Result**

`Result<T, E>` represents either success (`Ok`) with a value or failure (`Err`) with an error.

#### Usage:

```rust
fn divide(a: f64, b: f64) -> Result<f64, &'static str> {
    if b == 0.0 {
        Err("Division by zero")
    } else {
        Ok(a / b)
    }
}
```

## **Linked Lists in Rust**

### **Definition and Usage**

Linked lists are collections of data elements, where each element points to the next in the sequence.

#### Usage:

```rust
use std::collections::LinkedList;

let mut list: LinkedList<i32> = LinkedList::new();
list.push_back(1);
list.push_back(2);
list.push_back(3);

for item in list.iter() {
    println!("{}", item);
}
```

## **Queues in Rust**

### **Definition and Usage**

Queues are data structures that follow the First-In-First-Out (FIFO) principle.

#### Usage:

```rust
use std::collections::VecDeque;

let mut queue: VecDeque<i32> = VecDeque::new();
queue.push_back(1);
queue.push_back(2);
queue.push_back(3);

while let Some(front) = queue.pop_front() {
    println!("Front element: {}", front);
}
```

## **Binary Trees and Heaps**

### **Binary Trees**

Binary trees are hierarchical data structures with nodes having at most two children.

#### Usage:

```rust
use std::collections::BinaryTree;

let mut tree = BinaryTree::new();
tree.insert(5);
tree.insert(3);
tree.insert(7);

if let Some(root) = tree.get_root() {
    println!("Root: {}", root);
}
```

### **Heaps**

Heaps are tree-based data structures with the property that the parent node is less (or greater) than its children nodes.

#### Usage:

```rust
use std::collections::BinaryHeap;

let mut heap = BinaryHeap::new();
heap.push(5);
heap.push(3);
heap.push(7);

while let Some(max) = heap.pop() {
    println!("Max element: {}", max);
}
```

## **External Crate: HashMaps with** `hashbrown`

The `hashbrown` crate provides an optimized HashMap implementation with superior performance in certain scenarios.

#### Usage:

```rust
use hashbrown::HashMap;

let mut hashmap = HashMap::new();
hashmap.insert("key", "value");

if let Some(value) = hashmap.get("key") {
    println!("Value: {}", value);
}
```

## **Conclusion**

Exploring advanced data types and collections in Rust expands your toolbox for solving complex problems efficiently. Linked lists, queues, binary trees, heaps, and specialized HashMap implementations offered by external crates like `hashbrown` provide specialized data structures catering to various requirements.

Utilizing these advanced collections equips you to tackle diverse programming challenges, optimize performance, and design more efficient algorithms. As you continue your Rust journey, experimenting with and mastering these advanced data types will enhance your programming skills and enable you to build more sophisticated and performant Rust applications. Keep exploring and experimenting to unlock the full potential of Rust's powerful collection types!

Happy coding with Rust!

I hope this helps, you!!

**More such articles:**

[https://medium.com/techwasti](Link)

[https://www.youtube.com/@maheshwarligade](https://www.youtube.com/@maheshwarligade)

[https://www.techwasti.com/](Link)

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

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

**Let’s connect on** [**Stackoverflow**](http://stackoverflow.com/users/3187349/maheshwar-ligade)**,** [**LinkedIn**](https://in.linkedin.com/in/maheshwar-ligade-14447841)**, &** [**Twitter**](https://twitter.com/MaheshwarLigade)**.**