Refactorización entre Paradigmas

A veces, la mejor refactorización implica cambiar de paradigma para abordar mejor un problema.

7.1. De OOP a Funcional

class DiscountCalculator {
    fun calculateDiscount(order: Order): Double {
        var discount = 0.0
        
        if (order.items.size > 5) {
            discount += 5.0
        }
        
        if (order.totalAmount > 100) {
            discount += order.totalAmount * 0.1
        }
        
        if (order.customer.isPremium) {
            discount += 15.0
        }
        
        return discount
    }
}

// Funciones puras que calculan diferentes tipos de descuentos
fun volumeDiscount(order: Order): Double =
    if (order.items.size > 5) 5.0 else 0.0

fun amountDiscount(order: Order): Double =
    if (order.totalAmount > 100) order.totalAmount * 0.1 else 0.0

fun premiumDiscount(order: Order): Double =
    if (order.customer.isPremium) 15.0 else 0.0

// Función componible que aplica todos los descuentos
fun calculateTotalDiscount(order: Order): Double =
    listOf(::volumeDiscount, ::amountDiscount, ::premiumDiscount)
        .sumByDouble { discountFn -> discountFn(order) }

7.2. De Procedural a OOP

struct Customer {
    char name[100];
    int age;
    char address[200];
};

void print_customer(struct Customer customer) {
    printf("Name: %s\n", customer.name);
    printf("Age: %d\n", customer.age);
    printf("Address: %s\n", customer.address);
}

int is_adult(struct Customer customer) {
    return customer.age >= 18;
}

void update_address(struct Customer* customer, const char* new_address) {
    strcpy(customer->address, new_address);
}

class Customer {
private:
    std::string name;
    int age;
    std::string address;
    
public:
    Customer(const std::string& name, int age, const std::string& address)
        : name(name), age(age), address(address) {}
    
    void print() const {
        std::cout << "Name: " << name << std::endl;
        std::cout << "Age: " << age << std::endl;
        std::cout << "Address: " << address << std::endl;
    }
    
    bool isAdult() const {
        return age >= 18;
    }
    
    void updateAddress(const std::string& newAddress) {
        address = newAddress;
    }
};