Design Principles: DRY, KISS, YAGNI

package main

import "fmt"

type Address struct{ City string }

type Customer struct {
	Name    string
	address Address
}

type Order struct {
	ID       int
	Subtotal int // taka
	Km       int
	customer Customer
}

// Law of Demeter: callers ask the order, instead of reaching through
// order.customer.address.City themselves.
func (o Order) DeliveryCity() string { return o.customer.address.City }

// DRY: the delivery fee rule lives in exactly one function.
// KISS: a plain function with three inputs; no strategy, no factory, no config file.
func deliveryFee(subtotal, km int, city string) int {
	if city == "Dhaka" && subtotal >= 500 {
		return 0 // free delivery in Dhaka from 500 taka
	}
	fee := 40
	if km > 3 {
		fee += (km - 3) * 10
	}
	return fee
}

// Separation of concerns: pricing works out numbers...
func price(o Order) (fee, total int) {
	fee = deliveryFee(o.Subtotal, o.Km, o.DeliveryCity())
	return fee, o.Subtotal + fee
}

// ...and formatting turns numbers into text. Neither knows about the other's job.
func receipt(o Order, fee, total int) string {
	return fmt.Sprintf("order %d: %d tk + delivery %d tk = %d tk (%s, %d km)",
		o.ID, o.Subtotal, fee, total, o.DeliveryCity(), o.Km)
}

func main() {
	dhaka := Address{City: "Dhaka"}
	ctg := Address{City: "Chattogram"}
	orders := []Order{
		{ID: 1, Subtotal: 350, Km: 2, customer: Customer{"Rahim", dhaka}},
		{ID: 2, Subtotal: 650, Km: 6, customer: Customer{"Nadia", dhaka}},
		{ID: 3, Subtotal: 450, Km: 9, customer: Customer{"Tania", ctg}},
		{ID: 4, Subtotal: 650, Km: 6, customer: Customer{"Sabbir", ctg}},
	}
	for _, o := range orders {
		fee, total := price(o)
		fmt.Println(receipt(o, fee, total))
	}
	// The checkout screen and the refund job call the same rule, so they can't disagree.
	fmt.Println("refund job, order 3 delivery:", deliveryFee(450, 9, "Chattogram"), "tk")
}

from dataclasses import dataclass


@dataclass(frozen=True)
class Address:
    city: str


@dataclass(frozen=True)
class Customer:
    name: str
    address: Address


@dataclass(frozen=True)
class Order:
    id: int
    subtotal: int  # taka
    km: int
    customer: Customer

    def delivery_city(self) -> str:
        """Law of Demeter: callers ask the order instead of reaching through customer.address.city."""
        return self.customer.address.city


def delivery_fee(subtotal: int, km: int, city: str) -> int:
    """DRY: the delivery fee rule lives in exactly one function.
    KISS: a plain function with three inputs; no strategy, no factory, no config file."""
    if city == "Dhaka" and subtotal >= 500:
        return 0  # free delivery in Dhaka from 500 taka
    return 40 + max(0, km - 3) * 10


def price(o: Order) -> tuple[int, int]:
    """Separation of concerns: pricing works out numbers..."""
    fee = delivery_fee(o.subtotal, o.km, o.delivery_city())
    return fee, o.subtotal + fee


def receipt(o: Order, fee: int, total: int) -> str:
    """...and formatting turns numbers into text."""
    return f"order {o.id}: {o.subtotal} tk + delivery {fee} tk = {total} tk ({o.delivery_city()}, {o.km} km)"


dhaka, ctg = Address("Dhaka"), Address("Chattogram")
orders = [
    Order(1, 350, 2, Customer("Rahim", dhaka)),
    Order(2, 650, 6, Customer("Nadia", dhaka)),
    Order(3, 450, 9, Customer("Tania", ctg)),
    Order(4, 650, 6, Customer("Sabbir", ctg)),
]
for o in orders:
    fee, total = price(o)
    print(receipt(o, fee, total))
# The checkout screen and the refund job call the same rule, so they can't disagree.
print("refund job, order 3 delivery:", delivery_fee(450, 9, "Chattogram"), "tk")

interface Address {
  readonly city: string;
}

