SOLID Principles

package main

import "fmt"

type Customer struct {
	Name    string
	Student bool
}

type Applied struct {
	Name   string
	Amount int
}

type Invoice struct {
	ID        string
	Customer  Customer
	Subtotal  int
	Discounts []Applied
	Total     int
}

// OCP: a new discount is a new type, not an edit to existing code.
// LSP: every Discount must honour the same promise: return 0..subtotal, never negative.
type Discount interface {
	Name() string
	Amount(c Customer, subtotal int) int
}

type PercentOff struct {
	Label   string
	Percent int
}

func (p PercentOff) Name() string                   { return p.Label }
func (p PercentOff) Amount(_ Customer, sub int) int { return sub * p.Percent / 100 }

type StudentOff struct{ Taka int }

func (StudentOff) Name() string { return "student" }
func (s StudentOff) Amount(c Customer, sub int) int {
	if !c.Student {
		return 0
	}
	return min(s.Taka, sub)
}

// SRP: Calculator only works out numbers.
type Calculator struct{ rules []Discount }

func (calc Calculator) Build(id string, c Customer, subtotal int) Invoice {
	inv := Invoice{ID: id, Customer: c, Subtotal: subtotal, Total: subtotal}
	for _, r := range calc.rules {
		if a := r.Amount(c, subtotal); a > 0 {
			inv.Discounts = append(inv.Discounts, Applied{r.Name(), a})
			inv.Total -= a
		}
	}
	return inv
}

// SRP: printing is a separate job with a separate reason to change.
func Print(inv Invoice) {
	fmt.Printf("invoice %s for %s\n", inv.ID, inv.Customer.Name)
	fmt.Printf("  %-15s %5d tk\n", "subtotal", inv.Subtotal)
	for _, d := range inv.Discounts {
		fmt.Printf("  %-15s %5d tk\n", "- "+d.Name, d.Amount)
	}
	fmt.Printf("  %-15s %5d tk\n", "total", inv.Total)
}

// ISP: checkout only needs to save, so it asks for a small interface, not the whole store.
type InvoiceSaver interface {
	Save(inv Invoice) string
}

// MemoryStore can do more (Count), but checkout never sees that.
type MemoryStore struct{ saved []Invoice }

func (m *MemoryStore) Save(inv Invoice) string { m.saved = append(m.saved, inv); return "memory" }
func (m *MemoryStore) Count() int              { return len(m.saved) }

// DIP: Checkout depends on abstractions (Discount, InvoiceSaver), not on a database class.
type Checkout struct {
	calc  Calculator
	saver InvoiceSaver
}

func (co Checkout) Process(id string, c Customer, subtotal int) {
	inv := co.calc.Build(id, c, subtotal)
	Print(inv)
	fmt.Printf("saved %s to %s\n", inv.ID, co.saver.Save(inv))
}

func main() {
	store := &MemoryStore{}
	co := Checkout{
		calc:  Calculator{rules: []Discount{PercentOff{"eid sale 10%", 10}, StudentOff{Taka: 50}}},
		saver: store,
	}
	co.Process("INV-1", Customer{"Rahim", true}, 1200)
	co.Process("INV-2", Customer{"Nadia", false}, 300)
	fmt.Println("store has", store.Count(), "invoices")
}

from __future__ import annotations

from dataclasses import dataclass, field
from typing import Protocol


@dataclass(frozen=True)
class Customer:
    name: str
    student: bool


@dataclass
class Invoice:
    id: str
    customer: Customer
    subtotal: int
    discounts: list[tuple[str, int]] = field(default_factory=list)
    total: int = 0


class Discount(Protocol):
    """OCP: a new discount is a new class, not an edit to existing code.
    LSP: every Discount must honour the same promise: return 0..subtotal, never negative."""
    name: str

    def amount(self, c: Customer, subtotal: int) -> int: ...


class PercentOff:
    def __init__(self, label: str, percent: int):
        self.name, self.percent = label, percent

    def amount(self, c: Customer, subtotal: int) -> int:
        return subtotal * self.percent // 100


