Object-Oriented Programming in Rust

pub struct BankAccount {
    // This field is private. It can only be accessed by methods within this module.
    balance: f64,
}

impl BankAccount {
    // A public constructor.
    pub fn new() -> BankAccount {
        BankAccount { balance: 0.0 }
    }

    // A public method to deposit money.
    pub fn deposit(&mut self, amount: f64) {
        if amount > 0.0 {
            self.balance += amount;
        }
    }

    // A public method to withdraw money.
    pub fn withdraw(&mut self, amount: f64) -> Result<(), &'static str> {
        if amount > 0.0 && self.balance >= amount {
            self.balance -= amount;
            Ok(())
        } else {
            Err("Insufficient funds or invalid amount.")
        }
    }

    // A public method to check the balance.
    pub fn balance(&self) -> f64 {
        self.balance
    }
}

fn main() {
    let mut account = BankAccount::new();
    account.deposit(100.0);
    
    // This would fail to compile because `balance` is private:
    // account.balance = 1_000_000.0; 

    println!("Current balance: ${}", account.balance());
}
```
## Inheritance: Composition with Traits

Many OOP languages use **inheritance**, where an object can inherit data and behavior from a parent object. Rust deliberately does not have this form of inheritance, primarily to avoid the complexities and problems it can introduce (like the "diamond problem" and deep, rigid class hierarchies).

Instead, Rust favors **composition over inheritance** through the use of **traits**. A trait defines a set of methods that a type must implement, allowing for shared behavior across different structs.

**Example: A `Drawable` Trait**

Instead of having a base `UIComponent` class that `Button` and `TextField` inherit from, we can define a `Drawable` trait.

````rust
// This trait defines a shared behavior: the ability to be drawn on a screen.
pub trait Drawable {
    fn draw(&self);
}

// A Button struct that implements the Drawable trait.
pub struct Button {
    pub label: String,
}

impl Drawable for Button {
    fn draw(&self) {
        println!("Drawing a button with label: '{}'", self.label);
    }
}

// A TextField struct that also implements the Drawable trait.
pub struct TextField {
    pub placeholder: String,
}

impl Drawable for TextField {
    fn draw(&self) {
        println!("Drawing a text field with placeholder: '{}'", self.placeholder);
    }
}
```
Here, both `Button` and `TextField` can be drawn, but they don't share any parent-child relationship. This is a more flexible and loosely-coupled way to share functionality.

## Polymorphism: Dynamic Dispatch with Trait Objects

Polymorphism is the ability to use an object of one type as if it were another, often a more general type. In Rust, this is achieved using **trait objects**.

A trait object points to an instance of a type that implements a specific trait. We create a trait object by using a pointer (like `&` or `Box`) followed by the `dyn` keyword and the trait name (e.g., `Box<dyn Drawable>`). This allows us to create collections of different types that all share the same trait.

The specific method that gets called is determined at runtime, which is known as **dynamic dispatch**.

**Example: A Screen with Different Components**

Building on the previous example, we can create a `Screen` that holds a list of `Drawable` components.

````rust
// Re-using the Drawable trait and structs from the previous example.


pub struct Screen {
    // `components` is a vector of trait objects. Each element can be any type
    // that implements the `Drawable` trait.
    pub components: Vec<Box<dyn Drawable>>,
}

impl Screen {
    pub fn run(&self) {
        for component in self.components.iter() {
            component.draw();
        }
    }
}

fn main() {
    let screen = Screen {
        components: vec![
            Box::new(Button {
                label: String::from("OK"),
            }),
            Box::new(TextField {
                placeholder: String::from("Enter your name"),
            }),
        ],
    };

    screen.run();
}
```

The `Screen` doesn't need to know the concrete types of its components. It only cares that they implement the `Drawable` trait, allowing it to call the `draw` method on each one.

## Conclusion

Rust provides powerful tools to implement object-oriented patterns in a way that aligns with its core principles of safety and performance.

- **Encapsulation** is achieved through `struct`s and `impl` blocks with public/private visibility.
- **Inheritance** is replaced by a more flexible system of **composition** using traits.
- **Polymorphism** is enabled through **trait objects** (`dyn Trait`), which allow for dynamic dispatch.

By understanding these concepts, you can write clean, maintainable, and idiomatic Rust code that leverages the best of OOP design.

## Resources

- [Official Documentation](https://docs.python.org/3/)
- [Language Specification](https://docs.python.org/3/reference/)
- [Community Resources](https://www.python.org/community/)