Applying Polymorphism in Rust with Traits and Structs

Welcome to the fourth lesson of the Clean Code with Multiple Structs and Traits in Rust course, you're almost at the finish line! In this lesson, we'll delve into the powerful concept of polymorphism using Rust's traits, structs, and enums. Polymorphism is a fundamental principle in programming that allows us to write flexible and reusable code. In Rust, traits enable different types to share a common interface, allowing us to treat diverse types uniformly through dynamic or static dispatch. Today, we'll explore how to apply these principles to write clean, maintainable, and scalable Rust code. Let's get started!

Polymorphism in Rust empowers developers to create flexible and scalable applications by allowing different struct types to be treated uniformly through traits or enums. For example, consider several structs representing different payment methods: CreditCardPayment, PayPalPayment, and BankTransferPayment. By implementing a shared trait or using an enum, these can be handled in a unified, clean manner.

Here's a basic example illustrating this concept using traits:

trait Payment {
    fn pay(&self);
}

struct CreditCardPayment;

impl Payment for CreditCardPayment {
    fn pay(&self) {
        println!("Processing credit card payment.");
    }
}

struct PayPalPayment;

impl Payment for PayPalPayment {
    fn pay(&self) {
        println!("Processing PayPal payment.");
    }
}

With the Payment trait, you can work with different payment methods through a single, common interface:

fn process_payment(payment: &dyn Payment) {
    payment.pay(); 
}

fn main() {
    let credit_card_payment = CreditCardPayment;
    let paypal_payment = PayPalPayment;

    process_payment(&credit_card_payment);
    process_payment(&paypal_payment);
}

This demonstrates a core benefit of polymorphism: the ability to operate on various types uniformly, reducing code duplication and making it easier to add new payment types by simply implementing the Payment trait.

A common challenge in software design is managing code that's difficult to maintain or extend due to repetitive conditionals or complex logic based on primitive types. Polymorphism offers a solution by enabling a more abstract and scalable design. Without polymorphism, handling different payment methods might involve extensive conditional checks on strings or other primitive values:

fn process_payment_details(payment_method: &str) {
    match payment_method {
        "CreditCard" => println!("Processing credit card payment."),
        "PayPal" => println!("Processing PayPal payment."),
        // More matches...
        _ => println!("Unknown payment method."),
    }
}

As the number of payment methods grows, this approach becomes cumbersome and error-prone. It relies on string literals, which lack type safety and can lead to bugs that are hard to detect at compile time. Polymorphism eliminates the need for such conditionals by abstracting common behaviors through traits or enums.

By using traits, you can define a common interface for all payment methods:

fn process_payment(payment: &dyn Payment) {
    payment.pay();
}

Alternatively, using enums with pattern matching provides a type-safe and exhaustive way to handle different payment methods, leveraging Rust's powerful pattern matching capabilities in an idiomatic way.

By designing types that embrace polymorphism — whether through traits for dynamic dispatch or enums for static dispatch — you can avoid complex conditionals based on primitive values. This makes your code cleaner, more maintainable, and easier to extend, as adding new payment methods doesn't require modifying existing conditional logic.