What Is Low Level Design?

package main

import (
	"errors"
	"fmt"
)

// Each class has one job, found from the nouns in the requirements.

type Book struct {
	Title  string
	onLoan bool
}

type Member struct {
	Name    string
	Premium bool
	loans   int
}

// The borrowing limit lives with the member, so "premium gets 5" is a one-line change.
func (m *Member) limit() int {
	if m.Premium {
		return 5
	}
	return 3
}

type Loan struct {
	book   *Book
	member *Member
	due    int // day number
}

// Library is the only place that decides who may borrow what.
type Library struct {
	loans []*Loan
}

const loanDays, finePerDay = 14, 5 // taka

func (l *Library) Lend(m *Member, b *Book, today int) error {
	if b.onLoan {
		return errors.New("already on loan")
	}
	if m.loans >= m.limit() {
		return fmt.Errorf("limit reached (%d)", m.limit())
	}
	b.onLoan = true
	m.loans++
	l.loans = append(l.loans, &Loan{book: b, member: m, due: today + loanDays})
	return nil
}

// Return closes the loan and says how much fine is due.
func (l *Library) Return(b *Book, today int) (int, error) {
	for i, ln := range l.loans {
		if ln.book == b {
			l.loans = append(l.loans[:i], l.loans[i+1:]...)
			b.onLoan = false
			ln.member.loans--
			return max(0, today-ln.due) * finePerDay, nil
		}
	}
	return 0, errors.New("not on loan")
}

func main() {
	lib := &Library{}
	rahim := &Member{Name: "Rahim"}
	nadia := &Member{Name: "Nadia", Premium: true}
	books := []*Book{{Title: "Himu"}, {Title: "Feluda"}, {Title: "Byomkesh"}, {Title: "Tintin"}}

	for _, b := range books {
		if err := lib.Lend(rahim, b, 1); err != nil {
			fmt.Printf("day 1  Rahim  %-9s refused: %v\n", b.Title, err)
		} else {
			fmt.Printf("day 1  Rahim  %-9s ok\n", b.Title)
		}
	}
	if err := lib.Lend(nadia, books[0], 2); err != nil {
		fmt.Printf("day 2  Nadia  %-9s refused: %v\n", books[0].Title, err)
	}
	fine, _ := lib.Return(books[0], 19) // due on day 15
	fmt.Printf("day 19 Rahim  returns %s, %d days late, fine %d taka\n", books[0].Title, fine/finePerDay, fine)
	if err := lib.Lend(nadia, books[3], 19); err == nil {
		fmt.Printf("day 19 Nadia  %-9s ok (premium limit %d)\n", books[3].Title, nadia.limit())
	}
}

from dataclasses import dataclass, field

LOAN_DAYS, FINE_PER_DAY = 14, 5  # taka

# Each class has one job, found from the nouns in the requirements.

@dataclass(eq=False)
class Book:
    title: str
    on_loan: bool = False


@dataclass(eq=False)
class Member:
    name: str
    premium: bool = False
    loans: int = 0

    # The borrowing limit lives with the member, so "premium gets 5" is a one-line change.
    def limit(self) -> int:
        return 5 if self.premium else 3


@dataclass(eq=False)
class Loan:
    book: Book
    member: Member
    due: int  # day number


class LendError(Exception):
    pass


@dataclass
class Library:
    """The only place that decides who may borrow what."""
    loans: list[Loan] = field(default_factory=list)

    def lend(self, m: Member, b: Book, today: int) -> None:
        if b.on_loan:
            raise LendError("already on loan")
        if m.loans >= m.limit():
            raise LendError(f"limit reached ({m.limit()})")
        b.on_loan = True
        m.loans += 1
        self.loans.append(Loan(b, m, today + LOAN_DAYS))

    def return_book(self, b: Book, today: int) -> int:
        for ln in self.loans:
            if ln.book is b:
                self.loans.remove(ln)
                b.on_loan = False
                ln.member.loans -= 1
                return max(0, today - ln.due) * FINE_PER_DAY
        raise LendError("not on loan")