interface Customer {
  readonly name: string;
  readonly address: Address;
}

class Order {
  readonly id: number;
  readonly subtotal: number; // taka
  readonly km: number;
  readonly #customer: Customer;
  constructor(id: number, subtotal: number, km: number, customer: Customer) {
    this.id = id;
    this.subtotal = subtotal;
    this.km = km;
    this.#customer = customer;
  }
  // Law of Demeter: callers ask the order instead of reaching through customer.address.city.
  deliveryCity(): string {
    return this.#customer.address.city;
  }
}

// DRY: the delivery fee rule lives in exactly one function.
// KISS: a plain function with three inputs; no strategy, no factory, no config file.
function deliveryFee(subtotal: number, km: number, city: string): number {
  if (city === "Dhaka" && subtotal >= 500) return 0; // free delivery in Dhaka from 500 taka
  return 40 + Math.max(0, km - 3) * 10;
}

// Separation of concerns: pricing works out numbers...
function price(o: Order): [fee: number, total: number] {
  const fee = deliveryFee(o.subtotal, o.km, o.deliveryCity());
  return [fee, o.subtotal + fee];
}

// ...and formatting turns numbers into text.
function receipt(o: Order, fee: number, total: number): string {
  return `order ${o.id}: ${o.subtotal} tk + delivery ${fee} tk = ${total} tk (${o.deliveryCity()}, ${o.km} km)`;
}

const dhaka: Address = { city: "Dhaka" };
const ctg: Address = { city: "Chattogram" };
const orders = [
  new Order(1, 350, 2, { name: "Rahim", address: dhaka }),
  new Order(2, 650, 6, { name: "Nadia", address: dhaka }),
  new Order(3, 450, 9, { name: "Tania", address: ctg }),
  new Order(4, 650, 6, { name: "Sabbir", address: ctg }),
];
for (const o of orders) {
  const [fee, total] = price(o);
  console.log(receipt(o, fee, total));
}
// The checkout screen and the refund job call the same rule, so they can't disagree.
console.log("refund job, order 3 delivery:", deliveryFee(450, 9, "Chattogram"), "tk");

struct Address { city: String }

struct Customer { _name: String, address: Address }

struct Order { id: u32, subtotal: u32, km: u32, customer: Customer }

impl Order {
    // Law of Demeter: callers ask the order instead of reaching through customer.address.city.
    fn delivery_city(&self) -> &str { &self.customer.address.city }
}

// DRY: the delivery fee rule lives in exactly one function.
// KISS: a plain function with three inputs; no strategy, no factory, no config file.
fn delivery_fee(subtotal: u32, km: u32, city: &str) -> u32 {
    if city == "Dhaka" && subtotal >= 500 {
        return 0; // free delivery in Dhaka from 500 taka
    }
    40 + km.saturating_sub(3) * 10
}

// Separation of concerns: pricing works out numbers...
fn price(o: &Order) -> (u32, u32) {
    let fee = delivery_fee(o.subtotal, o.km, o.delivery_city());
    (fee, o.subtotal + fee)
}

// ...and formatting turns numbers into text.
fn receipt(o: &Order, fee: u32, total: u32) -> String {
    format!("order {}: {} tk + delivery {fee} tk = {total} tk ({}, {} km)", o.id, o.subtotal, o.delivery_city(), o.km)
}

fn main() {
    let order = |id, subtotal, km, name: &str, city: &str| Order {
        id, subtotal, km,
        customer: Customer { _name: name.into(), address: Address { city: city.into() } },
    };
    let orders = [
        order(1, 350, 2, "Rahim", "Dhaka"),
        order(2, 650, 6, "Nadia", "Dhaka"),
        order(3, 450, 9, "Tania", "Chattogram"),
        order(4, 650, 6, "Sabbir", "Chattogram"),
    ];
    for o in &orders {
        let (fee, total) = price(o);
        println!("{}", receipt(o, fee, total));
    }
    // The checkout screen and the refund job call the same rule, so they can't disagree.
    println!("refund job, order 3 delivery: {} tk", delivery_fee(450, 9, "Chattogram"));
}

import java.util.List;

