Factory Method Pattern in Rust: A Guide to Flexible Object Creation

Welcome to the second lesson in our course on Creational Patterns in Rust! 🌟 In the previous lesson, we delved into the Singleton Pattern, ensuring a single instance of a struct with a global access point. Now, let's explore another powerful creational design pattern: the Factory Method Pattern. This pattern enhances object creation with flexibility and extensibility, leveraging Rust's traits and ownership model.

The Factory Method Pattern provides a way to encapsulate object creation, allowing different implementations to alter the type of objects that will be created. In Rust, we achieve this through traits to define interfaces and concrete structs to implement those interfaces. Rust's emphasis on traits and composition over inheritance aligns perfectly with this pattern, providing flexibility in an idiomatic way.

The pattern consists of four essential components: the Product (a trait defining common behavior), Concrete Products (structs implementing the Product trait), Creator (a trait declaring the factory method), and Concrete Creators (structs implementing the Creator trait to produce specific products).

Use the Factory Method Pattern in Rust when:

• You need to instantiate different types without knowing the exact object type at compile time.
• Your program requires a flexible, plug-and-play way to introduce new types with minimal changes.
• You want to encapsulate creation details while keeping your code understandable and extensible.

Let's begin by defining the document interface and concrete document types:

// Define the Document trait as the product interface
trait Document {
    fn open(&self);
}

// Concrete product - WordDocument
struct WordDocument;

impl Document for WordDocument {
    fn open(&self) {
        println!("Opening Word document.");
    }
}

// Concrete product - ExcelDocument
struct ExcelDocument;

impl Document for ExcelDocument {
    fn open(&self) {
        println!("Opening Excel document.");
    }
}

Here, we use traits to define the interface for Document, and WordDocument and ExcelDocument are concrete structs implementing this interface with specific behavior.