Exception vs Result: hansını, niyə

// ══════ EXCEPTION ILƏ ══════
abstract interface class OrderRepository {
  // İmza: xəta barədə heç nə demir.
  // Hansı exception-lar atılır? Sənəddə yazılmasa — bilinmir.
  Future<Order> place(Cart cart);
}

// Notifier-də: nə tutmalı olduğunu təxmin edirsən.
Future<void> submit(Cart cart) async {
  state = const AsyncValue.loading();
  try {
    final order = await _repository.place(cart);
    state = AsyncValue.data(order);
  } on OutOfStockException catch (e) {      // bunu bilirdin
    state = AsyncValue.error(e, StackTrace.current);
  } on PaymentDeclinedException catch (e) { // bunu da
    state = AsyncValue.error(e, StackTrace.current);
  }
  // Bəs `SocketException`? Bəs `UnauthorizedException`?
  // Tutulmadı → tətbiq crash olur, ya da state loading-də qalır.
}


// ══════ RESULT ILƏ ══════
abstract interface class OrderRepository {
  // İmza: uğursuzluğun mümkün olduğunu AÇIQ deyir.
  Future<Result<Order>> place(Cart cart);
}

// Notifier-də: kompilyator hər iki halı nəzərə almağa məcbur edir.
Future<void> submit(Cart cart) async {
  state = const AsyncValue.loading();
  final result = await _repository.place(cart);

  // `sealed` tip: `switch` tam olmalıdır, yoxsa kompilyasiya xətası.
  state = switch (result) {
    Ok(:final value) => AsyncValue.data(value),
    Error(:final error) => AsyncValue.error(error, StackTrace.current),
  };
}


// ══════ ARDICIL ƏMƏLİYYATLAR: ən böyük fərq ══════
// Exception ilə: içi-içinə try/catch
Future<void> checkoutWithExceptions(Cart cart) async {
  try {
    final reserved = await _inventory.reserve(cart);
    try {
      final payment = await _payments.charge(reserved.total);
      try {
        await _orders.confirm(reserved, payment);
      } catch (e) {
        await _payments.refund(payment);   // kompensasiya
        rethrow;
      }
    } catch (e) {
      await _inventory.release(reserved);  // kompensasiya
      rethrow;
    }
  } catch (e) {
    // Burada hansı addım sındı? Bilinmir.
  }
}

// Result ilə: düz axın, hər addım aydın
Future<Result<Order>> checkoutWithResult(Cart cart) async {
  // Tam `switch` ifadəsi dəyəri çıxarır və uğursuzluqda dərhal qaytarır.
  // (`reserved` yalnız bir budaqda təyin olunur — Dart bunu qəbul edir,
  //  çünki digər budaq `return` edir.)
  final Reservation reserved;
  switch (await _inventory.reserve(cart)) {
    case Ok(:final value):
      reserved = value;
    case Error(:final error):
      return Result.error(error);
  }

  final Payment payment;
  switch (await _payments.charge(reserved.total)) {
    case Ok(:final value):
      payment = value;
    case Error(:final error):
      await _inventory.release(reserved);          // kompensasiya
      return Result.error(error);
  }

  switch (await _orders.confirm(reserved, payment)) {
    case Ok(:final value):
      return Result.ok(value);
    case Error(:final error):
      await _payments.refund(payment);             // kompensasiya
      await _inventory.release(reserved);
      return Result.error(error);
  }
}