public class Main {
    record Address(String city) {}

    record Customer(String name, Address address) {}

    record Order(int id, int subtotal, int km, Customer customer) {
        // Law of Demeter: callers ask the order instead of reaching through customer().address().city().
        String deliveryCity() { return customer.address().city(); }
    }

    // DRY: the delivery fee rule lives in exactly one method.
    // KISS: a plain method with three inputs; no strategy, no factory, no config file.
    static int deliveryFee(int subtotal, int km, String city) {
        if (city.equals("Dhaka") && subtotal >= 500) return 0; // free delivery in Dhaka from 500 taka
        return 40 + Math.max(0, km - 3) * 10;
    }

    record Price(int fee, int total) {}

    // Separation of concerns: pricing works out numbers...
    static Price price(Order o) {
        int fee = deliveryFee(o.subtotal(), o.km(), o.deliveryCity());
        return new Price(fee, o.subtotal() + fee);
    }

    // ...and formatting turns numbers into text.
    static String receipt(Order o, Price p) {
        return String.format("order %d: %d tk + delivery %d tk = %d tk (%s, %d km)",
            o.id(), o.subtotal(), p.fee(), p.total(), o.deliveryCity(), o.km());
    }

    public static void main(String[] args) {
        Address dhaka = new Address("Dhaka"), ctg = new Address("Chattogram");
        List<Order> orders = List.of(
            new Order(1, 350, 2, new Customer("Rahim", dhaka)),
            new Order(2, 650, 6, new Customer("Nadia", dhaka)),
            new Order(3, 450, 9, new Customer("Tania", ctg)),
            new Order(4, 650, 6, new Customer("Sabbir", ctg)));
        for (Order o : orders) System.out.println(receipt(o, price(o)));
        // The checkout screen and the refund job call the same rule, so they can't disagree.
        System.out.println("refund job, order 3 delivery: " + deliveryFee(450, 9, "Chattogram") + " tk");
    }
}

#include <algorithm>
#include <cstdio>
#include <string>
#include <utility>
#include <vector>

struct Address {
    std::string city;
};

struct Customer {
    std::string name;
    Address address;
};

class Order {
public:
    Order(int id, int subtotal, int km, Customer c) : id(id), subtotal(subtotal), km(km), customer_(std::move(c)) {}
    int id, subtotal, km;  // subtotal in taka
    // Law of Demeter: callers ask the order instead of reaching through customer.address.city.
    const std::string& deliveryCity() const { return customer_.address.city; }

private:
    Customer customer_;
};

// DRY: the delivery fee rule lives in exactly one function.
// KISS: a plain function with three inputs; no strategy, no factory, no config file.
int deliveryFee(int subtotal, int km, const std::string& city) {
    if (city == "Dhaka" && subtotal >= 500) return 0;  // free delivery in Dhaka from 500 taka
    return 40 + std::max(0, km - 3) * 10;
}

// Separation of concerns: pricing works out numbers...
std::pair<int, int> price(const Order& o) {
    int fee = deliveryFee(o.subtotal, o.km, o.deliveryCity());
    return {fee, o.subtotal + fee};
}

// ...and formatting turns numbers into text.
std::string receipt(const Order& o, int fee, int total) {
    char buf[128];
    std::snprintf(buf, sizeof buf, "order %d: %d tk + delivery %d tk = %d tk (%s, %d km)", o.id, o.subtotal, fee,
                  total, o.deliveryCity().c_str(), o.km);
    return buf;
}

int main() {
    Address dhaka{"Dhaka"}, ctg{"Chattogram"};
    std::vector<Order> orders{
        {1, 350, 2, {"Rahim", dhaka}},
        {2, 650, 6, {"Nadia", dhaka}},
        {3, 450, 9, {"Tania", ctg}},
        {4, 650, 6, {"Sabbir", ctg}},
    };
    for (const auto& o : orders) {
        auto [fee, total] = price(o);
        std::printf("%s\n", receipt(o, fee, total).c_str());
    }
    // The checkout screen and the refund job call the same rule, so they can't disagree.
    std::printf("refund job, order 3 delivery: %d tk\n", deliveryFee(450, 9, "Chattogram"));
}