Strategy: swap algorithms at runtime

TypeScript · langs/shipping.ts

// Shipping rules as strategies in TypeScript: a rule is any function from an order to a cost.
type Order = { id: string; subtotal: number; grams: number };
type Rule = (order: Order) => number;
type Settings = { rule: string; [key: string]: string | number };

const RULES: Record<string, (s: Settings) => Rule> = {
  flat: (s) => () => Number(s.amount),
  weight: (s) => (o) => Number(s.base) + Number(s.per_kg) * Math.ceil(o.grams / 1000),
  "free-above": (s) => (o) => (o.subtotal >= Number(s.threshold) ? 0 : Number(s.otherwise)),
};

function makeRule(settings: Settings): Rule {
  const factory = RULES[settings.rule];
  if (!factory) throw new Error(`unknown shipping rule "${settings.rule}"; known rules: ${Object.keys(RULES).sort().join(", ")}`);
  return factory(settings);
}

const orders: Order[] = [
  { id: "A", subtotal: 120, grams: 400 }, { id: "B", subtotal: 499, grams: 2000 }, { id: "C", subtotal: 500, grams: 2000 },
  { id: "D", subtotal: 1250, grams: 7500 }, { id: "E", subtotal: 60, grams: 12000 }, { id: "F", subtotal: 999, grams: 0 },
];
const rules = [
  makeRule({ rule: "flat", amount: 40 }),
  makeRule({ rule: "weight", base: 20, per_kg: 12 }),
  makeRule({ rule: "free-above", threshold: 500, otherwise: 60 }),
];
for (const o of orders) console.log(o.id, rules.map((rule) => rule(o)).join(" "));
try {
  makeRule({ rule: "free_above", threshold: 500, otherwise: 60 });
} catch (e) {
  console.log((e as Error).message);
}

Java · langs/Shipping.java

// Shipping rules as strategies in Java 25: ShippingRule is a functional interface, so each rule is a lambda.
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.function.Function;

public class Shipping {
    record Order(String id, int subtotal, int grams) {}

    @FunctionalInterface
    interface ShippingRule {
        int cost(Order order);
    }

    static final Map<String, Function<Map<String, Integer>, ShippingRule>> RULES = new TreeMap<>(Map.of(
        "flat", s -> order -> s.get("amount"),
        "weight", s -> order -> s.get("base") + s.get("per_kg") * ((order.grams() + 999) / 1000),
        "free-above", s -> order -> order.subtotal() >= s.get("threshold") ? 0 : s.get("otherwise")));

    static ShippingRule makeRule(String name, Map<String, Integer> settings) {
        var factory = RULES.get(name);
        if (factory == null) {
            throw new IllegalArgumentException("unknown shipping rule \"" + name + "\"; known rules: " + String.join(", ", RULES.keySet()));
        }
        return factory.apply(settings);
    }

    public static void main(String[] args) {
        var orders = List.of(new Order("A", 120, 400), new Order("B", 499, 2000), new Order("C", 500, 2000),
            new Order("D", 1250, 7500), new Order("E", 60, 12000), new Order("F", 999, 0));
        var rules = List.of(
            makeRule("flat", Map.of("amount", 40)),
            makeRule("weight", Map.of("base", 20, "per_kg", 12)),
            makeRule("free-above", Map.of("threshold", 500, "otherwise", 60)));
        for (var o : orders) {
            var line = new StringBuilder(o.id());
            for (var rule : rules) line.append(' ').append(rule.cost(o));
            System.out.println(line);
        }
        try {
            makeRule("free_above", Map.of("threshold", 500, "otherwise", 60));
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
        }
    }
}

Go · langs/shipping.go

// Shipping rules as strategies in Go: a rule is a function type, and a map from names to factories picks one.
package main

import (
	"fmt"
	"maps"
	"slices"
	"strings"
)

type Order struct {
	ID              string
	Subtotal, Grams int
}

type Rule func(Order) int

type Settings map[string]int

var rules = map[string]func(Settings) Rule{
	"flat":       func(s Settings) Rule { return func(Order) int { return s["amount"] } },
	"weight":     func(s Settings) Rule { return func(o Order) int { return s["base"] + s["per_kg"]*((o.Grams+999)/1000) } },
	"free-above": func(s Settings) Rule { return func(o Order) int { return freeAbove(o, s) } },
}

func freeAbove(o Order, s Settings) int {
	if o.Subtotal >= s["threshold"] {
		return 0
	}
	return s["otherwise"]
}

func makeRule(name string, s Settings) (Rule, error) {
	factory, ok := rules[name]
	if !ok {
		known := slices.Sorted(maps.Keys(rules))
		return nil, fmt.Errorf("unknown shipping rule %q; known rules: %s", name, strings.Join(known, ", "))
	}
	return factory(s), nil
}

