Intermediate

import java.math.BigDecimal;                                          // => namespace/package import
import java.util.List;                                                // => namespace/package import
 
// ── supporting types ──────────────────────────────────────────────────────────
// These minimal types make the example self-contained; no external dependency needed
enum OrderStatus { PENDING, CONFIRMED, SHIPPED, CANCELLED }           // => enum OrderStatus
// => Four lifecycle states; only CONFIRMED orders are eligible for the discount rule
 
record OrderId(String value) {}                                       // => record OrderId
// => Strongly-typed ID; wraps String to prevent mixing with other IDs
record Money(BigDecimal amount, String currency) {}                   // => record Money
// => Value Object pair: amount is meaningless without its currency
 
class Order {                                                         // => class Order
    private final OrderId id;                                         // => id field
    // => private final: ID assigned once, never mutated
    private final Money total;                                        // => total field
    // => private final: total is immutable after construction
    private final OrderStatus status;                                 // => status field
    // => Immutable fields; Order only exposes getters — no public setters
 
    Order(OrderId id, Money total, OrderStatus status) {              // => Order() called
        this.id = id; this.total = total; this.status = status;       // => this.id assigned
        // => All three fields required; no partial construction
    }
    public Money getTotal()       { return total; }   // => Read-only accessor
    public OrderStatus getStatus(){ return status; }  // => Read-only accessor
}
 
// ── Specification interface ───────────────────────────────────────────────────
// A Specification encapsulates one cohesive business rule
// => Generic: works for any domain object type T
// => Single method makes this a functional interface; lambdas can implement it
interface Specification<T> {                                          // => interface Specification
    boolean isSatisfiedBy(T candidate); // => True = rule passes for this candidate
    // => False = candidate does not satisfy this rule
}
 
// ── Concrete specification: eligible for discount ────────────────────────────
// The rule "total >= 100 AND status is CONFIRMED" has a name the domain expert recognises
class EligibleForDiscountSpec implements Specification<Order> {       // => class EligibleForDiscountSpec
    private static final BigDecimal THRESHOLD = new BigDecimal("100.00"); // => THRESHOLD declared
    // => Business rule threshold defined as a named constant, not a magic literal
 
    @Override                                                         // => expression
    public boolean isSatisfiedBy(Order order) {                       // => isSatisfiedBy method
        boolean bigEnough = order.getTotal().amount().compareTo(THRESHOLD) >= 0; // => order.getTotal() called
        // => BigDecimal.compareTo: returns 0 if equal, negative if less, positive if greater
        // => >= 0 means amount equals or exceeds threshold
        boolean confirmed = order.getStatus() == OrderStatus.CONFIRMED; // => order.getStatus() called
        // => Only confirmed orders are eligible; pending orders have not yet committed
        return bigEnough && confirmed;                                // => returns bigEnough && confirmed
        // => Both conditions must hold; short-circuits if bigEnough is false
    }
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
var spec  = new EligibleForDiscountSpec();                            // => spec initialised
// => spec is stateless; safe to share or re-use across calls
var order = new Order(new OrderId("O1"),                              // => order initialised
                      new Money(new BigDecimal("120.00"), "USD"),     // => expression
                      OrderStatus.CONFIRMED);                         // => expression
// => order: 120 USD, CONFIRMED — satisfies both conditions
 
boolean eligible = spec.isSatisfiedBy(order);                         // => spec.isSatisfiedBy() called
// => true: 120 >= 100 and status is CONFIRMED
 
var smallOrder = new Order(new OrderId("O2"),                         // => smallOrder initialised
                           new Money(new BigDecimal("50.00"), "USD"), // => expression
                           OrderStatus.CONFIRMED);                    // => expression
// => smallOrder: 50 USD, CONFIRMED — fails the threshold condition
boolean notEligible = spec.isSatisfiedBy(smallOrder);                 // => spec.isSatisfiedBy() called
// => false: 50 < 100, so bigEnough is false
 
// Filter a list using the specification
List<Order> orders = List.of(order, smallOrder);                      // => List.of() called
// => Both orders in the list
List<Order> discountable = orders.stream()                            // => orders.stream() called
    .filter(spec::isSatisfiedBy)  // => Method reference: passes order to isSatisfiedBy
    .toList();                    // => [order] — only the 120 USD confirmed order qualifies
// => smallOrder excluded because it failed the threshold

import java.math.BigDecimal                                           // => namespace/package import
 
// ── supporting types ──────────────────────────────────────────────────────────
enum class OrderStatus { PENDING, CONFIRMED, SHIPPED, CANCELLED }     // => enum class
data class OrderId(val value: String)                                 // => class OrderId
data class Money(val amount: BigDecimal, val currency: String)        // => class Money
 
data class Order(val id: OrderId, val total: Money, val status: OrderStatus) // => class Order
 
// ── Specification as functional interface ─────────────────────────────────────
// Kotlin: fun interface allows SAM conversion — lambda can stand in for Specification
fun interface Specification<T> {                                      // => interface Specification
    fun isSatisfiedBy(candidate: T): Boolean // => Single abstract method
}
 
// ── Concrete specification ─────────────────────────────────────────────────────
class EligibleForDiscountSpec : Specification<Order> {                // => class EligibleForDiscountSpec
    private val threshold = BigDecimal("100.00")                      // => threshold declared
    // => Rule lives here; no scattering across service methods
 
    override fun isSatisfiedBy(candidate: Order): Boolean {           // => isSatisfiedBy method
        val bigEnough  = candidate.total.amount >= threshold // => Kotlin operator overload on BigDecimal
        val confirmed  = candidate.status == OrderStatus.CONFIRMED    // => confirmed initialised
        return bigEnough && confirmed // => Both conditions required
    }
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
val spec      = EligibleForDiscountSpec()                             // => spec initialised
val confirmed = Order(OrderId("O1"), Money(BigDecimal("120.00"), "USD"), OrderStatus.CONFIRMED) // => confirmed initialised
val small     = Order(OrderId("O2"), Money(BigDecimal("50.00"),  "USD"), OrderStatus.CONFIRMED) // => small initialised
 
val eligible    = spec.isSatisfiedBy(confirmed) // => true
val notEligible = spec.isSatisfiedBy(small)     // => false
 
val orders = listOf(confirmed, small)                                 // => orders initialised
val discountable = orders.filter(spec::isSatisfiedBy) // => [confirmed]
// => Kotlin filter accepts any (Order) -> Boolean; method reference works directly

using System;                                                         // => namespace/package import
using System.Collections.Generic;                                     // => namespace/package import
using System.Linq;                                                    // => namespace/package import
 
// ── supporting types ──────────────────────────────────────────────────────────
public enum OrderStatus { Pending, Confirmed, Shipped, Cancelled }    // => OrderStatus field
public record OrderId(string Value);                                  // => record OrderId
public record Money(decimal Amount, string Currency);                 // => record Money
public record Order(OrderId Id, Money Total, OrderStatus Status);     // => record Order
 
// ── Specification interface ────────────────────────────────────────────────────
// C# uses generic interface; lambda or class can implement
public interface ISpecification<T>                                    // => interface ISpecification
{
    bool IsSatisfiedBy(T candidate); // => Returns true when candidate meets the rule
}
 
// ── Concrete specification ─────────────────────────────────────────────────────
public class EligibleForDiscountSpec : ISpecification<Order>          // => class EligibleForDiscountSpec
{
    private const decimal Threshold = 100m;                           // => Threshold declared
    // => Business rule centralised; easy to unit-test in isolation
 
    public bool IsSatisfiedBy(Order order)                            // => IsSatisfiedBy method
    {
        bool bigEnough = order.Total.Amount >= Threshold; // => >= 100 USD
        bool confirmed = order.Status == OrderStatus.Confirmed;       // => expression
        return bigEnough && confirmed; // => Both must hold
    }
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
var spec      = new EligibleForDiscountSpec();                        // => spec initialised
var confirmed = new Order(new OrderId("O1"), new Money(120m, "USD"), OrderStatus.Confirmed); // => confirmed initialised
var small     = new Order(new OrderId("O2"), new Money(50m,  "USD"), OrderStatus.Confirmed); // => small initialised
 
bool eligible    = spec.IsSatisfiedBy(confirmed); // => true
bool notEligible = spec.IsSatisfiedBy(small);     // => false
 
var orders = new List<Order> { confirmed, small };                    // => orders initialised
var discountable = orders.Where(spec.IsSatisfiedBy).ToList(); // => [confirmed]
// => LINQ Where accepts Func<Order,bool>; IsSatisfiedBy matches the signature

import java.math.BigDecimal;                                          // => namespace/package import
 
// ── Reuse types from Example 26 ───────────────────────────────────────────────
enum OrderStatus { PENDING, CONFIRMED }                               // => enum OrderStatus
// => Only two states needed here; composite spec applies to confirmed orders
record Money(BigDecimal amount, String currency) {}                   // => record Money
record Order(Money total, OrderStatus status, boolean customerActive) {} // => record Order
// => customerActive: true when the customer account is in good standing
 
interface Specification<T> {                                          // => interface Specification
    boolean isSatisfiedBy(T t);                                       // => expression
    // => Core method: evaluate the rule for one candidate
 