class StudentOff:
    name = "student"

    def __init__(self, taka: int):
        self.taka = taka

    def amount(self, c: Customer, subtotal: int) -> int:
        return min(self.taka, subtotal) if c.student else 0


class Calculator:
    """SRP: only works out numbers."""

    def __init__(self, rules: list[Discount]):
        self.rules = rules

    def build(self, id: str, c: Customer, subtotal: int) -> Invoice:
        inv = Invoice(id, c, subtotal, total=subtotal)
        for r in self.rules:
            a = r.amount(c, subtotal)
            if a > 0:
                inv.discounts.append((r.name, a))
                inv.total -= a
        return inv


def print_invoice(inv: Invoice) -> None:
    """SRP: printing is a separate job with a separate reason to change."""
    print(f"invoice {inv.id} for {inv.customer.name}")
    print(f"  {'subtotal':<15} {inv.subtotal:>5} tk")
    for name, amount in inv.discounts:
        print(f"  {'- ' + name:<15} {amount:>5} tk")
    print(f"  {'total':<15} {inv.total:>5} tk")


class InvoiceSaver(Protocol):
    """ISP: checkout only needs to save, so it asks for a small interface."""

    def save(self, inv: Invoice) -> str: ...


class MemoryStore:
    """Can do more (count), but checkout never sees that."""

    def __init__(self) -> None:
        self.saved: list[Invoice] = []

    def save(self, inv: Invoice) -> str:
        self.saved.append(inv)
        return "memory"

    def count(self) -> int:
        return len(self.saved)


class Checkout:
    """DIP: depends on abstractions (Discount, InvoiceSaver), not on a database class."""

    def __init__(self, calc: Calculator, saver: InvoiceSaver):
        self.calc, self.saver = calc, saver

    def process(self, id: str, c: Customer, subtotal: int) -> None:
        inv = self.calc.build(id, c, subtotal)
        print_invoice(inv)
        print(f"saved {inv.id} to {self.saver.save(inv)}")


store = MemoryStore()
co = Checkout(Calculator([PercentOff("eid sale 10%", 10), StudentOff(50)]), store)
co.process("INV-1", Customer("Rahim", True), 1200)
co.process("INV-2", Customer("Nadia", False), 300)
print("store has", store.count(), "invoices")

interface Customer {
  readonly name: string;
  readonly student: boolean;
}

interface Invoice {
  readonly id: string;
  readonly customer: Customer;
  readonly subtotal: number;
  readonly discounts: { name: string; amount: number }[];
  total: number;
}

// OCP: a new discount is a new class, not an edit to existing code.
// LSP: every Discount must honour the same promise: return 0..subtotal, never negative.
interface Discount {
  readonly name: string;
  amount(c: Customer, subtotal: number): number;
}

class PercentOff implements Discount {
  readonly name: string;
  readonly percent: number;
  constructor(label: string, percent: number) {
    this.name = label;
    this.percent = percent;
  }
  amount(_c: Customer, subtotal: number): number {
    return Math.floor((subtotal * this.percent) / 100);
  }
}

class StudentOff implements Discount {
  readonly name = "student";
  readonly taka: number;
  constructor(taka: number) {
    this.taka = taka;
  }
  amount(c: Customer, subtotal: number): number {
    return c.student ? Math.min(this.taka, subtotal) : 0;
  }
}

// SRP: only works out numbers.
class Calculator {
  readonly rules: Discount[];
  constructor(rules: Discount[]) {
    this.rules = rules;
  }
  build(id: string, customer: Customer, subtotal: number): Invoice {
    const inv: Invoice = { id, customer, subtotal, discounts: [], total: subtotal };
    for (const r of this.rules) {
      const a = r.amount(customer, subtotal);
      if (a > 0) {
        inv.discounts.push({ name: r.name, amount: a });
        inv.total -= a;
      }
    }
    return inv;
  }
}

