Unidirectional data flow

data class CartState(val items: List<CartItem> = emptyList()) {
    val total: Money get() = items.fold(Money.ZERO) { acc, it -> acc + it.price * it.quantity }  // derived
    val badgeCount: Int get() = items.sumOf { it.quantity }                                      // derived
}

class CartViewModel : ViewModel() {
    private val _state = MutableStateFlow(CartState())        // the only source of truth
    val state: StateFlow<CartState> = _state.asStateFlow()

    fun setQuantity(id: ItemId, quantity: Int) = _state.update { s ->   // events come here
        s.copy(items = if (quantity == 0) s.items.filterNot { it.id == id }
                       else s.items.map { if (it.id == id) it.copy(quantity = quantity) else it })
    }
}

@Composable
fun CartRow(item: CartItem, onQuantityChange: (Int) -> Unit) {   // data down, events up
    QuantityStepper(value = item.quantity, onValueChange = onQuantityChange)
}

@Composable
fun CartScreen(viewModel: CartViewModel) {
    val state by viewModel.state.collectAsStateWithLifecycle()
    LazyColumn {
        items(state.items, key = { it.id.value }) { item ->
            CartRow(item) { viewModel.setQuantity(item.id, it) }
        }
    }
    Text("Total: ${state.total}")
}

// React: the cart owns the items; rows get values and callbacks
function CartScreen() {
  const [items, setItems] = useState<CartItem[]>([]);          // the only source of truth

  const total = items.reduce((sum, i) => sum + i.price * i.quantity, 0);   // derived on render
  const badgeCount = items.reduce((n, i) => n + i.quantity, 0);            // derived on render

  const setQuantity = (id: ItemId, quantity: number) =>      // events come here
    setItems((prev) => quantity === 0
      ? prev.filter((i) => i.id !== id)
      : prev.map((i) => (i.id === id ? { ...i, quantity } : i)));

  return (
    <>
      {items.map((item) => (
        <CartRow key={item.id} item={item} onQuantityChange={(q) => setQuantity(item.id, q)} />
      ))}
      <p>Total: {formatMoney(total)}</p>
    </>
  );
}

function CartRow({ item, onQuantityChange }: { item: CartItem; onQuantityChange(q: number): void }) {
  return <QuantityStepper value={item.quantity} onChange={onQuantityChange} />;   // data down, events up
}

data class CartState(val items: List<CartItem> = emptyList(), val coupon: CouponStatus = CouponStatus.None)

sealed interface CartAction {
    data class SetQuantity(val id: ItemId, val quantity: Int) : CartAction
    data class ApplyCoupon(val code: String) : CartAction
    data class CouponResponse(val result: Result<List<CartItem>>) : CartAction
}

// Pure: returns the next state; effects are handled by the store
fun reduce(state: CartState, action: CartAction): CartState = when (action) {
    is CartAction.SetQuantity -> state.copy(items = state.items.mapNotNull {
        if (it.id != action.id) it else if (action.quantity == 0) null else it.copy(quantity = action.quantity)
    })
    is CartAction.ApplyCoupon -> state.copy(coupon = CouponStatus.Applying)
    is CartAction.CouponResponse -> action.result.fold(
        onSuccess = { state.copy(items = it, coupon = CouponStatus.Applied) },
        onFailure = { state.copy(coupon = CouponStatus.Failed(it.message.orEmpty())) },
    )
}

class CartStore(private val api: CartApi, private val scope: CoroutineScope) {
    private val _state = MutableStateFlow(CartState())
    val state: StateFlow<CartState> = _state.asStateFlow()

    fun send(action: CartAction) {
        _state.update { reduce(it, action) }
        if (action is CartAction.ApplyCoupon) scope.launch {                 // effect
            send(CartAction.CouponResponse(runCatching { api.applyCoupon(action.code) }))
        }
    }
}

interface CartState { items: CartItem[]; coupon: CouponStatus }

type CartAction =
  | { type: "setQuantity"; id: ItemId; quantity: number }
  | { type: "applyCoupon"; code: string }
  | { type: "couponApplied"; items: CartItem[] }
  | { type: "couponFailed"; message: string };

// Pure: returns a new state object, never mutates the old one
function cartReducer(state: CartState, action: CartAction): CartState {
  switch (action.type) {
    case "setQuantity":
      return {
        ...state,
        items: action.quantity === 0
          ? state.items.filter((i) => i.id !== action.id)
          : state.items.map((i) => (i.id === action.id ? { ...i, quantity: action.quantity } : i)),
      };
    case "applyCoupon":
      return { ...state, coupon: { kind: "applying" } };
    case "couponApplied":
      return { ...state, items: action.items, coupon: { kind: "applied" } };
    case "couponFailed":
      return { ...state, coupon: { kind: "failed", message: action.message } };
  }
}

// Effect: runs outside the reducer and reports back with actions
async function applyCoupon(code: string, dispatch: (a: CartAction) => void, api: CartApi) {
  dispatch({ type: "applyCoupon", code });
  try {
    dispatch({ type: "couponApplied", items: await api.applyCoupon(code) });
  } catch (e) {
    dispatch({ type: "couponFailed", message: String(e) });
  }
}