    // Default methods provide composability without subclassing
    // => Default methods added to the interface; existing implementations unchanged
    default Specification<T> and(Specification<T> other) {            // => expression
        return t -> this.isSatisfiedBy(t) && other.isSatisfiedBy(t);  // => returns t -> this.isSatisfiedBy(t) && 
        // => Returns new spec: both this AND other must be satisfied
        // => Lambda captures both specs; evaluated lazily per candidate
    }
 
    default Specification<T> or(Specification<T> other) {             // => expression
        return t -> this.isSatisfiedBy(t) || other.isSatisfiedBy(t);  // => returns t -> this.isSatisfiedBy(t) || 
        // => Returns new spec: at least one must be satisfied (short-circuits)
    }
 
    default Specification<T> not() {                                  // => expression
        return t -> !this.isSatisfiedBy(t);                           // => returns t -> !this.isSatisfiedBy(t)
        // => Returns new spec: negation of this spec; inverts every result
    }
}
 
// ── Two simple specs composed into a complex rule ────────────────────────────
// Each leaf spec is a focused lambda; single responsibility
Specification<Order> bigOrder   = o -> o.total().amount().compareTo(new BigDecimal("100")) >= 0; // => o.total() called
// => Lambda implements Specification<Order>; true when total >= 100
Specification<Order> confirmed  = o -> o.status() == OrderStatus.CONFIRMED; // => o.status() called
// => True when order has progressed past PENDING to CONFIRMED
Specification<Order> activeCustomer = o -> o.customerActive();        // => o.customerActive() called
// => True when the customer's account is active (not suspended or banned)
 
// Compose: eligible = bigOrder AND confirmed AND activeCustomer
// => and() chains return new Specification instances; originals unchanged
Specification<Order> eligible = bigOrder.and(confirmed).and(activeCustomer); // => bigOrder.and() called
// => Three independent rules chained; each testable in isolation
 
var orderA = new Order(new Money(new BigDecimal("120"), "USD"), OrderStatus.CONFIRMED, true); // => orderA initialised
// => orderA: 120 USD, CONFIRMED, active — should satisfy all three rules
var orderB = new Order(new Money(new BigDecimal("120"), "USD"), OrderStatus.CONFIRMED, false); // => orderB initialised
// => orderB: 120 USD, CONFIRMED, INACTIVE — should fail activeCustomer
 
boolean aOk = eligible.isSatisfiedBy(orderA); // => true (all three pass)
boolean bOk = eligible.isSatisfiedBy(orderB); // => false (activeCustomer fails for orderB)
 
// NOT example: flip the eligible spec to get the ineligible spec
Specification<Order> ineligible = eligible.not();                     // => eligible.not() called
// => ineligible = NOT(bigOrder AND confirmed AND activeCustomer)
boolean bIneligible = ineligible.isSatisfiedBy(orderB); // => true (orderB IS ineligible)

import java.math.BigDecimal                                           // => namespace/package import
 
enum class OrderStatus { PENDING, CONFIRMED }                         // => enum class
data class Money(val amount: BigDecimal, val currency: String)        // => class Money
data class Order(val total: Money, val status: OrderStatus, val customerActive: Boolean) // => class Order
 
// Kotlin: fun interface + extension functions for composability
fun interface Specification<T> {                                      // => interface Specification
    fun isSatisfiedBy(t: T): Boolean                                  // => isSatisfiedBy method
}
 
// Extension functions compose specs without modifying the interface
infix fun <T> Specification<T>.and(other: Specification<T>): Specification<T> = // => expression
    Specification { isSatisfiedBy(it) && other.isSatisfiedBy(it) }    // => other.isSatisfiedBy() called
// => infix: readable as  bigOrder and confirmed
 
infix fun <T> Specification<T>.or(other: Specification<T>): Specification<T> = // => expression
    Specification { isSatisfiedBy(it) || other.isSatisfiedBy(it) }    // => other.isSatisfiedBy() called
 
fun <T> Specification<T>.not(): Specification<T> =                    // => expression
    Specification { !isSatisfiedBy(it) }                              // => expression
 
// ── Usage ─────────────────────────────────────────────────────────────────────
val bigOrder       = Specification<Order> { it.total.amount >= BigDecimal("100") } // => bigOrder initialised
val confirmed      = Specification<Order> { it.status == OrderStatus.CONFIRMED } // => confirmed initialised
val activeCustomer = Specification<Order> { it.customerActive }       // => activeCustomer initialised
 
val eligible = bigOrder and confirmed and activeCustomer              // => eligible initialised
// => Infix 'and': reads naturally as English
 
val orderA = Order(Money(BigDecimal("120"), "USD"), OrderStatus.CONFIRMED, customerActive = true) // => orderA initialised
val orderB = Order(Money(BigDecimal("120"), "USD"), OrderStatus.CONFIRMED, customerActive = false) // => orderB initialised
 
val aOk = eligible.isSatisfiedBy(orderA) // => true
val bOk = eligible.isSatisfiedBy(orderB) // => false (activeCustomer fails)
 
val ineligible = eligible.not()                                       // => ineligible initialised
val bIneligible = ineligible.isSatisfiedBy(orderB) // => true

using System;                                                         // => namespace/package import
 
public enum OrderStatus { Pending, Confirmed }                        // => OrderStatus field
public record Money(decimal Amount, string Currency);                 // => record Money
public record Order(Money Total, OrderStatus Status, bool CustomerActive); // => record Order
 
public interface ISpecification<T>                                    // => interface ISpecification
{
    bool IsSatisfiedBy(T t);                                          // => expression
 
    // Default interface methods provide combinators (C# 8+)
    ISpecification<T> And(ISpecification<T> other) =>                 // => expression
        new LambdaSpec<T>(t => IsSatisfiedBy(t) && other.IsSatisfiedBy(t)); // => other.IsSatisfiedBy() called
    // => Creates anonymous spec: both must hold
 
    ISpecification<T> Or(ISpecification<T> other) =>                  // => expression
        new LambdaSpec<T>(t => IsSatisfiedBy(t) || other.IsSatisfiedBy(t)); // => other.IsSatisfiedBy() called
 
    ISpecification<T> Not() =>                                        // => expression
        new LambdaSpec<T>(t => !IsSatisfiedBy(t));                    // => expression
}
 
// Helper: wraps a lambda as an ISpecification
public class LambdaSpec<T>(Func<T, bool> predicate) : ISpecification<T> // => class LambdaSpec
{
    // => Primary constructor (C# 12): field 'predicate' injected automatically
    public bool IsSatisfiedBy(T t) => predicate(t);                   // => IsSatisfiedBy method
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
ISpecification<Order> bigOrder       = new LambdaSpec<Order>(o => o.Total.Amount >= 100m); // => expression
ISpecification<Order> confirmed      = new LambdaSpec<Order>(o => o.Status == OrderStatus.Confirmed); // => expression
ISpecification<Order> activeCustomer = new LambdaSpec<Order>(o => o.CustomerActive); // => expression
 
var eligible = bigOrder.And(confirmed).And(activeCustomer);           // => eligible initialised
// => Three specs chained; each independently testable
 
var orderA = new Order(new Money(120m, "USD"), OrderStatus.Confirmed, CustomerActive: true); // => orderA initialised
var orderB = new Order(new Money(120m, "USD"), OrderStatus.Confirmed, CustomerActive: false); // => orderB initialised
 
bool aOk = eligible.IsSatisfiedBy(orderA); // => true
bool bOk = eligible.IsSatisfiedBy(orderB); // => false
 
var ineligible = eligible.Not();                                      // => ineligible initialised
bool bIneligible = ineligible.IsSatisfiedBy(orderB); // => true

import java.math.BigDecimal;                                          // => namespace/package import
import java.time.Instant;                                             // => namespace/package import
import java.util.*;                                                   // => namespace/package import
 
// ── Supporting types ──────────────────────────────────────────────────────────
enum OrderStatus { PENDING }                                          // => enum OrderStatus
record OrderId(String value)      { static OrderId generate() { return new OrderId(UUID.randomUUID().toString()); } } // => record OrderId
record CustomerId(String value)   {}                                  // => record CustomerId
record ProductId(String value)    {}                                  // => record ProductId
record Money(BigDecimal amount, String currency) {}                   // => record Money
 
interface DomainEvent {}                                              // => interface DomainEvent
record OrderCreated(OrderId orderId, CustomerId customerId, Instant occurredAt) implements DomainEvent {} // => record OrderCreated
 
// ── Aggregate ─────────────────────────────────────────────────────────────────
public class Order {                                                  // => Order field
    private final OrderId id;                                         // => id field
    private final CustomerId customerId;                              // => customerId field
    private final List<ProductId> lineItems;                          // => expression
    private OrderStatus status;                                       // => status field
    private final List<DomainEvent> events = new ArrayList<>();       // => List method
    // => Private constructor: external callers cannot bypass the factory
 
    private Order(OrderId id, CustomerId customerId, List<ProductId> lineItems) { // => Order method
        this.id = id;                                                 // => this.id assigned
        this.customerId = customerId;                                 // => this.customerId assigned
        this.lineItems  = List.copyOf(lineItems); // => Defensive copy; caller cannot mutate
        this.status     = OrderStatus.PENDING;                        // => this.status assigned
    }
 