func main() {
	orders := []Order{{"A", 120, 400}, {"B", 499, 2000}, {"C", 500, 2000}, {"D", 1250, 7500}, {"E", 60, 12000}, {"F", 999, 0}}
	var chosen []Rule
	for _, c := range []struct {
		name string
		s    Settings
	}{
		{"flat", Settings{"amount": 40}},
		{"weight", Settings{"base": 20, "per_kg": 12}},
		{"free-above", Settings{"threshold": 500, "otherwise": 60}},
	} {
		rule, err := makeRule(c.name, c.s)
		if err != nil {
			panic(err)
		}
		chosen = append(chosen, rule)
	}
	for _, o := range orders {
		costs := make([]string, len(chosen))
		for i, rule := range chosen {
			costs[i] = fmt.Sprint(rule(o))
		}
		fmt.Println(o.ID, strings.Join(costs, " "))
	}
	if _, err := makeRule("free_above", Settings{"threshold": 500, "otherwise": 60}); err != nil {
		fmt.Println(err)
	}
}

C++ · langs/shipping.cpp

// Shipping rules as strategies in C++23: std::function holds any callable with the right signature.
#include <functional>
#include <map>
#include <print>
#include <stdexcept>
#include <string>
#include <vector>

struct Order {
    std::string id;
    int subtotal;
    int grams;
};

using Rule = std::function<int(const Order&)>;
using Settings = std::map<std::string, int>;

const std::map<std::string, std::function<Rule(const Settings&)>> rules = {
    {"flat", [](const Settings& s) -> Rule { return [a = s.at("amount")](const Order&) { return a; }; }},
    {"weight", [](const Settings& s) -> Rule {
         return [base = s.at("base"), per_kg = s.at("per_kg")](const Order& o) { return base + per_kg * ((o.grams + 999) / 1000); };
     }},
    {"free-above", [](const Settings& s) -> Rule {
         return [t = s.at("threshold"), other = s.at("otherwise")](const Order& o) { return o.subtotal >= t ? 0 : other; };
     }},
};

Rule make_rule(const std::string& name, const Settings& settings) {
    auto it = rules.find(name);
    if (it == rules.end()) {
        std::string known;
        for (const auto& [key, _] : rules) known += (known.empty() ? "" : ", ") + key;
        throw std::invalid_argument("unknown shipping rule \"" + name + "\"; known rules: " + known);
    }
    return it->second(settings);
}

int main() {
    std::vector<Order> orders = {{"A", 120, 400}, {"B", 499, 2000}, {"C", 500, 2000}, {"D", 1250, 7500}, {"E", 60, 12000}, {"F", 999, 0}};
    std::vector<Rule> chosen = {
        make_rule("flat", {{"amount", 40}}),
        make_rule("weight", {{"base", 20}, {"per_kg", 12}}),
        make_rule("free-above", {{"threshold", 500}, {"otherwise", 60}}),
    };
    for (const auto& o : orders) {
        std::print("{}", o.id);
        for (const auto& rule : chosen) std::print(" {}", rule(o));
        std::println("");
    }
    try {
        make_rule("free_above", {{"threshold", 500}, {"otherwise", 60}});
    } catch (const std::invalid_argument& e) {
        std::println("{}", e.what());
    }
}

Rust · langs/shipping.rs

// Shipping rules as strategies in Rust: a rule chosen at run time is a boxed closure, Box<dyn Fn>.
use std::collections::BTreeMap;

struct Order {
    id: &'static str,
    subtotal: u32,
    grams: u32,
}

type Rule = Box<dyn Fn(&Order) -> u32>;
type Settings = BTreeMap<&'static str, u32>;

fn rules() -> BTreeMap<&'static str, fn(&Settings) -> Rule> {
    let mut m: BTreeMap<&'static str, fn(&Settings) -> Rule> = BTreeMap::new();
    m.insert("flat", |s| {
        let amount = s["amount"];
        Box::new(move |_| amount)
    });
    m.insert("weight", |s| {
        let (base, per_kg) = (s["base"], s["per_kg"]);
        Box::new(move |o| base + per_kg * o.grams.div_ceil(1000))
    });
    m.insert("free-above", |s| {
        let (threshold, otherwise) = (s["threshold"], s["otherwise"]);
        Box::new(move |o| if o.subtotal >= threshold { 0 } else { otherwise })
    });
    m
}

fn make_rule(name: &str, settings: &Settings) -> Result<Rule, String> {
    let all = rules();
    match all.get(name) {
        Some(factory) => Ok(factory(settings)),
        None => {
            let known: Vec<&str> = all.keys().copied().collect();
            Err(format!("unknown shipping rule \"{name}\"; known rules: {}", known.join(", ")))
        }
    }
}