// SRP: printing is a separate job with a separate reason to change.
function printInvoice(inv: Invoice): void {
  const row = (label: string, n: number) => console.log(`  ${label.padEnd(15)} ${String(n).padStart(5)} tk`);
  console.log(`invoice ${inv.id} for ${inv.customer.name}`);
  row("subtotal", inv.subtotal);
  for (const d of inv.discounts) row(`- ${d.name}`, d.amount);
  row("total", inv.total);
}

// ISP: checkout only needs to save, so it asks for a small interface.
interface InvoiceSaver {
  save(inv: Invoice): string;
}

// Can do more (count), but checkout never sees that.
class MemoryStore implements InvoiceSaver {
  readonly saved: Invoice[] = [];
  save(inv: Invoice): string {
    this.saved.push(inv);
    return "memory";
  }
  count(): number {
    return this.saved.length;
  }
}

// DIP: depends on abstractions (Discount, InvoiceSaver), not on a database class.
class Checkout {
  readonly calc: Calculator;
  readonly saver: InvoiceSaver;
  constructor(calc: Calculator, saver: InvoiceSaver) {
    this.calc = calc;
    this.saver = saver;
  }
  process(id: string, c: Customer, subtotal: number): void {
    const inv = this.calc.build(id, c, subtotal);
    printInvoice(inv);
    console.log(`saved ${inv.id} to ${this.saver.save(inv)}`);
  }
}

const store = new MemoryStore();
const co = new Checkout(new Calculator([new PercentOff("eid sale 10%", 10), new StudentOff(50)]), store);
co.process("INV-1", { name: "Rahim", student: true }, 1200);
co.process("INV-2", { name: "Nadia", student: false }, 300);
console.log("store has", store.count(), "invoices");

struct Customer { name: String, student: bool }

struct Invoice { id: String, customer_name: String, subtotal: u32, discounts: Vec<(String, u32)>, total: u32 }

// OCP: a new discount is a new type, not an edit to existing code.
// LSP: every Discount must honour the same promise: return 0..=subtotal.
trait Discount {
    fn name(&self) -> &str;
    fn amount(&self, c: &Customer, subtotal: u32) -> u32;
}

struct PercentOff { label: String, percent: u32 }
impl Discount for PercentOff {
    fn name(&self) -> &str { &self.label }
    fn amount(&self, _: &Customer, sub: u32) -> u32 { sub * self.percent / 100 }
}

struct StudentOff { taka: u32 }
impl Discount for StudentOff {
    fn name(&self) -> &str { "student" }
    fn amount(&self, c: &Customer, sub: u32) -> u32 { if c.student { self.taka.min(sub) } else { 0 } }
}

// SRP: only works out numbers.
struct Calculator { rules: Vec<Box<dyn Discount>> }
impl Calculator {
    fn build(&self, id: &str, c: &Customer, subtotal: u32) -> Invoice {
        let mut inv = Invoice { id: id.into(), customer_name: c.name.clone(), subtotal, discounts: vec![], total: subtotal };
        for r in &self.rules {
            let a = r.amount(c, subtotal);
            if a > 0 {
                inv.discounts.push((r.name().to_string(), a));
                inv.total -= a;
            }
        }
        inv
    }
}

// SRP: printing is a separate job with a separate reason to change.
fn print_invoice(inv: &Invoice) {
    println!("invoice {} for {}", inv.id, inv.customer_name);
    println!("  {:<15} {:>5} tk", "subtotal", inv.subtotal);
    for (name, amount) in &inv.discounts {
        println!("  {:<15} {:>5} tk", format!("- {name}"), amount);
    }
    println!("  {:<15} {:>5} tk", "total", inv.total);
}

// ISP: checkout only needs to save, so it asks for a small trait.
trait InvoiceSaver { fn save(&mut self, inv: Invoice) -> String; }

// Can do more (count), but checkout never sees that.
struct MemoryStore { saved: Vec<Invoice> }
impl InvoiceSaver for MemoryStore {
    fn save(&mut self, inv: Invoice) -> String { self.saved.push(inv); "memory".into() }
}
impl MemoryStore { fn count(&self) -> usize { self.saved.len() } }