    // ── Static factory method ─────────────────────────────────────────────────
    // Named factory makes intent explicit; validates, assembles, and records creation event
    public static Order create(CustomerId customerId, List<ProductId> items) { // => create method
        if (customerId == null) throw new IllegalArgumentException("CustomerId required"); // => throws if guard fails
        if (items == null || items.isEmpty()) throw new IllegalArgumentException("At least one item required"); // => throws if guard fails
        // => Business rule: an order must have items to exist
 
        OrderId newId = OrderId.generate();          // => Generate identity inside factory
        Order order = new Order(newId, customerId, items); // => Private ctor
        order.events.add(new OrderCreated(newId, customerId, Instant.now())); // => events.add() called
        // => Creation event registered inside factory; caller never needs to do this
        return order; // => Returns fully initialised, valid aggregate
    }
 
    public OrderId getId()               { return id; }               // => getId method
    public List<DomainEvent> getEvents() { return List.copyOf(events); } // => getEvents method
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
var order = Order.create(                                             // => order initialised
    new CustomerId("C1"),                                             // => expression
    List.of(new ProductId("P1"), new ProductId("P2"))                 // => List.of() called
); // => order.id is a UUID; order.events has [OrderCreated]
 
// Order invalid = new Order(...); // => compile error — constructor is private

import java.time.Instant                                              // => namespace/package import
import java.util.UUID                                                 // => namespace/package import
 
enum class OrderStatus { PENDING }                                    // => enum class
data class OrderId(val value: String) { companion object { fun generate() = OrderId(UUID.randomUUID().toString()) } } // => class OrderId
data class CustomerId(val value: String)                              // => class CustomerId
data class ProductId(val value: String)                               // => class ProductId
 
interface DomainEvent                                                 // => interface DomainEvent
data class OrderCreated(val orderId: OrderId, val customerId: CustomerId, val occurredAt: Instant) : DomainEvent // => class OrderCreated
 
class Order private constructor( // => private: only companion object can call
    val id: OrderId,                                                  // => expression
    val customerId: CustomerId,                                       // => expression
    val lineItems: List<ProductId>,                                   // => expression
) {                                                                   // => expression
    var status: OrderStatus = OrderStatus.PENDING                     // => expression
        private set                                                   // => expression
 
    private val _events = mutableListOf<DomainEvent>()                // => events declared
    val events: List<DomainEvent> get() = _events.toList() // => Snapshot; caller cannot mutate
 
    companion object {                                                // => expression
        // Named factory: validates, constructs, registers creation event
        fun create(customerId: CustomerId, items: List<ProductId>): Order { // => create method
            require(items.isNotEmpty()) { "At least one item required" } // => precondition check
            // => Domain rule enforced before object exists
            val id    = OrderId.generate()                            // => id initialised
            val order = Order(id, customerId, items)                  // => order initialised
            order._events.add(OrderCreated(id, customerId, Instant.now())) // => _events.add() called
            // => Creation event recorded; app service will publish after save
            return order                                              // => returns order
        }
    }
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
val order = Order.create(                                             // => order initialised
    customerId = CustomerId("C1"),                                    // => customerId assigned
    items      = listOf(ProductId("P1"), ProductId("P2"))             // => items assigned
) // => order.id is UUID; order.events = [OrderCreated(...)]
// Order(...) cannot be called directly — constructor is private

using System;                                                         // => namespace/package import
using System.Collections.Generic;                                     // => namespace/package import
 
public enum OrderStatus { Pending }                                   // => OrderStatus field
public record OrderId(string Value) { public static OrderId Generate() => new(Guid.NewGuid().ToString()); } // => record OrderId
public record CustomerId(string Value);                               // => record CustomerId
public record ProductId(string Value);                                // => record ProductId
 
public interface IDomainEvent {}                                      // => IDomainEvent field
public record OrderCreated(OrderId OrderId, CustomerId CustomerId, DateTimeOffset OccurredAt) : IDomainEvent; // => record OrderCreated
 
public class Order                                                    // => class Order
// => begins block
{
    public  OrderId           Id         { get; }                     // => Id field
    public  CustomerId        CustomerId { get; }                     // => CustomerId field
    public  IReadOnlyList<ProductId> LineItems { get; }               // => expression
    public  OrderStatus       Status     { get; private set; } = OrderStatus.Pending; // => Status field
 
    private readonly List<IDomainEvent> _events = new();              // => List method
    public  IReadOnlyList<IDomainEvent> Events => _events.AsReadOnly(); // => IReadOnlyList method
 
    private Order(OrderId id, CustomerId customerId, List<ProductId> lineItems) // => Order method
    // => begins block
    {
        // => private: callers must use Create factory
        Id         = id;                                              // => Id assigned
        CustomerId = customerId;                                      // => CustomerId assigned
        LineItems  = lineItems.AsReadOnly(); // => Defensive immutable view
    }
 
    // ── Static factory ────────────────────────────────────────────────────────
    public static Order Create(CustomerId customerId, List<ProductId> items) // => Create method
    {
        if (items == null || items.Count == 0)                        // => precondition check
            throw new ArgumentException("At least one item required"); // => throws if guard fails
        var id    = OrderId.Generate();                               // => id initialised
        var order = new Order(id, customerId, items); // => Private ctor
        order._events.Add(new OrderCreated(id, customerId, DateTimeOffset.UtcNow)); // => _events.Add() called
        // => Creation event; app service publishes after persistence
        return order;                                                 // => returns order
    }
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
var order = Order.Create(                                             // => order initialised
    new CustomerId("C1"),                                             // => expression
    new List<ProductId> { new("P1"), new("P2") }                      // => expression
); // => order.Id = GUID; order.Events = [OrderCreated]

import java.math.BigDecimal;                                          // => namespace/package import
import java.util.*;                                                   // => namespace/package import
 
// ── Supporting types ──────────────────────────────────────────────────────────
record OrderId(String value)    { static OrderId generate() { return new OrderId(UUID.randomUUID().toString()); } } // => record OrderId
record CustomerId(String value) {}                                    // => record CustomerId
record Money(BigDecimal amount, String currency) {}                   // => record Money
enum Priority { STANDARD, EXPRESS }                                   // => enum Priority
 
// ── Aggregate with optional fields ───────────────────────────────────────────
public class Order {                                                  // => Order field
    private final OrderId   id;                                       // => id field
    private final CustomerId customerId;                              // => customerId field
    private final Money      total;                                   // => total field
    private final Priority   priority;         // => Optional; default STANDARD
    private final String     deliveryNote;     // => Optional; may be null
 
    private Order(OrderId id, CustomerId customerId, Money total,     // => Order method
                  Priority priority, String deliveryNote) {           // => expression
        this.id           = id;                                       // => this.id assigned
        this.customerId   = customerId;                               // => this.customerId assigned
        this.total        = total;                                    // => this.total assigned
        this.priority     = priority;                                 // => this.priority assigned
        this.deliveryNote = deliveryNote;                             // => this.deliveryNote assigned
    }
 
    // ── Inner Builder ─────────────────────────────────────────────────────────
    public static class Builder {                                     // => Builder field
        private CustomerId customerId; // => Required; validated in build()
        private Money      total;      // => Required
        private Priority   priority   = Priority.STANDARD; // => Optional; sensible default
        private String     deliveryNote;                    // => Optional; null allowed
 
        public Builder customerId(CustomerId id)     { this.customerId = id;   return this; } // => customerId method
        public Builder total(Money t)                { this.total = t;         return this; } // => total method
        public Builder priority(Priority p)          { this.priority = p;      return this; } // => priority method
        public Builder deliveryNote(String note)     { this.deliveryNote = note; return this; } // => deliveryNote method
        // => Fluent setters return 'this' for method chaining
 
        public Order build() {                                        // => build method
            // => All validations in one place; no partial Order escapes
            if (customerId == null) throw new IllegalStateException("customerId required"); // => throws if guard fails
            if (total == null)      throw new IllegalStateException("total required"); // => throws if guard fails
            return new Order(OrderId.generate(), customerId, total, priority, deliveryNote); // => returns new Order(OrderId.generate(), 
        }
    }
 
    public static Builder builder() { return new Builder(); } // => Entry point
    public OrderId getId()          { return id; }                    // => getId method
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
Order express = Order.builder()                                       // => Order.builder() called
    .customerId(new CustomerId("C1"))                                 // => expression
    .total(new Money(new BigDecimal("200"), "USD"))                   // => expression
    .priority(Priority.EXPRESS)                                       // => expression
    .deliveryNote("Leave at door")                                    // => expression
    .build();                                                         // => expression
// => express.priority = EXPRESS, deliveryNote = "Leave at door"
 
Order standard = Order.builder()                                      // => Order.builder() called
    .customerId(new CustomerId("C2"))                                 // => expression
    .total(new Money(new BigDecimal("50"), "USD"))                    // => expression
    .build();                                                         // => expression
// => standard.priority = STANDARD, deliveryNote = null (optional not set)

import java.math.BigDecimal                                           // => namespace/package import
import java.util.UUID                                                 // => namespace/package import
 
data class OrderId(val value: String) { companion object { fun generate() = OrderId(UUID.randomUUID().toString()) } } // => class OrderId
data class CustomerId(val value: String)                              // => class CustomerId
data class Money(val amount: BigDecimal, val currency: String)        // => class Money
enum class Priority { STANDARD, EXPRESS }                             // => enum class
 
// Kotlin: data class with default parameters often replaces Builder
// => But a Builder is still useful when construction validation spans multiple fields
data class Order private constructor(                                 // => class Order
    val id:           OrderId,                                        // => expression
    val customerId:   CustomerId,                                     // => expression
    val total:        Money,                                          // => expression
    val priority:     Priority = Priority.STANDARD,                   // => expression
    val deliveryNote: String?  = null  // => Nullable optional field
) {                                                                   // => expression
    class Builder {                                                   // => class Builder
        private var customerId:   CustomerId? = null                  // => expression
        private var total:        Money?      = null                  // => expression
        private var priority:     Priority    = Priority.STANDARD     // => expression
        private var deliveryNote: String?     = null                  // => expression
 
        fun customerId(id: CustomerId)   = apply { customerId = id }  // => customerId method
        fun total(t: Money)              = apply { total = t }        // => total method
        fun priority(p: Priority)        = apply { priority = p }     // => priority method
        fun deliveryNote(note: String?)  = apply { deliveryNote = note } // => deliveryNote method
        // => apply{} returns 'this'; enables fluent chaining
 
        fun build(): Order {                                          // => build method
            val cid = requireNotNull(customerId) { "customerId required" } // => cid initialised
            val tot = requireNotNull(total)       { "total required" } // => tot initialised
            return Order(OrderId.generate(), cid, tot, priority, deliveryNote) // => returns Order(OrderId.generate(), cid,
            // => Constructs via private constructor; validation done above
        }
    }
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
val express = Order.Builder()                                         // => express initialised
    .customerId(CustomerId("C1"))                                     // => expression
    .total(Money(BigDecimal("200"), "USD"))                           // => expression
    .priority(Priority.EXPRESS)                                       // => expression
    .deliveryNote("Leave at door")                                    // => expression
    .build()                                                          // => expression
// => Order(id=UUID, customerId=C1, total=200 USD, priority=EXPRESS, deliveryNote=Leave at door)
 
val standard = Order.Builder()                                        // => standard initialised
    .customerId(CustomerId("C2"))                                     // => expression
    .total(Money(BigDecimal("50"), "USD"))                            // => expression
    .build()                                                          // => expression
// => priority=STANDARD, deliveryNote=null

using System;                                                         // => namespace/package import
 
public record OrderId(string Value) { public static OrderId Generate() => new(Guid.NewGuid().ToString()); } // => record OrderId
public record CustomerId(string Value);                               // => record CustomerId
public record Money(decimal Amount, string Currency);                 // => record Money
public enum Priority { Standard, Express }                            // => Priority field
 
// C# record with init properties: the record itself acts as a builder target
// For complex validation, a dedicated Builder class keeps the aggregate immutable
public class Order                                                    // => class Order
// => begins block
{
    public OrderId    Id           { get; }                           // => Id field
    public CustomerId CustomerId  { get; }                            // => CustomerId field
    public Money      Total        { get; }                           // => Total field
    public Priority   Priority     { get; }                           // => Priority field
    public string?    DeliveryNote { get; }  // => Nullable; optional
 
    private Order(OrderId id, CustomerId customerId, Money total,     // => Order method
                  Priority priority, string? deliveryNote)            // => expression
    {
        Id = id; CustomerId = customerId; Total = total;              // => Id assigned
        Priority = priority; DeliveryNote = deliveryNote;             // => Priority assigned
    }
 
    // ── Builder ───────────────────────────────────────────────────────────────
    public class Builder                                              // => class Builder
    {
        private CustomerId? _customerId;                              // => expression
        private Money?      _total;                                   // => expression
        private Priority    _priority    = Priority.Standard; // => Default
        private string?     _deliveryNote;                            // => expression
 
        public Builder WithCustomerId(CustomerId id)    { _customerId = id;    return this; } // => WithCustomerId method
        public Builder WithTotal(Money t)               { _total = t;          return this; } // => WithTotal method
        public Builder WithPriority(Priority p)         { _priority = p;       return this; } // => WithPriority method
        public Builder WithDeliveryNote(string? note)   { _deliveryNote = note; return this; } // => WithDeliveryNote method
        // => Fluent; each setter returns 'this'
 
        public Order Build()                                          // => Build method
        {
            if (_customerId is null) throw new InvalidOperationException("CustomerId required"); // => throws if guard fails
            if (_total      is null) throw new InvalidOperationException("Total required"); // => throws if guard fails
            return new Order(OrderId.Generate(), _customerId, _total, _priority, _deliveryNote); // => returns new Order(OrderId.Generate(), 
        }
    }
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
var express = new Order.Builder()                                     // => express initialised
    .WithCustomerId(new CustomerId("C1"))                             // => expression
    .WithTotal(new Money(200m, "USD"))                                // => expression
    .WithPriority(Priority.Express)                                   // => expression
    .WithDeliveryNote("Leave at door")                                // => expression
    .Build();                                                         // => expression
// => express.Priority = Express, DeliveryNote = "Leave at door"
 
var standard = new Order.Builder()                                    // => standard initialised
    .WithCustomerId(new CustomerId("C2"))                             // => expression
    .WithTotal(new Money(50m, "USD"))                                 // => expression
    .Build();                                                         // => expression
// => standard.Priority = Standard, DeliveryNote = null

import java.util.*;                                                   // => namespace/package import
 
// ── Supporting types ──────────────────────────────────────────────────────────
record OrderId(String value) {}                                       // => record OrderId
record CustomerId(String value) {}                                    // => record CustomerId
enum OrderStatus { PENDING, CONFIRMED, SHIPPED }                      // => enum OrderStatus
record Order(OrderId id, CustomerId customerId, OrderStatus status) {} // => record Order
 
// ── Repository interface: domain-language queries ─────────────────────────────
interface OrderRepository {                                           // => interface OrderRepository
    // Finder methods named from the domain perspective, not the database perspective
    Optional<Order> findById(OrderId id);                             // => expression
    // => "find" prefix: may or may not exist — returns Optional
 
    List<Order> findByCustomerId(CustomerId customerId);              // => expression
    // => "findBy": returns all orders for a customer; empty list if none
 
    List<Order> findByStatus(OrderStatus status);                     // => expression
    // => Returns all orders in a given status; useful for fulfilment workflows
 
    List<Order> findPendingOlderThanDays(int days);                   // => expression
    // => Named domain query: "which pending orders are stale?"
 
    void save(Order order);   // => Insert or update (upsert semantics)
    void delete(OrderId id);  // => Remove from repository
}
 
// ── In-memory implementation (for tests / demos) ──────────────────────────────
class InMemoryOrderRepository implements OrderRepository {            // => class InMemoryOrderRepository
    private final Map<String, Order> store = new HashMap<>();         // => Map method
    // => Keyed by OrderId value for O(1) lookup
 
    @Override public Optional<Order> findById(OrderId id) {           // => expression
        return Optional.ofNullable(store.get(id.value())); // => Absent = Optional.empty
    }
 
    @Override public List<Order> findByCustomerId(CustomerId cid) {   // => expression
        return store.values().stream()                                // => returns store.values().stream()
            .filter(o -> o.customerId().equals(cid)) // => Linear scan; acceptable in-memory
            .toList();                                                // => expression
    }
 
    @Override public List<Order> findByStatus(OrderStatus s) {        // => expression
        return store.values().stream().filter(o -> o.status() == s).toList(); // => returns store.values().stream().filter
    }
 
    @Override public List<Order> findPendingOlderThanDays(int days) { // => expression
        // => Real impl would compare timestamps; simplified here
        return store.values().stream()                                // => returns store.values().stream()
            .filter(o -> o.status() == OrderStatus.PENDING).toList(); // => o.status() called
    }
 
    @Override public void save(Order o)   { store.put(o.id().value(), o); } // => store.put() called
    @Override public void delete(OrderId id) { store.remove(id.value()); } // => store.remove() called
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
var repo  = new InMemoryOrderRepository();                            // => repo initialised
var order = new Order(new OrderId("O1"), new CustomerId("C1"), OrderStatus.PENDING); // => order initialised
repo.save(order);  // => Stored
 
Optional<Order> found = repo.findById(new OrderId("O1")); // => Optional[Order]
List<Order>     byCustomer = repo.findByCustomerId(new CustomerId("C1")); // => [order]
List<Order>     pending    = repo.findByStatus(OrderStatus.PENDING);      // => [order]

// ── Kotlin repository interface ───────────────────────────────────────────────
data class OrderId(val value: String)                                 // => class OrderId
data class CustomerId(val value: String)                              // => class CustomerId
enum class OrderStatus { PENDING, CONFIRMED, SHIPPED }                // => enum class
data class Order(val id: OrderId, val customerId: CustomerId, val status: OrderStatus) // => class Order
 
interface OrderRepository {                                           // => interface OrderRepository
    fun findById(id: OrderId): Order?             // => Kotlin nullable: null = not found
    fun findByCustomerId(cid: CustomerId): List<Order>                // => findByCustomerId method
    fun findByStatus(status: OrderStatus): List<Order>                // => findByStatus method
    fun findPendingOlderThanDays(days: Int): List<Order>              // => findPendingOlderThanDays method
    fun save(order: Order)                                            // => save method
    fun delete(id: OrderId)                                           // => delete method
}
 
// ── In-memory implementation ──────────────────────────────────────────────────
class InMemoryOrderRepository : OrderRepository {                     // => class InMemoryOrderRepository
    private val store = mutableMapOf<String, Order>()                 // => store declared
 
    override fun findById(id: OrderId)           = store[id.value]    // => findById method
    // => Nullable return: map returns null when key absent
 
    override fun findByCustomerId(cid: CustomerId) =                  // => findByCustomerId method
        store.values.filter { it.customerId == cid } // => Returns empty list if none
 
    override fun findByStatus(status: OrderStatus) =                  // => findByStatus method
        store.values.filter { it.status == status }                   // => expression
 
    override fun findPendingOlderThanDays(days: Int) =                // => findPendingOlderThanDays method
        store.values.filter { it.status == OrderStatus.PENDING }      // => expression
    // => Simplified; real impl would use timestamps
 
    override fun save(order: Order)  { store[order.id.value] = order } // => save method
    override fun delete(id: OrderId) { store.remove(id.value) }       // => delete method
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
val repo  = InMemoryOrderRepository()                                 // => repo initialised
val order = Order(OrderId("O1"), CustomerId("C1"), OrderStatus.PENDING) // => order initialised
repo.save(order)                                                      // => repo.save() called
 
val found      = repo.findById(OrderId("O1"))          // => Order? (non-null here)
val byCustomer = repo.findByCustomerId(CustomerId("C1")) // => [order]
val pending    = repo.findByStatus(OrderStatus.PENDING)  // => [order]

using System.Collections.Generic;  // => Dictionary, List, IEnumerable
 
public record OrderId(string Value);                                  // => record OrderId
// => Typed id; wraps string; prevents mixing OrderId with CustomerId
public record CustomerId(string Value);                               // => record CustomerId
// => Typed customer id; structural equality via record
public enum OrderStatus { Pending, Confirmed, Shipped }               // => OrderStatus field
// => Three lifecycle states; interface methods filter by each state
public record Order(OrderId Id, CustomerId CustomerId, OrderStatus Status); // => record Order
// => Immutable order record; three fields capturing identity, owner, and lifecycle
 
public interface IOrderRepository                                     // => interface IOrderRepository
// => Domain-language interface; declares what domain needs from persistence
{
    Order?        FindById(OrderId id);              // => Nullable: null = not found
    // => Nullable return: caller must handle "not found" case explicitly (no exception)
    List<Order>   FindByCustomerId(CustomerId id);                    // => expression
    // => Returns all orders for this customer; empty list if none
    List<Order>   FindByStatus(OrderStatus status);                   // => expression
    // => Returns all orders in this status; production uses DB index on status column
    List<Order>   FindPendingOlderThanDays(int days);                 // => expression
    // => Business query: "stale" pending orders need follow-up; expressed in domain vocabulary
    void          Save(Order order);                                  // => expression
    // => Upsert: inserts new id or replaces existing id
    void          Delete(OrderId id);                                 // => expression
    // => Removes order; no-op if id not found (idempotent)
}
 
public class InMemoryOrderRepository : IOrderRepository               // => class InMemoryOrderRepository
// => In-memory implementation for tests and demos; not for production
{
    private readonly Dictionary<string, Order> _store = new();        // => Dictionary method
    // => Key = order id string; O(1) FindById lookups
 
    public Order? FindById(OrderId id) =>                             // => method declaration
        _store.TryGetValue(id.Value, out var o) ? o : null;           // => _store.TryGetValue() called
    // => TryGetValue avoids KeyNotFoundException; returns null when absent
    // => Ternary: returns o if found, null otherwise
 
    public List<Order> FindByCustomerId(CustomerId id) =>             // => FindByCustomerId method
        _store.Values.Where(o => o.CustomerId == id).ToList();        // => Values.Where() called
    // => LINQ Where: filters in-memory; production uses DB WHERE clause
 
    public List<Order> FindByStatus(OrderStatus s) =>                 // => FindByStatus method
        _store.Values.Where(o => o.Status == s).ToList();             // => Values.Where() called
    // => Filters by status enum; record == compares Status value
 
    public List<Order> FindPendingOlderThanDays(int days) =>          // => FindPendingOlderThanDays method
        _store.Values.Where(o => o.Status == OrderStatus.Pending).ToList(); // => Values.Where() called
    // => Simplified: ignores 'days' parameter; real impl filters by creation date
 
    public void Save(Order o)      => _store[o.Id.Value] = o;         // => Save method
    // => Indexer assignment: inserts or replaces; upsert semantics
    public void Delete(OrderId id) => _store.Remove(id.Value);        // => Delete method
    // => Remove: no-op if key absent; no exception on missing id
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
var repo  = new InMemoryOrderRepository();                            // => repo initialised
// => Empty store; no orders yet
var order = new Order(new OrderId("O1"), new CustomerId("C1"), OrderStatus.Pending); // => order initialised
// => Immutable record: O1, C1, Pending
repo.Save(order);                                                     // => repo.Save() called
// => _store = {"O1": order}
 
var found   = repo.FindById(new OrderId("O1"));             // => Order (non-null)
// => TryGetValue finds "O1"; returns the stored Order
var pending = repo.FindByStatus(OrderStatus.Pending);        // => [order]
// => Where filter matches; one order in result list

import java.math.BigDecimal;                                          // => namespace/package import
import java.util.*;                                                   // => namespace/package import
 
enum OrderStatus { PENDING, CONFIRMED }                               // => enum OrderStatus
record OrderId(String value) {}                                       // => record OrderId
record Money(BigDecimal amount, String currency) {}                   // => record Money
record Order(OrderId id, Money total, OrderStatus status) {}          // => record Order
 
interface Specification<T> { boolean isSatisfiedBy(T t); }            // => interface Specification
 
// ── Repository accepting a Specification ─────────────────────────────────────
interface OrderRepository {                                           // => interface OrderRepository
    List<Order> findAll(Specification<Order> spec);                   // => expression
    // => One method covers all possible filtering combinations
    void save(Order order);                                           // => expression
}
 
class InMemoryOrderRepository implements OrderRepository {            // => class InMemoryOrderRepository
    private final Map<String, Order> store = new HashMap<>();         // => Map method
 
    @Override                                                         // => expression
    public List<Order> findAll(Specification<Order> spec) {           // => findAll method
        return store.values().stream()                                // => returns store.values().stream()
            .filter(spec::isSatisfiedBy) // => Delegate filtering to the spec
            .toList();                                                // => expression
        // => In-memory: linear scan; SQL impl would translate spec to WHERE clause
    }
 
    @Override public void save(Order o) { store.put(o.id().value(), o); } // => store.put() called
}
 
// ── Specs ─────────────────────────────────────────────────────────────────────
Specification<Order> bigOrder  = o -> o.total().amount().compareTo(new BigDecimal("100")) >= 0; // => o.total() called
Specification<Order> confirmed = o -> o.status() == OrderStatus.CONFIRMED; // => o.status() called
Specification<Order> combined  = t -> bigOrder.isSatisfiedBy(t) && confirmed.isSatisfiedBy(t); // => bigOrder.isSatisfiedBy() called
// => No new repository method needed; combine specs at call site
 
// ── Usage ─────────────────────────────────────────────────────────────────────
var repo = new InMemoryOrderRepository();                             // => repo initialised
repo.save(new Order(new OrderId("O1"), new Money(new BigDecimal("120"), "USD"), OrderStatus.CONFIRMED)); // => repo.save() called
repo.save(new Order(new OrderId("O2"), new Money(new BigDecimal("50"),  "USD"), OrderStatus.CONFIRMED)); // => repo.save() called
repo.save(new Order(new OrderId("O3"), new Money(new BigDecimal("120"), "USD"), OrderStatus.PENDING)); // => repo.save() called
 
List<Order> results = repo.findAll(combined);                         // => repo.findAll() called
// => [Order O1] — only O1 satisfies both bigOrder and confirmed

import java.math.BigDecimal                                           // => namespace/package import
 
enum class OrderStatus { PENDING, CONFIRMED }                         // => enum class
// => Two states; Specification will filter by CONFIRMED
data class OrderId(val value: String)                                 // => class OrderId
// => Typed identity; value class would give zero overhead in production
data class Money(val amount: BigDecimal, val currency: String)        // => class Money
// => amount + currency together; prevents unit-less arithmetic
data class Order(val id: OrderId, val total: Money, val status: OrderStatus) // => class Order
// => Plain data; no domain logic here — used to demonstrate repo filtering
 
fun interface Specification<T> { fun isSatisfiedBy(t: T): Boolean }   // => interface Specification
// => fun interface: SAM type; enables lambda syntax at call site
 
interface OrderRepository {                                           // => interface OrderRepository
    fun findAll(spec: Specification<Order>): List<Order>              // => findAll method
    // => One method replaces: findByStatus, findByTotalAbove, findByStatusAndTotal, etc.
    fun save(order: Order)                                            // => save method
    // => Upsert semantics; new id = insert, existing id = update
}
 
class InMemoryOrderRepository : OrderRepository {                     // => class InMemoryOrderRepository
    private val store = mutableMapOf<String, Order>()                 // => store declared
    // => Key = order id string; value = Order aggregate
 
    override fun findAll(spec: Specification<Order>) =                // => findAll method
        store.values.filter(spec::isSatisfiedBy)                      // => values.filter() called
    // => Delegates filtering to spec; repository stays generic
    // => SQL impl would translate spec to a WHERE clause or JPA Criteria
 
    override fun save(order: Order) { store[order.id.value] = order } // => save method
    // => Overwrites if id already present; no explicit insert/update distinction
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
val repo = InMemoryOrderRepository()                                  // => repo initialised
// => Empty store; three orders added below
repo.save(Order(OrderId("O1"), Money(BigDecimal("120"), "USD"), OrderStatus.CONFIRMED)) // => repo.save() called
// => store = {O1: Order(total=120 USD, status=CONFIRMED)}
repo.save(Order(OrderId("O2"), Money(BigDecimal("50"),  "USD"), OrderStatus.CONFIRMED)) // => repo.save() called
// => store = {O1: ..., O2: Order(total=50 USD, status=CONFIRMED)}
repo.save(Order(OrderId("O3"), Money(BigDecimal("120"), "USD"), OrderStatus.PENDING)) // => repo.save() called
// => store = {O1, O2, O3}; O3 is PENDING so will not match bigConfirmed
 
val bigConfirmed = Specification<Order> {                             // => bigConfirmed initialised
    it.total.amount >= BigDecimal("100") && it.status == OrderStatus.CONFIRMED // => expression
    // => Lambda evaluated for each order: O1 passes (120>=100 AND CONFIRMED); O2 fails (50<100)
}
val results = repo.findAll(bigConfirmed) // => [Order O1]
// => O2 fails amount check; O3 fails status check; only O1 satisfies both conditions

using System.Collections.Generic;                                     // => namespace/package import
using System.Linq;                                                    // => namespace/package import
 
public enum OrderStatus { Pending, Confirmed }                        // => OrderStatus field
// => Two states; specification will filter by Confirmed
public record OrderId(string Value);                                  // => record OrderId
// => Typed identity; prevents string mix-ups at call sites
public record Money(decimal Amount, string Currency);                 // => record Money
// => Value Object; amount + currency always travel together
public record Order(OrderId Id, Money Total, OrderStatus Status);     // => record Order
// => Simple immutable order record for demonstration
 
public interface ISpecification<T> { bool IsSatisfiedBy(T t); }       // => interface ISpecification
// => Single method: returns true when t satisfies the encapsulated rule
 
public interface IOrderRepository                                     // => interface IOrderRepository
{
    List<Order> FindAll(ISpecification<Order> spec);                  // => expression
    // => One method handles all filter combinations; no new methods per query
    void Save(Order order);                                           // => expression
    // => Upsert: insert on new id, update on existing id
}
 
public class InMemoryOrderRepository : IOrderRepository               // => class InMemoryOrderRepository
{
    private readonly Dictionary<string, Order> _store = new();        // => Dictionary method
    // => String key = order id value; production uses DB row ids
 
    public List<Order> FindAll(ISpecification<Order> spec) =>         // => FindAll method
        _store.Values.Where(spec.IsSatisfiedBy).ToList();             // => Values.Where() called
    // => Evaluates spec against every order in the store
    // => SQL impl would translate spec to WHERE clause via EF Core expressions
 
    public void Save(Order o) => _store[o.Id.Value] = o;              // => Save method
    // => Overwrites if id already in dictionary; no explicit insert/update split
}
 
public class LambdaSpec<T>(System.Func<T, bool> predicate) : ISpecification<T> // => class LambdaSpec
{
    // => Primary constructor (C# 12): predicate injected and stored automatically
    public bool IsSatisfiedBy(T t) => predicate(t);                   // => IsSatisfiedBy method
    // => Delegates to the stored lambda; one indirection over a raw Func<T,bool>
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
var repo = new InMemoryOrderRepository();                             // => repo initialised
// => Empty store; three orders added below
repo.Save(new Order(new OrderId("O1"), new Money(120m, "USD"), OrderStatus.Confirmed)); // => repo.Save() called
// => _store = {O1: Order(Total=120 USD, Status=Confirmed)}
repo.Save(new Order(new OrderId("O2"), new Money(50m,  "USD"), OrderStatus.Confirmed)); // => repo.Save() called
// => _store = {O1, O2: 50 USD Confirmed}; O2 will fail amount check
repo.Save(new Order(new OrderId("O3"), new Money(120m, "USD"), OrderStatus.Pending)); // => repo.Save() called
// => _store = {O1, O2, O3}; O3 is Pending so will fail status check
 
var bigConfirmed = new LambdaSpec<Order>(o => o.Total.Amount >= 100m && o.Status == OrderStatus.Confirmed); // => bigConfirmed initialised
// => Lambda: O1 passes (120>=100 AND Confirmed); O2 fails (50<100); O3 fails (Pending)
var results = repo.FindAll(bigConfirmed); // => [Order O1]
// => Only O1 satisfies both conditions; list has one element

import java.math.BigDecimal;                                          // => namespace/package import
 
// ── Two aggregate roots, each behind its own repository ───────────────────────
record CustomerId(String value) {}                                    // => record CustomerId
record OrderId(String value)    {}                                    // => record OrderId
record Money(BigDecimal amount, String currency) {}                   // => record Money
 
// Customer aggregate root
class Customer {                                                      // => class Customer
    private final CustomerId id;                                      // => id field
    private final String name;                                        // => name field
    // => Customer has its own lifecycle; Order must not hold a Customer reference
 
    Customer(CustomerId id, String name) { this.id = id; this.name = name; } // => Customer() called
    public CustomerId getId() { return id; }                          // => getId method
    public String getName()   { return name; }                        // => getName method
}
 
// Order aggregate root — stores CustomerId, NOT Customer
class Order {                                                         // => class Order
    private final OrderId    id;                                      // => id field
    private final CustomerId customerId; // => ID only; no Customer object here
    private final Money      total;                                   // => total field
    // => If Order held a Customer reference, loading Order would load Customer data,
    //    violating aggregate boundaries and creating hidden coupling
 
    Order(OrderId id, CustomerId customerId, Money total) {           // => Order() called
        this.id = id; this.customerId = customerId; this.total = total; // => this.id assigned
    }
 
    public CustomerId getCustomerId() { return customerId; }          // => getCustomerId method
    // => Caller queries CustomerRepository if Customer data is needed
}
 
// ── Usage: application service loads each aggregate separately ────────────────
// Pseudocode showing the separation principle:
// Customer customer = customerRepo.findById(order.getCustomerId()).orElseThrow();
// => Two separate repository calls; two transaction scopes possible
// => Each aggregate loaded only when its data is actually needed

import java.math.BigDecimal                                           // => namespace/package import
 
data class CustomerId(val value: String)                              // => class CustomerId
data class OrderId(val value: String)                                 // => class OrderId
data class Money(val amount: BigDecimal, val currency: String)        // => class Money
 
data class Customer(val id: CustomerId, val name: String)             // => class Customer
// => Customer is its own aggregate root with its own repository
 
data class Order(                                                     // => class Order
    val id:         OrderId,                                          // => expression
    val customerId: CustomerId, // => ID reference only — no Customer object
    val total:      Money                                             // => expression
)
// => Order aggregate does not reach into the Customer aggregate
// => "Cross-aggregate reference by ID" is the DDD rule
 
// ── Application service loads both when needed ────────────────────────────────
// val order    = orderRepo.findById(orderId) ?: error("not found")
// val customer = customerRepo.findById(order.customerId) ?: error("not found")
// => Each repository call is independent; lazy loading by design

public record CustomerId(string Value);                               // => record CustomerId
public record OrderId(string Value);                                  // => record OrderId
public record Money(decimal Amount, string Currency);                 // => record Money
 
public class Customer                                                 // => class Customer
{
    public CustomerId Id   { get; }                                   // => Id field
    public string     Name { get; }                                   // => Name field
    public Customer(CustomerId id, string name) { Id = id; Name = name; } // => Customer method
}
 
public class Order                                                    // => class Order
{
    public OrderId    Id         { get; }                             // => Id field
    public CustomerId CustomerId { get; } // => ID only; no Customer navigation property
    public Money      Total      { get; }                             // => Total field
    // => Entity Framework "navigation properties" to other aggregate roots violate boundaries
    // => DDD rule: only store the foreign aggregate's ID in this aggregate
 
    public Order(OrderId id, CustomerId customerId, Money total)      // => Order method
    {
        Id = id; CustomerId = customerId; Total = total;              // => Id assigned
    }
}
 
// ── Application service pattern ────────────────────────────────────────────────
// var order    = orderRepo.FindById(orderId) ?? throw new KeyNotFoundException();
// var customer = customerRepo.FindById(order.CustomerId) ?? throw new KeyNotFoundException();
// => Explicit two-step load; no automatic join or lazy load across aggregate boundary

import java.time.Instant;                                             // => namespace/package import
import java.util.*;                                                   // => namespace/package import
// => java.util.* provides List, Map, HashMap used throughout
 
// ── Domain events ─────────────────────────────────────────────────────────────
// Events carry the data needed by downstream handlers; nothing more, nothing less
interface DomainEvent {}                                              // => interface DomainEvent
// => Marker interface: all domain events implement this for dispatcher registration
record ProductId(String value) {}                                     // => record ProductId
// => Typed product identity; prevents mixing with OrderId or CustomerId
record OrderId(String value)   {}                                     // => record OrderId
// => Typed order identity; self-documenting in method signatures
 
record OrderConfirmed(                                                // => record OrderConfirmed
    OrderId orderId,     // => Which order was confirmed
    List<ProductId> items, // => Which products need stock decremented
    Instant occurredAt   // => When the confirmation happened; useful for ordering / audit
) implements DomainEvent {}                                           // => expression
// => Immutable event record: past tense name signals it is a historical fact
 
// ── Inventory aggregate — independent lifecycle ───────────────────────────────
// Inventory is a separate aggregate root; Order knows nothing about Inventory internals
// => "Separate aggregate root" means separate repository, separate transaction scope
class Inventory {                                                     // => class Inventory
    private final Map<String, Integer> stock = new HashMap<>();       // => Map method
    // => productId value (String) maps to current stock quantity (Integer)
    // => Inventory is its own aggregate root with its own repository in production
 
    public void initialiseStock(ProductId productId, int qty) {       // => initialiseStock method
        stock.put(productId.value(), qty);                            // => stock.put() called
        // => Seed stock for a product; in production called when product is added to catalogue
    }
 
    public void decreaseStock(ProductId productId, int qty) {         // => decreaseStock method
        int current = stock.getOrDefault(productId.value(), 0);       // => stock.getOrDefault() called
        // => getOrDefault: treats unknown products as having zero stock
        if (current < qty)                                            // => precondition check
            throw new IllegalStateException("Insufficient stock: " + productId); // => throws if guard fails
            // => Inventory enforces its own invariant: stock cannot go negative
            // => Handler catches this and sends the event to a dead-letter queue
        stock.put(productId.value(), current - qty);                  // => stock.put() called
        // => Atomic update: current quantity decremented by requested qty
    }
 
    public int getStock(ProductId pid) {                              // => getStock method
        return stock.getOrDefault(pid.value(), 0);                    // => returns stock.getOrDefault(pid.value()
        // => Returns 0 for unknown products rather than null
    }
}
 
// ── Domain event handler: bridges Order domain and Inventory domain ───────────
// This handler runs in a SEPARATE transaction from the one that saved Order
// => Eventual consistency: Inventory may lag Order by milliseconds in production
class OrderConfirmedHandler {                                         // => class OrderConfirmedHandler
    private final Inventory inventory;                                // => inventory field
    // => Inventory injected; handler has no direct dependency on Order aggregate
 
    OrderConfirmedHandler(Inventory inventory) { this.inventory = inventory; } // => OrderConfirmedHandler() called
 
    public void handle(OrderConfirmed event) {                        // => handle method
        // => event carries all data needed; no need to reload Order from repository
        for (ProductId item : event.items()) {                        // => iteration over collection
            inventory.decreaseStock(item, 1);                         // => inventory.decreaseStock() called
            // => Each item in the confirmed order decreases stock by 1 unit
            // => In production: wrapped in retry logic; message queue handles transient failures
        }
        // => Handler is idempotent if decreaseStock checks for exact quantity match
    }
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
var inventory = new Inventory();                                      // => inventory initialised
inventory.initialiseStock(new ProductId("P1"), 10);                   // => inventory.initialiseStock() called
// => P1 starts with 10 units in stock
 
var handler = new OrderConfirmedHandler(inventory);                   // => handler initialised
var event   = new OrderConfirmed(                                     // => event initialised
    new OrderId("O1"),                                                // => expression
    List.of(new ProductId("P1"), new ProductId("P1")),                // => List.of() called
    // => Two line items referencing P1: reduces stock by 2 total
    Instant.now()                                                     // => Instant.now() called
    // => Timestamp records when the order was confirmed; useful for audit and replay
);                                                                    // => expression
 
handler.handle(event);                                                // => handler.handle() called
// => handler processes both P1 items; decreaseStock called twice
int remaining = inventory.getStock(new ProductId("P1"));              // => inventory.getStock() called
// => 8 (10 initial - 2 from the two confirmed P1 items)

import java.time.Instant                                              // => namespace/package import
 
interface DomainEvent                                                 // => interface DomainEvent
data class ProductId(val value: String)                               // => class ProductId
data class OrderId(val value: String)                                 // => class OrderId
data class OrderConfirmed(val orderId: OrderId, val items: List<ProductId>, val occurredAt: Instant) : DomainEvent // => class OrderConfirmed
 
class Inventory {                                                     // => class Inventory
    private val stock = mutableMapOf<String, Int>()                   // => stock declared
 
    fun initialiseStock(productId: ProductId, qty: Int) { stock[productId.value] = qty } // => initialiseStock method
 
    fun decreaseStock(productId: ProductId, qty: Int) {               // => decreaseStock method
        val current = stock[productId.value] ?: 0                     // => current initialised
        check(current >= qty) { "Insufficient stock: ${productId.value}" } // => precondition check
        stock[productId.value] = current - qty                        // => expression
        // => Invariant: stock >= 0 enforced here, not in the handler
    }
 
    fun getStock(productId: ProductId) = stock[productId.value] ?: 0  // => getStock method
}
 
class OrderConfirmedHandler(private val inventory: Inventory) {       // => class OrderConfirmedHandler
    fun handle(event: OrderConfirmed) {                               // => handle method
        event.items.forEach { inventory.decreaseStock(it, 1) }        // => inventory.decreaseStock() called
        // => Each item in the event decreases stock by 1
        // => Handler runs in its own transaction; eventual consistency achieved
    }
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
val inventory = Inventory()                                           // => inventory initialised
inventory.initialiseStock(ProductId("P1"), 10) // => P1 stock = 10
 
val event = OrderConfirmed(OrderId("O1"), listOf(ProductId("P1"), ProductId("P1")), Instant.now()) // => event initialised
OrderConfirmedHandler(inventory).handle(event)                        // => OrderConfirmedHandler() called
 
val remaining = inventory.getStock(ProductId("P1")) // => 8

using System;                                                         // => namespace/package import
using System.Collections.Generic;                                     // => namespace/package import
 
public interface IDomainEvent {}                                      // => IDomainEvent field
public record ProductId(string Value);                                // => record ProductId
public record OrderId(string Value);                                  // => record OrderId
public record OrderConfirmed(OrderId OrderId, List<ProductId> Items, DateTimeOffset OccurredAt) : IDomainEvent; // => record OrderConfirmed
 
public class Inventory                                                // => class Inventory
// => begins block
{
    private readonly Dictionary<string, int> _stock = new();          // => Dictionary method
 
    public void InitialiseStock(ProductId productId, int qty) => _stock[productId.Value] = qty; // => InitialiseStock method
 
    public void DecreaseStock(ProductId productId, int qty)           // => DecreaseStock method
    // => begins block
    {
        var current = _stock.GetValueOrDefault(productId.Value, 0);   // => current initialised
        if (current < qty) throw new InvalidOperationException($"Insufficient stock: {productId.Value}"); // => throws if guard fails
        _stock[productId.Value] = current - qty; // => Stock updated; invariant protected
    // => ends block
    }
 
    public int GetStock(ProductId pid) => _stock.GetValueOrDefault(pid.Value, 0); // => GetStock method
// => ends block
}
 
public class OrderConfirmedHandler(Inventory inventory)               // => class OrderConfirmedHandler
// => begins block
{
    public void Handle(OrderConfirmed evt)                            // => Handle method
    // => begins block
    {
        foreach (var item in evt.Items)                               // => iteration over collection
            inventory.DecreaseStock(item, 1); // => Eventual consistency: runs after Order transaction
    // => ends block
    }
}
 
// ── Usage ─────────────────────────────────────────────────────────────────────
var inv = new Inventory();                                            // => inv initialised
inv.InitialiseStock(new ProductId("P1"), 10); // => P1 = 10
 
var evt = new OrderConfirmed(new OrderId("O1"),                       // => evt initialised
    new List<ProductId> { new("P1"), new("P1") }, DateTimeOffset.UtcNow); // => expression
new OrderConfirmedHandler(inv).Handle(evt);                           // => expression
 
int remaining = inv.GetStock(new ProductId("P1")); // => 8

import java.time.Instant;                                             // => namespace/package import
import java.util.*;                                                   // => namespace/package import
import java.util.function.Consumer;                                   // => namespace/package import
 
// ── Infrastructure: simple synchronous event dispatcher ───────────────────────
interface DomainEvent {}                                              // => interface DomainEvent
 
class EventDispatcher {                                               // => class EventDispatcher
    private final Map<Class<?>, List<Consumer<DomainEvent>>> handlers = new HashMap<>(); // => Map method
    // => Maps event type to list of handlers; multiple handlers per event supported
 
    @SuppressWarnings("unchecked")                                    // => expression
    public <T extends DomainEvent> void register(Class<T> eventType, Consumer<T> handler) { // => expression
        handlers.computeIfAbsent(eventType, k -> new ArrayList<>())   // => handlers.computeIfAbsent() called
                .add(e -> handler.accept((T) e)); // => Type-safe cast at registration
    }
 
    public void publish(DomainEvent event) {                          // => publish method
        var eventHandlers = handlers.getOrDefault(event.getClass(), List.of()); // => eventHandlers initialised
        eventHandlers.forEach(h -> h.accept(event)); // => Invoke each registered handler
    }
}
 
// ── Events ────────────────────────────────────────────────────────────────────
record OrderId(String value) {}                                       // => record OrderId
record CustomerId(String value) {}                                    // => record CustomerId
record OrderPlaced(OrderId orderId, CustomerId customerId, Instant occurredAt) implements DomainEvent {} // => record OrderPlaced
 
// ── Handler classes: one responsibility each ─────────────────────────────────
class SendConfirmationEmailHandler {                                  // => class SendConfirmationEmailHandler
    // => Reacts to OrderPlaced; sends customer confirmation
    public void handle(OrderPlaced event) {                           // => handle method
        System.out.println("Sending confirmation email for order " + event.orderId().value()); // => output to console
        // => In production: inject EmailService; call sendEmail(event.customerId())
    }
}
 
class UpdateLoyaltyPointsHandler {                                    // => class UpdateLoyaltyPointsHandler
    // => Reacts to OrderPlaced; credits loyalty points
    public void handle(OrderPlaced event) {                           // => handle method
        System.out.println("Adding loyalty points for customer " + event.customerId().value()); // => output to console
        // => In production: inject LoyaltyService; call addPoints(event.customerId())
    }
}
 
// ── Wire up: registration at application startup ──────────────────────────────
var dispatcher     = new EventDispatcher();                           // => dispatcher initialised
var emailHandler   = new SendConfirmationEmailHandler();              // => emailHandler initialised
var loyaltyHandler = new UpdateLoyaltyPointsHandler();                // => loyaltyHandler initialised
 
dispatcher.register(OrderPlaced.class, emailHandler::handle);         // => dispatcher.register() called
// => When OrderPlaced fires, call emailHandler.handle(...)
dispatcher.register(OrderPlaced.class, loyaltyHandler::handle);       // => dispatcher.register() called
// => Both handlers registered; both invoked when event published
 
// ── Trigger ───────────────────────────────────────────────────────────────────
var event = new OrderPlaced(new OrderId("O1"), new CustomerId("C1"), Instant.now()); // => event initialised
dispatcher.publish(event);                                            // => dispatcher.publish() called
// => Output: Sending confirmation email for order O1
// => Output: Adding loyalty points for customer C1

import java.time.Instant                                              // => namespace/package import
 
interface DomainEvent                                                 // => interface DomainEvent
 
class EventDispatcher {                                               // => class EventDispatcher
    private val handlers = mutableMapOf<Class<*>, MutableList<(DomainEvent) -> Unit>>() // => handlers declared
 
    @Suppress("UNCHECKED_CAST")                                       // => expression
    fun <T : DomainEvent> register(type: Class<T>, handler: (T) -> Unit) { // => expression
        handlers.getOrPut(type) { mutableListOf() }                   // => handlers.getOrPut() called
            .add { event -> handler(event as T) }                     // => expression
    // => ends block
    }
 
    fun publish(event: DomainEvent) {                                 // => publish method
        handlers[event::class.java]?.forEach { it(event) }            // => expression
        // => Calls each registered handler with the event
    // => ends block
    }
}
 
data class OrderId(val value: String)                                 // => class OrderId
data class CustomerId(val value: String)                              // => class CustomerId
data class OrderPlaced(val orderId: OrderId, val customerId: CustomerId, val occurredAt: Instant) : DomainEvent // => class OrderPlaced
 
class SendConfirmationEmailHandler {                                  // => class SendConfirmationEmailHandler
    fun handle(event: OrderPlaced) {                                  // => handle method
        println("Sending confirmation email for order ${event.orderId.value}") // => output to console
        // => Single responsibility: only email concern lives here
    }
}
 
class UpdateLoyaltyPointsHandler {                                    // => class UpdateLoyaltyPointsHandler
    fun handle(event: OrderPlaced) {                                  // => handle method
        println("Adding loyalty points for customer ${event.customerId.value}") // => output to console
    }
}
 
// ── Wire up and trigger ───────────────────────────────────────────────────────
val dispatcher = EventDispatcher()                                    // => dispatcher initialised
dispatcher.register(OrderPlaced::class.java, SendConfirmationEmailHandler()::handle) // => dispatcher.register() called
dispatcher.register(OrderPlaced::class.java, UpdateLoyaltyPointsHandler()::handle) // => dispatcher.register() called
 
val event = OrderPlaced(OrderId("O1"), CustomerId("C1"), Instant.now()) // => event initialised
dispatcher.publish(event)                                             // => dispatcher.publish() called
// => Sending confirmation email for order O1
// => Adding loyalty points for customer C1

using System;                      // => Console.WriteLine, Type
using System.Collections.Generic;  // => Dictionary, List, Action
 
public interface IDomainEvent {}                                      // => IDomainEvent field
// => Marker interface: all domain events implement this; enables Dictionary<Type, ...> dispatch
 
public class EventDispatcher                                          // => class EventDispatcher
// => Routes events to all registered handlers by event type
{
    private readonly Dictionary<Type, List<Action<IDomainEvent>>> _handlers = new(); // => List method
    // => Key = event runtime type; Value = list of handlers registered for that type
 
    public void Register<T>(Action<T> handler) where T : IDomainEvent // => Register method
    // => Generic registration: T must be IDomainEvent; enables type-safe Add()
    {
        var type = typeof(T);                                         // => type initialised
        // => Capture runtime Type object for the event type T
        if (!_handlers.ContainsKey(type)) _handlers[type] = new();    // => precondition check
        // => Lazily create handler list if first registration for this event type
        _handlers[type].Add(e => handler((T)e)); // => Type-safe wrapper
        // => Lambda wraps typed Action<T> as untyped Action<IDomainEvent>; cast is safe
    }
 
    public void Publish(IDomainEvent evt)                             // => Publish method
    // => Dispatches event to all handlers registered for evt's runtime type
    {
        if (_handlers.TryGetValue(evt.GetType(), out var list))       // => precondition check
            // => TryGetValue: returns false if no handlers registered (no exception)
            foreach (var h in list) h(evt); // => Invoke all handlers for this event type
        // => h(evt): calls each registered handler; any order (List does not sort)
    }
}
 
public record OrderId(string Value);                                  // => record OrderId
// => Typed order identity; wraps string for compile-time safety
public record CustomerId(string Value);                               // => record CustomerId
// => Typed customer identity; prevents mixing with OrderId strings
public record OrderPlaced(OrderId OrderId, CustomerId CustomerId, DateTimeOffset OccurredAt) : IDomainEvent; // => record OrderPlaced
// => Immutable domain event record; OccurredAt captures when the placement happened
 
public class SendConfirmationEmailHandler                             // => class SendConfirmationEmailHandler
// => Single-responsibility: only handles OrderPlaced to send email
{
    public void Handle(OrderPlaced evt) =>                            // => Handle method
        Console.WriteLine($"Sending confirmation email for order {evt.OrderId.Value}"); // => output to console
    // => In production: calls email service; here prints to console for demonstration
}
 
public class UpdateLoyaltyPointsHandler                               // => class UpdateLoyaltyPointsHandler
// => Single-responsibility: only handles OrderPlaced to update points
{
    public void Handle(OrderPlaced evt) =>                            // => Handle method
        Console.WriteLine($"Adding loyalty points for customer {evt.CustomerId.Value}"); // => output to console
    // => In production: calls loyalty service; here prints for demonstration
}
 
// ── Wire up ───────────────────────────────────────────────────────────────────
var dispatcher = new EventDispatcher();                               // => dispatcher initialised
// => New dispatcher; no handlers registered yet
dispatcher.Register<OrderPlaced>(new SendConfirmationEmailHandler().Handle); // => expression
// => First handler for OrderPlaced registered
dispatcher.Register<OrderPlaced>(new UpdateLoyaltyPointsHandler().Handle); // => expression
// => Second handler for OrderPlaced registered; dispatcher._handlers[OrderPlaced] = [email, loyalty]
 
dispatcher.Publish(new OrderPlaced(new OrderId("O1"), new CustomerId("C1"), DateTimeOffset.UtcNow)); // => dispatcher.Publish() called
// => Dispatches to both handlers in registration order
// => Sending confirmation email for order O1
// => Adding loyalty points for customer C1