fn main() {
    let orders = [
        Order { id: "A", subtotal: 120, grams: 400 },
        Order { id: "B", subtotal: 499, grams: 2000 },
        Order { id: "C", subtotal: 500, grams: 2000 },
        Order { id: "D", subtotal: 1250, grams: 7500 },
        Order { id: "E", subtotal: 60, grams: 12000 },
        Order { id: "F", subtotal: 999, grams: 0 },
    ];
    let chosen: Vec<Rule> = vec![
        make_rule("flat", &Settings::from([("amount", 40)])).unwrap(),
        make_rule("weight", &Settings::from([("base", 20), ("per_kg", 12)])).unwrap(),
        make_rule("free-above", &Settings::from([("threshold", 500), ("otherwise", 60)])).unwrap(),
    ];
    for o in &orders {
        let costs: Vec<String> = chosen.iter().map(|rule| rule(o).to_string()).collect();
        println!("{} {}", o.id, costs.join(" "));
    }
    if let Err(e) = make_rule("free_above", &Settings::from([("threshold", 500), ("otherwise", 60)])) {
        println!("{e}");
    }
}

Rust · langs/dispatch.rs

// One strategy, two kinds of dispatch. total_generic is compiled once for every closure type it is called with
// (monomorphisation); total_dyn is compiled once and calls the closure through a vtable chosen at run time.
struct Order {
    subtotal: u32,
    grams: u32,
}

#[inline(never)]
fn total_generic<F: Fn(&Order) -> u32>(orders: &[Order], rule: F) -> u32 {
    orders.iter().map(|o| rule(o)).sum()
}

#[inline(never)]
fn total_dyn(orders: &[Order], rule: &dyn Fn(&Order) -> u32) -> u32 {
    orders.iter().map(|o| rule(o)).sum()
}

fn main() {
    let orders = [
        Order { subtotal: 120, grams: 400 },
        Order { subtotal: 499, grams: 2000 },
        Order { subtotal: 500, grams: 2000 },
        Order { subtotal: 1250, grams: 7500 },
        Order { subtotal: 60, grams: 12000 },
        Order { subtotal: 999, grams: 0 },
    ];
    let flat = |_: &Order| 40;
    let weight = |o: &Order| 20 + 12 * o.grams.div_ceil(1000);
    let free_above = |o: &Order| if o.subtotal >= 500 { 0 } else { 60 };

    // Static dispatch: three closure types, so three copies of total_generic.
    println!("generic: {} {} {}", total_generic(&orders, flat), total_generic(&orders, weight), total_generic(&orders, free_above));
    // Dynamic dispatch: one copy of total_dyn; the closures can also live in one Vec, chosen by name at run time.
    let by_name: Vec<(&str, Box<dyn Fn(&Order) -> u32>)> = vec![("flat", Box::new(flat)), ("weight", Box::new(weight)), ("free-above", Box::new(free_above))];
    let totals: Vec<String> = by_name.iter().map(|(_, rule)| total_dyn(&orders, rule.as_ref()).to_string()).collect();
    println!("dyn:     {}", totals.join(" "));
}

C++ · langs/dispatch.cpp

// One strategy, two kinds of dispatch in C++. total_template is instantiated once for every lambda type it is called
// with; total_function takes std::function, compiled once, and calls whatever callable it holds at run time.
#include <functional>
#include <print>
#include <vector>

struct Order {
    int subtotal;
    int grams;
};

template <typename Rule>
[[gnu::noinline]] int total_template(const std::vector<Order>& orders, Rule rule) {
    int sum = 0;
    for (const auto& o : orders) sum += rule(o);
    return sum;
}

[[gnu::noinline]] int total_function(const std::vector<Order>& orders, const std::function<int(const Order&)>& rule) {
    int sum = 0;
    for (const auto& o : orders) sum += rule(o);
    return sum;
}

int main() {
    std::vector<Order> orders = {{120, 400}, {499, 2000}, {500, 2000}, {1250, 7500}, {60, 12000}, {999, 0}};
    auto flat = [](const Order&) { return 40; };
    auto weight = [](const Order& o) { return 20 + 12 * ((o.grams + 999) / 1000); };
    auto free_above = [](const Order& o) { return o.subtotal >= 500 ? 0 : 60; };

    std::println("template: {} {} {}", total_template(orders, flat), total_template(orders, weight), total_template(orders, free_above));
    std::vector<std::function<int(const Order&)>> chosen = {flat, weight, free_above};
    std::print("function:");
    for (const auto& rule : chosen) std::print(" {}", total_function(orders, rule));
    std::println("");
}

Rust: mixed closures · langs/mixed.rs

// Two rules that capture their settings, in one Vec without a Box. Every closure has a type of its own, so this
// does not compile. (Closures that capture nothing would compile here: they turn into plain function pointers.)
fn main() {
    let amount = 40;
    let per_kg = 12;
    let flat = move |_grams: u32| amount;
    let weight = move |grams: u32| 20 + per_kg * grams.div_ceil(1000);
    let rules = vec![flat, weight];
    println!("{}", rules.len());
}