// DIP: depends on abstractions (Discount, InvoiceSaver), not on a database type.
struct Checkout<'a> { calc: Calculator, saver: &'a mut dyn InvoiceSaver }
impl Checkout<'_> {
    fn process(&mut self, id: &str, c: &Customer, subtotal: u32) {
        let inv = self.calc.build(id, c, subtotal);
        print_invoice(&inv);
        let id = inv.id.clone();
        println!("saved {id} to {}", self.saver.save(inv));
    }
}

fn main() {
    let mut store = MemoryStore { saved: vec![] };
    {
        let calc = Calculator { rules: vec![
            Box::new(PercentOff { label: "eid sale 10%".into(), percent: 10 }),
            Box::new(StudentOff { taka: 50 }),
        ] };
        let mut co = Checkout { calc, saver: &mut store };
        co.process("INV-1", &Customer { name: "Rahim".into(), student: true }, 1200);
        co.process("INV-2", &Customer { name: "Nadia".into(), student: false }, 300);
    }
    println!("store has {} invoices", store.count());
}

import java.util.ArrayList;
import java.util.List;

public class Main {
    record Customer(String name, boolean student) {}

    record Applied(String name, int amount) {}

    record Invoice(String id, Customer customer, int subtotal, List<Applied> discounts, int total) {}

    // OCP: a new discount is a new class, not an edit to existing code.
    // LSP: every Discount must honour the same promise: return 0..subtotal, never negative.
    interface Discount {
        String name();
        int amount(Customer c, int subtotal);
    }

    record PercentOff(String name, int percent) implements Discount {
        public int amount(Customer c, int subtotal) { return subtotal * percent / 100; }
    }

    record StudentOff(int taka) implements Discount {
        public String name() { return "student"; }
        public int amount(Customer c, int subtotal) { return c.student() ? Math.min(taka, subtotal) : 0; }
    }

    // SRP: only works out numbers.
    record Calculator(List<Discount> rules) {
        Invoice build(String id, Customer c, int subtotal) {
            List<Applied> applied = new ArrayList<>();
            int total = subtotal;
            for (Discount r : rules) {
                int a = r.amount(c, subtotal);
                if (a > 0) {
                    applied.add(new Applied(r.name(), a));
                    total -= a;
                }
            }
            return new Invoice(id, c, subtotal, applied, total);
        }
    }

    // SRP: printing is a separate job with a separate reason to change.
    static void print(Invoice inv) {
        System.out.printf("invoice %s for %s%n", inv.id(), inv.customer().name());
        System.out.printf("  %-15s %5d tk%n", "subtotal", inv.subtotal());
        for (Applied d : inv.discounts()) System.out.printf("  %-15s %5d tk%n", "- " + d.name(), d.amount());
        System.out.printf("  %-15s %5d tk%n", "total", inv.total());
    }

    // ISP: checkout only needs to save, so it asks for a small interface.
    interface InvoiceSaver {
        String save(Invoice inv);
    }

    // Can do more (count), but checkout never sees that.
    static final class MemoryStore implements InvoiceSaver {
        private final List<Invoice> saved = new ArrayList<>();
        public String save(Invoice inv) { saved.add(inv); return "memory"; }
        int count() { return saved.size(); }
    }

    // DIP: depends on abstractions (Discount, InvoiceSaver), not on a database class.
    record Checkout(Calculator calc, InvoiceSaver saver) {
        void process(String id, Customer c, int subtotal) {
            Invoice inv = calc.build(id, c, subtotal);
            print(inv);
            System.out.printf("saved %s to %s%n", inv.id(), saver.save(inv));
        }
    }