lib = Library()
rahim, nadia = Member("Rahim"), Member("Nadia", premium=True)
books = [Book(t) for t in ("Himu", "Feluda", "Byomkesh", "Tintin")]

for b in books:
    try:
        lib.lend(rahim, b, 1)
        print(f"day 1  Rahim  {b.title:<9} ok")
    except LendError as e:
        print(f"day 1  Rahim  {b.title:<9} refused: {e}")
try:
    lib.lend(nadia, books[0], 2)
except LendError as e:
    print(f"day 2  Nadia  {books[0].title:<9} refused: {e}")
fine = lib.return_book(books[0], 19)  # due on day 15
print(f"day 19 Rahim  returns {books[0].title}, {fine // FINE_PER_DAY} days late, fine {fine} taka")
lib.lend(nadia, books[3], 19)
print(f"day 19 Nadia  {books[3].title:<9} ok (premium limit {nadia.limit()})")

const LOAN_DAYS = 14, FINE_PER_DAY = 5; // taka

// Each class has one job, found from the nouns in the requirements.

class Book {
  readonly title: string;
  onLoan = false;
  constructor(title: string) {
    this.title = title;
  }
}

class Member {
  readonly name: string;
  readonly premium: boolean;
  loans = 0;
  constructor(name: string, premium = false) {
    this.name = name;
    this.premium = premium;
  }
  // The borrowing limit lives with the member, so "premium gets 5" is a one-line change.
  limit(): number {
    return this.premium ? 5 : 3;
  }
}

interface Loan { book: Book; member: Member; due: number } // due = day number

// The only place that decides who may borrow what.
class Library {
  private loans: Loan[] = [];

  lend(m: Member, b: Book, today: number): void {
    if (b.onLoan) throw new Error("already on loan");
    if (m.loans >= m.limit()) throw new Error(`limit reached (${m.limit()})`);
    b.onLoan = true;
    m.loans++;
    this.loans.push({ book: b, member: m, due: today + LOAN_DAYS });
  }

  returnBook(b: Book, today: number): number {
    const i = this.loans.findIndex((ln) => ln.book === b);
    if (i < 0) throw new Error("not on loan");
    const [ln] = this.loans.splice(i, 1);
    b.onLoan = false;
    ln!.member.loans--;
    return Math.max(0, today - ln!.due) * FINE_PER_DAY;
  }
}

const lib = new Library();
const rahim = new Member("Rahim"), nadia = new Member("Nadia", true);
const books = ["Himu", "Feluda", "Byomkesh", "Tintin"].map((t) => new Book(t));

for (const b of books) {
  try {
    lib.lend(rahim, b, 1);
    console.log(`day 1  Rahim  ${b.title.padEnd(9)} ok`);
  } catch (e) {
    console.log(`day 1  Rahim  ${b.title.padEnd(9)} refused: ${(e as Error).message}`);
  }
}
try {
  lib.lend(nadia, books[0]!, 2);
} catch (e) {
  console.log(`day 2  Nadia  ${books[0]!.title.padEnd(9)} refused: ${(e as Error).message}`);
}
const fine = lib.returnBook(books[0]!, 19); // due on day 15
console.log(`day 19 Rahim  returns ${books[0]!.title}, ${fine / FINE_PER_DAY} days late, fine ${fine} taka`);
lib.lend(nadia, books[3]!, 19);
console.log(`day 19 Nadia  ${books[3]!.title.padEnd(9)} ok (premium limit ${nadia.limit()})`);

const LOAN_DAYS: u32 = 14;
const FINE_PER_DAY: u32 = 5; // taka

// Each struct has one job, found from the nouns in the requirements.
// Books and members are referred to by index, so the Library can own them all.

struct Book { title: String, on_loan: bool }

struct Member { premium: bool, loans: u32 }

