j5ik2o/okite-ai/first-class-collection

コレクション型のフィールド/変数
    ↓
ビジネスロジック（集計/フィルタ/バリデーション）が必要か？
    ├─ YES → ファーストクラスコレクション化を検討
    │         ├─ 同じ操作が複数箇所にあるか？ → 必須
    │         └─ 1箇所のみ → 将来性を考慮して判断
    └─ NO → 生のコレクションで可

❌ orders.stream().filter(o -> o.getStatus() == PENDING).toList()  // 複数箇所で同じフィルタ
❌ int total = items.stream().mapToInt(Item::getPrice).sum()       // 呼び出し側で集計
❌ if (users.isEmpty()) throw new EmptyUsersException()            // バリデーション散在
❌ for (Order o : orders) { if (o.isOverdue()) ... }               // 外部でループ処理
❌ orders.add(order)                                                // 直接変更可能

// ❌ 生のコレクション
List<Order> orders;
 
// ✅ ファーストクラスコレクション
public final class Orders {
    private final List<Order> values;
 
    public Orders(List<Order> values) {
        this.values = List.copyOf(values);  // 不変性保証
    }
 
    // ドメインロジックをここに集約
}

// ❌ 呼び出し側で集計
Money total = Money.ZERO;
for (Order order : orders) {
    total = total.add(order.getAmount());
}
 
// ✅ コレクションに集約
public Money totalAmount() {
    return values.stream()
        .map(Order::amount)
        .reduce(Money.ZERO, Money::add);
}

// ❌ 外部でフィルタリング
List<Order> pending = orders.stream()
    .filter(o -> o.getStatus() == PENDING)
    .toList();
 
// ✅ ドメイン用語でメソッド化
public Orders pending() {
    return new Orders(
        values.stream()
            .filter(Order::isPending)
            .toList()
    );
}

// ❌ 外部でバリデーション
if (orders.isEmpty()) {
    throw new IllegalArgumentException("注文がありません");
}
 
// ✅ 生成時にバリデーション
public Orders(List<Order> values) {
    if (values.isEmpty()) {
        throw new EmptyOrdersException();
    }
    this.values = List.copyOf(values);
}

// ❌ 破壊的変更
orders.add(newOrder);
 
// ✅ 新しいインスタンスを返す
public Orders add(Order order) {
    List<Order> newList = new ArrayList<>(values);
    newList.add(order);
    return new Orders(newList);
}

class Orders {
    private constructor(private readonly values: readonly Order[]) {}
    static of(orders: Order[]): Orders {
        return new Orders([...orders]);
    }
    totalAmount(): Money {
        return this.values.reduce(
            (sum, order) => sum.add(order.amount),
            Money.ZERO
        );
    }
}

pub struct Orders(Vec<Order>);
 
impl Orders {
    pub fn new(orders: Vec<Order>) -> Self {
        Self(orders)
    }
 
    pub fn total_amount(&self) -> Money {
        self.0.iter().map(|o| o.amount()).sum()
    }
 
    pub fn pending(&self) -> Self {
        Self(self.0.iter().filter(|o| o.is_pending()).cloned().collect())
    }
}

@dataclass(frozen=True)
class Orders:
    _values: tuple[Order, ...]
    @classmethod
    def of(cls, orders: list[Order]) -> "Orders":
        return cls(tuple(orders))
    def total_amount(self) -> Money:
        return sum((o.amount for o in self._values), Money.ZERO)

type Orders struct {
    values []Order
}
 
func NewOrders(orders []Order) Orders {
    copied := make([]Order, len(orders))
    copy(copied, orders)
    return Orders{values: copied}
}
 
func (o Orders) TotalAmount() Money {
    total := ZeroMoney()
    for _, order := range o.values {
        total = total.Add(order.Amount())
    }
    return total
}
 
func (o Orders) Pending() Orders {
    var pending []Order
    for _, order := range o.values {
        if order.IsPending() {
            pending = append(pending, order)
        }
    }
    return NewOrders(pending)
}