    public static void main(String[] args) {
        MemoryStore store = new MemoryStore();
        Checkout co = new Checkout(new Calculator(List.of(new PercentOff("eid sale 10%", 10), new StudentOff(50))), store);
        co.process("INV-1", new Customer("Rahim", true), 1200);
        co.process("INV-2", new Customer("Nadia", false), 300);
        System.out.println("store has " + store.count() + " invoices");
    }
}

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

struct Customer {
    std::string name;
    bool student;
};

struct Invoice {
    std::string id;
    Customer customer;
    int subtotal;
    std::vector<std::pair<std::string, int>> discounts;
    int total;
};

// OCP: a new discount is a new class, not an edit to existing code.
// LSP: every Discount must honour the same promise: return 0..subtotal, never negative.
class Discount {
public:
    virtual ~Discount() = default;
    virtual std::string name() const = 0;
    virtual int amount(const Customer& c, int subtotal) const = 0;
};

class PercentOff : public Discount {
public:
    PercentOff(std::string label, int percent) : label_(std::move(label)), percent_(percent) {}
    std::string name() const override { return label_; }
    int amount(const Customer&, int sub) const override { return sub * percent_ / 100; }

private:
    std::string label_;
    int percent_;
};

class StudentOff : public Discount {
public:
    explicit StudentOff(int taka) : taka_(taka) {}
    std::string name() const override { return "student"; }
    int amount(const Customer& c, int sub) const override { return c.student ? std::min(taka_, sub) : 0; }

private:
    int taka_;
};

// SRP: only works out numbers.
class Calculator {
public:
    explicit Calculator(std::vector<std::unique_ptr<Discount>> rules) : rules_(std::move(rules)) {}
    Invoice build(const std::string& id, const Customer& c, int subtotal) const {
        Invoice inv{id, c, subtotal, {}, subtotal};
        for (const auto& r : rules_) {
            if (int a = r->amount(c, subtotal); a > 0) {
                inv.discounts.push_back({r->name(), a});
                inv.total -= a;
            }
        }
        return inv;
    }

private:
    std::vector<std::unique_ptr<Discount>> rules_;
};

// SRP: printing is a separate job with a separate reason to change.
void print(const Invoice& inv) {
    std::printf("invoice %s for %s\n", inv.id.c_str(), inv.customer.name.c_str());
    std::printf("  %-15s %5d tk\n", "subtotal", inv.subtotal);
    for (const auto& [name, amount] : inv.discounts) std::printf("  %-15s %5d tk\n", ("- " + name).c_str(), amount);
    std::printf("  %-15s %5d tk\n", "total", inv.total);
}

// ISP: checkout only needs to save, so it asks for a small interface.
class InvoiceSaver {
public:
    virtual ~InvoiceSaver() = default;
    virtual std::string save(const Invoice& inv) = 0;
};

// Can do more (count), but checkout never sees that.
class MemoryStore : public InvoiceSaver {
public:
    std::string save(const Invoice& inv) override {
        saved_.push_back(inv);
        return "memory";
    }
    size_t count() const { return saved_.size(); }

private:
    std::vector<Invoice> saved_;
};

// DIP: depends on abstractions (Discount, InvoiceSaver), not on a database class.
class Checkout {
public:
    Checkout(Calculator calc, InvoiceSaver& saver) : calc_(std::move(calc)), saver_(saver) {}
    void process(const std::string& id, const Customer& c, int subtotal) {
        Invoice inv = calc_.build(id, c, subtotal);
        print(inv);
        std::printf("saved %s to %s\n", inv.id.c_str(), saver_.save(inv).c_str());
    }

private:
    Calculator calc_;
    InvoiceSaver& saver_;
};

int main() {
    MemoryStore store;
    std::vector<std::unique_ptr<Discount>> rules;
    rules.push_back(std::make_unique<PercentOff>("eid sale 10%", 10));
    rules.push_back(std::make_unique<StudentOff>(50));
    Checkout co(Calculator(std::move(rules)), store);
    co.process("INV-1", {"Rahim", true}, 1200);
    co.process("INV-2", {"Nadia", false}, 300);
    std::printf("store has %zu invoices\n", store.count());
}