Object-Oriented Programming Features of Rust

Objects Contain Data and Behavior

The characteristics of object-oriented languages, particularly focus on objects, encapsulation, and inheritance. While there's no consensus on the exact features defining object-oriented programming (OOP), there are common elements.

According to the definition from the book "Design Patterns: Elements of Reusable Object-Oriented Software" (often referred to as The Gang of Four book), OOP involves objects that encapsulate both data and procedures (methods or operations). In Rust, although structs and enums with methods aren't explicitly called objects, they fulfill the same purpose by containing data and methods through impl blocks. Thus, Rust aligns with the definition of OOP provided by The Gang of Four.

Encapsulation

Encapsulation is a fundamental concept in object-oriented programming (OOP), ensuring that the internal details of an object remain hidden from external code. In Rust, encapsulation is achieved through the use of visibility modifiers like pub and defaulting fields to private.

For example, let's consider a struct AveragedCollection that maintains a list of integers and calculates the average of those values. Its implementation could look like this:

pub struct AveragedCollection {
    list: Vec<i32>,
    average: f64,
}

impl AveragedCollection {
    pub fn add(&mut self, value: i32) {
        self.list.push(value);
        self.update_average();
    }

    pub fn remove(&mut self) -> Option<i32> {
        let result = self.list.pop();
        if let Some(value) = result {
            self.update_average();
            Some(value)
        } else {
            None
        }
    }

    pub fn average(&self) -> f64 {
        self.average
    }

    fn update_average(&mut self) {
        let total: i32 = self.list.iter().sum();
        self.average = total as f64 / self.list.len() as f64;
    }
}

In this example:

• The AveragedCollection struct has private fields list and average.
• Public methods add, remove, and average provide controlled access to the internal data.
• The private method update_average ensures that the average field stays updated whenever items are added or removed from the list.

Encapsulation allows for flexibility in changing the internal implementation without affecting external code. For instance, we could switch from Vec<i32> to HashSet<i32> for the list without requiring changes in code using AveragedCollection.

In Rust, encapsulation is enforced through the visibility of fields and methods, providing a robust mechanism for object-oriented programming.

Inheritance and Polymorphism

In Rust, traditional inheritance and polymorphism isn't supported as in other object-oriented languages. Instead, Rust offers alternatives like trait objects for achieving similar functionalities.

1. Inheritance: Inheritance is often used for reusing code by implementing behavior for one type and then inheriting it for another type. Rust provides a limited alternative through default trait method implementations. For instance, if a trait Summary has a default implementation for summarize, any type implementing Summary will inherit this method.

   Example:

   trait Summary {
       fn summarize(&self) -> String {
           String::from("Read more...")
       }
   }
   

2. Polymorphism: Inheritance enables polymorphism, allowing objects of different types to be treated interchangeably if they share certain characteristics. Rust achieves polymorphism through generics and trait bounds. Generics allow writing functions and structs that can work with any type, while trait bounds specify what behavior a type must provide.

   Example 1:

   // A function that takes any type T implementing Summary trait
   fn notify<T: Summary>(item: T) {
       println!("Breaking news! {}", item.summarize());
   }
   

   This allows calling notify with different types that implement Summary.

   Example 2:

   use std::any::Any;
   
   // Define a trait
   trait Animal {
       fn make_sound(&self);
       fn as_any(&self) -> &dyn Any;
   }
   
   // Implement the trait for Dog
   struct Dog {
       name: String,
   }
   impl Dog {
       // Constructor
       fn new(name: &str) -> Dog {
           Dog { name: String::from(name) }
       }
   }
   impl Animal for Dog {
       fn make_sound(&self) {
           println!("Woof!");
       }
       fn as_any(&self) -> &dyn Any {
           self
       }
   }
   
   // Implement the trait for Cat
   struct Cat{
       name: String,
   }
   impl Cat {
       // Constructor
       fn new(name: &str) -> Cat {
           Cat { name: String::from(name) }
       }
   }
   impl Animal for Cat {
       fn make_sound(&self) {
           println!("Meow!");
       }
       fn as_any(&self) -> &dyn Any {
           self
       }
   }
   
   // Function that accepts trait objects
   fn make_some_noise(animal: &dyn Animal) {
       animal.make_sound();
       //println!("This is a Animal named {}", animal.name);
       
       // Try to downcast to Dog or Cat
       if let Some(dog) = animal.as_any().downcast_ref::<Dog>() {
           println!("This is a Dog named {}", dog.name);
       } else if let Some(cat) = animal.as_any().downcast_ref::<Cat>() {
           println!("This is a Cat named {}", cat.name);
       }
   }
   
   fn main() {
       // Create instances of Dog and Cat
       let dog = Dog::new("Rex");
       let cat = Cat::new("Whiskers");
   
       make_some_noise(&dog);
       make_some_noise(&cat);
   }

   This allows passing any object that implements the Animal trait to make_some_noise.