impl Member {
    // The borrowing limit lives with the member, so "premium gets 5" is a one-line change.
    fn limit(&self) -> u32 { if self.premium { 5 } else { 3 } }
}

struct Loan { book: usize, member: usize, due: u32 }

// The only place that decides who may borrow what.
struct Library { books: Vec<Book>, members: Vec<Member>, loans: Vec<Loan> }

impl Library {
    fn lend(&mut self, m: usize, b: usize, today: u32) -> Result<(), String> {
        if self.books[b].on_loan {
            return Err("already on loan".into());
        }
        let member = &mut self.members[m];
        if member.loans >= member.limit() {
            return Err(format!("limit reached ({})", member.limit()));
        }
        member.loans += 1;
        self.books[b].on_loan = true;
        self.loans.push(Loan { book: b, member: m, due: today + LOAN_DAYS });
        Ok(())
    }

    fn return_book(&mut self, b: usize, today: u32) -> Result<u32, String> {
        let i = self.loans.iter().position(|l| l.book == b).ok_or("not on loan")?;
        let loan = self.loans.remove(i);
        self.books[b].on_loan = false;
        self.members[loan.member].loans -= 1;
        Ok(today.saturating_sub(loan.due) * FINE_PER_DAY)
    }
}

fn main() {
    let titles = ["Himu", "Feluda", "Byomkesh", "Tintin"];
    let mut lib = Library {
        books: titles.iter().map(|t| Book { title: t.to_string(), on_loan: false }).collect(),
        members: vec![Member { premium: false, loans: 0 }, Member { premium: true, loans: 0 }],
        loans: vec![],
    };
    let (rahim, nadia) = (0, 1);

    for b in 0..titles.len() {
        match lib.lend(rahim, b, 1) {
            Ok(()) => println!("day 1  Rahim  {:<9} ok", titles[b]),
            Err(e) => println!("day 1  Rahim  {:<9} refused: {e}", titles[b]),
        }
    }
    if let Err(e) = lib.lend(nadia, 0, 2) {
        println!("day 2  Nadia  {:<9} refused: {e}", lib.books[0].title);
    }
    let fine = lib.return_book(0, 19).unwrap(); // due on day 15
    println!("day 19 Rahim  returns {}, {} days late, fine {fine} taka", lib.books[0].title, fine / FINE_PER_DAY);
    lib.lend(nadia, 3, 19).unwrap();
    println!("day 19 Nadia  {:<9} ok (premium limit {})", lib.books[3].title, lib.members[nadia].limit());
}

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

public class Library {
    static final int LOAN_DAYS = 14, FINE_PER_DAY = 5; // taka

    // Each class has one job, found from the nouns in the requirements.

    static final class Book {
        final String title;
        boolean onLoan;
        Book(String title) { this.title = title; }
    }

    static final class Member {
        final String name;
        final boolean premium;
        int loans;
        Member(String name, boolean premium) { this.name = name; this.premium = premium; }
        // The borrowing limit lives with the member, so "premium gets 5" is a one-line change.
        int limit() { return premium ? 5 : 3; }
    }

    record Loan(Book book, Member member, int due) {}

    static final class LendException extends Exception {
        private static final long serialVersionUID = 1L;
        LendException(String msg) { super(msg); }
    }

    // The only place that decides who may borrow what.
    private final List<Loan> loans = new ArrayList<>();

    void lend(Member m, Book b, int today) throws LendException {
        if (b.onLoan) throw new LendException("already on loan");
        if (m.loans >= m.limit()) throw new LendException("limit reached (" + m.limit() + ")");
        b.onLoan = true;
        m.loans++;
        loans.add(new Loan(b, m, today + LOAN_DAYS));
    }

    int returnBook(Book b, int today) throws LendException {
        for (Loan ln : loans) {
            if (ln.book() == b) {
                loans.remove(ln);
                b.onLoan = false;
                ln.member().loans--;
                return Math.max(0, today - ln.due()) * FINE_PER_DAY;
            }
        }
        throw new LendException("not on loan");
    }

