Strategy Design Pattern

@FunctionalInterface
public interface DiscountPolicy {
    Money apply(Cart cart);
}

public final class PercentageOff implements DiscountPolicy {
    private final BigDecimal rate;
    public PercentageOff(BigDecimal rate) { this.rate = rate; }

    @Override public Money apply(Cart cart) {
        return cart.subtotal().times(BigDecimal.ONE.subtract(rate));
    }
}

public final class BuyOneGetOne implements DiscountPolicy {
    @Override public Money apply(Cart cart) {
        return cart.subtotal().minus(cart.cheapestOfEachPair());
    }
}

public class Checkout {
    private final DiscountPolicy policy;   // injected, not chosen here
    public Checkout(DiscountPolicy policy) { this.policy = policy; }

    public Money total() {
        return policy.apply(cart).plus(shipping()).plus(tax());
    }
}

// Because the interface is @FunctionalInterface, a whole strategy can be a
// lambda when it doesn't need a name or state:
//
//     new Checkout(cart -> cart.subtotal());          // NoDiscount
//     new Checkout(new PercentageOff(new BigDecimal("0.10")));

from decimal import Decimal
from typing import Callable

# In Python a Strategy is usually just a callable. A class earns its place only
# when the strategy carries configuration or needs more than one method.
DiscountPolicy = Callable[[Cart], Money]


def no_discount(cart: Cart) -> Money:
    return cart.subtotal


def percentage_off(rate: Decimal) -> DiscountPolicy:
    """A closure over `rate` — the parameterised strategy, without a class."""
    def apply(cart: Cart) -> Money:
        return cart.subtotal * (Decimal(1) - rate)
    return apply


def buy_one_get_one(cart: Cart) -> Money:
    return cart.subtotal - cart.cheapest_of_each_pair()


class Checkout:
    def __init__(self, cart: Cart, policy: DiscountPolicy = no_discount) -> None:
        self._cart = cart
        self._policy = policy

    def total(self) -> Money:
        return self._policy(self._cart) + self.shipping() + self.tax()


# Checkout(cart, percentage_off(Decimal("0.10"))).total()
#
# Selection lives at the edge, in one lookup table:
#
#     POLICIES = {"bogo": buy_one_get_one, "loyalty": loyalty_tier}
#     Checkout(cart, POLICIES[code])

#include <functional>
#include <memory>

// Two idiomatic choices in C++, and they trade off differently.

// 1. std::function — runtime-swappable, allocates, one indirect call.
using DiscountPolicy = std::function<Money(const Cart&)>;

Money no_discount(const Cart& c) { return c.subtotal(); }

auto percentage_off(double rate) {
    return [rate](const Cart& c) { return c.subtotal() * (1.0 - rate); };
}

class Checkout {
public:
    explicit Checkout(DiscountPolicy policy) : policy_(std::move(policy)) {}
    Money total() const { return policy_(cart_) + shipping() + tax(); }
private:
    DiscountPolicy policy_;
    Cart cart_;
};

// 2. A template parameter — the strategy is chosen at COMPILE time, so the
//    call is inlined and there is no indirection at all. This is why
//    std::sort(begin, end, comparator) is as fast as a hand-written loop.
template <typename Policy>
class FastCheckout {
public:
    Money total() const { return Policy{}(cart_) + shipping() + tax(); }
private:
    Cart cart_;
};

// Use the template form on a hot path, std::function when the policy is picked
// from configuration at runtime.

public interface IDiscountPolicy
{
    Money Apply(Cart cart);
}

public sealed class PercentageOff(decimal rate) : IDiscountPolicy
{
    public Money Apply(Cart cart) => cart.Subtotal * (1m - rate);
}

public sealed class BuyOneGetOne : IDiscountPolicy
{
    public Money Apply(Cart cart) => cart.Subtotal - cart.CheapestOfEachPair();
}

public sealed class Checkout(IDiscountPolicy policy)
{
    public Money Total(Cart cart) => policy.Apply(cart) + Shipping() + Tax();
}

// A one-method interface is also just a delegate, so this is equally valid and
// often lighter:
//
//     public sealed class Checkout(Func<Cart, Money> policy) { ... }
//     new Checkout(cart => cart.Subtotal * 0.9m);
//
// Prefer the interface when you want DI registration by name, or when the
// strategy grows a second method.

// Functions are values, so a Strategy is a function. No interface, no class.

const noDiscount = cart => cart.subtotal

// Parameterised strategy = a closure. This is the whole "concrete strategy
// with configuration" idea, in one line.
const percentageOff = rate => cart => cart.subtotal * (1 - rate)

const buyOneGetOne = cart => cart.subtotal - cheapestOfEachPair(cart)

class Checkout {
  constructor(cart, policy = noDiscount) {
    this.cart = cart
    this.policy = policy
  }

  total() {
    return this.policy(this.cart) + this.shipping() + this.tax()
  }
}

// Selection happens once, at the edge:
const POLICIES = {
  none: noDiscount,
  bogo: buyOneGetOne,
  pct10: percentageOff(0.1),
}

new Checkout(cart, POLICIES[req.body.promo] ?? noDiscount).total()

// The lookup table IS the pattern here. What it replaced was a switch that had
// to be edited for every new promo; this one is data you can extend.

package checkout

// A single-method interface is the most idiomatic Strategy in Go, and it needs
// no `implements` — any type with the method satisfies it.
type DiscountPolicy interface {
	Apply(Cart) Money
}

type NoDiscount struct{}

func (NoDiscount) Apply(c Cart) Money { return c.Subtotal }

type PercentageOff struct{ Rate float64 }

func (p PercentageOff) Apply(c Cart) Money {
	return c.Subtotal.Times(1 - p.Rate)
}

type Checkout struct {
	Policy DiscountPolicy
}

func (co Checkout) Total(c Cart) Money {
	return co.Policy.Apply(c).Plus(shipping()).Plus(tax())
}

// The func-type variant, when the strategy has no state — this is exactly how
// http.HandlerFunc lets a plain function satisfy http.Handler:
//
//	type PolicyFunc func(Cart) Money
//	func (f PolicyFunc) Apply(c Cart) Money { return f(c) }
//
//	co := Checkout{Policy: PolicyFunc(func(c Cart) Money { return c.Subtotal })}

type DiscountPolicy = (cart: Cart) => Money

const noDiscount: DiscountPolicy = cart => cart.subtotal
const percentageOff = (rate: number): DiscountPolicy => cart => cart.subtotal * (1 - rate)
const buyOneGetOne: DiscountPolicy = cart => cart.subtotal - cheapestOfEachPair(cart)

class Checkout {
  constructor(
    private readonly cart: Cart,
    private readonly policy: DiscountPolicy = noDiscount,
  ) {}

  total(): Money {
    return this.policy(this.cart) + this.shipping() + this.tax()
  }
}

// The registry gets a real superpower from the type system: `satisfies` keeps
// the literal key names, so PromoCode is a union of exactly what exists...
const POLICIES = {
  none: noDiscount,
  bogo: buyOneGetOne,
  pct10: percentageOff(0.1),
} satisfies Record<string, DiscountPolicy>

type PromoCode = keyof typeof POLICIES   // 'none' | 'bogo' | 'pct10'

// ...and adding a policy widens the union automatically, so a switch elsewhere
// that forgot to handle it becomes a compile error rather than a silent
// fall-through to full price.