    public static void main(String[] args) throws LendException {
        Library lib = new Library();
        Member rahim = new Member("Rahim", false), nadia = new Member("Nadia", true);
        List<Book> books = List.of(new Book("Himu"), new Book("Feluda"), new Book("Byomkesh"), new Book("Tintin"));

        for (Book b : books) {
            try {
                lib.lend(rahim, b, 1);
                System.out.printf("day 1  Rahim  %-9s ok%n", b.title);
            } catch (LendException e) {
                System.out.printf("day 1  Rahim  %-9s refused: %s%n", b.title, e.getMessage());
            }
        }
        try {
            lib.lend(nadia, books.get(0), 2);
        } catch (LendException e) {
            System.out.printf("day 2  Nadia  %-9s refused: %s%n", books.get(0).title, e.getMessage());
        }
        int fine = lib.returnBook(books.get(0), 19); // due on day 15
        System.out.printf("day 19 Rahim  returns %s, %d days late, fine %d taka%n", books.get(0).title, fine / FINE_PER_DAY, fine);
        lib.lend(nadia, books.get(3), 19);
        System.out.printf("day 19 Nadia  %-9s ok (premium limit %d)%n", books.get(3).title, nadia.limit());
    }
}

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

constexpr int kLoanDays = 14, kFinePerDay = 5;  // taka

// Each class has one job, found from the nouns in the requirements.

struct Book {
    std::string title;
    bool onLoan = false;
};

struct Member {
    std::string name;
    bool premium = false;
    int loans = 0;
    // The borrowing limit lives with the member, so "premium gets 5" is a one-line change.
    int limit() const { return premium ? 5 : 3; }
};

struct Loan {
    Book* book;
    Member* member;
    int due;  // day number
};

// The only place that decides who may borrow what.
class Library {
public:
    void lend(Member& m, Book& b, int today) {
        if (b.onLoan) throw std::runtime_error("already on loan");
        if (m.loans >= m.limit()) throw std::runtime_error("limit reached (" + std::to_string(m.limit()) + ")");
        b.onLoan = true;
        ++m.loans;
        loans_.push_back({&b, &m, today + kLoanDays});
    }

    int returnBook(Book& b, int today) {
        auto it = std::find_if(loans_.begin(), loans_.end(), [&](const Loan& l) { return l.book == &b; });
        if (it == loans_.end()) throw std::runtime_error("not on loan");
        Loan ln = *it;
        loans_.erase(it);
        b.onLoan = false;
        --ln.member->loans;
        return std::max(0, today - ln.due) * kFinePerDay;
    }

private:
    std::vector<Loan> loans_;
};

int main() {
    Library lib;
    Member rahim{"Rahim"}, nadia{"Nadia", true};
    std::vector<Book> books{{"Himu"}, {"Feluda"}, {"Byomkesh"}, {"Tintin"}};

    for (auto& b : books) {
        try {
            lib.lend(rahim, b, 1);
            std::printf("day 1  Rahim  %-9s ok\n", b.title.c_str());
        } catch (const std::exception& e) {
            std::printf("day 1  Rahim  %-9s refused: %s\n", b.title.c_str(), e.what());
        }
    }
    try {
        lib.lend(nadia, books[0], 2);
    } catch (const std::exception& e) {
        std::printf("day 2  Nadia  %-9s refused: %s\n", books[0].title.c_str(), e.what());
    }
    int fine = lib.returnBook(books[0], 19);  // due on day 15
    std::printf("day 19 Rahim  returns %s, %d days late, fine %d taka\n", books[0].title.c_str(), fine / kFinePerDay, fine);
    lib.lend(nadia, books[3], 19);
    std::printf("day 19 Nadia  %-9s ok (premium limit %d)\n", books[3].title.c_str(), nadia.limit());
}