0Pricing
Flutter Mobile Development · 课时

Either、失败类型与函数式错误处理

使用 dartz Either 和密封失败类型，将可恢复错误建模为值。

Either、失败类型与函数式错误处理 是 CoddyKit 上的免费 Flutter Mobile Development 课时。 这是第 4 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Flutter Mobile Development 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Flutter Mobile Development 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

Errors as Values

In Clean Architecture, your domain and data layers should not crash the UI with raw exceptions. Instead of throwing across layer boundaries, you model recoverable errors as return values.

The dartz package gives you Either<L, R>: a value that is either a Left (by convention, the failure) or a Right (the success). The caller is forced to handle both.

  • Left = the error path (a Failure)
  • Right = the happy path (your data)

This turns invisible throw/catch control flow into an explicit, type-checked contract.

// A repository method signature in the domain layer
// Future<Either<Failure, User>> getUser(String id);
//
// Left  -> something went wrong (a Failure)
// Right -> the success value (a User)

Modeling Either Ourselves

Before reaching for dartz, it helps to see what Either actually is. It is just a sealed type with two cases. Dart 3 sealed classes make the idea concrete and exhaustive.

The key property: a function returning Either always returns one of two shapes, and the compiler can verify you handled both in a switch.

sealed class Either<L, R> {}

class Left<L, R> extends Either<L, R> {
  final L value;
  Left(this.value);
}

class Right<L, R> extends Either<L, R> {
  final R value;
  Right(this.value);
}

Either<String, int> parsePositive(String s) {
  final n = int.tryParse(s);
  if (n == null) return Left('not a number');
  if (n <= 0) return Left('must be positive');
  return Right(n);
}

void main() {
  final result = parsePositive('42');
  final msg = switch (result) {
    Left(value: final e) => 'Error: $e',
    Right(value: final v) => 'Got $v',
  };
  print(msg);
}

Sealed Failure Types

Rather than putting a raw String on the Left, Clean Architecture uses a sealed hierarchy of Failure types. Each subtype names a distinct, recoverable error your domain cares about.

  • ServerFailure — backend returned an error
  • CacheFailure — local storage failed
  • NetworkFailure — device is offline
  • ValidationFailure — input was invalid

Because the base is sealed, a switch over a Failure is checked for exhaustiveness — add a new failure and the compiler points you at every place that must handle it.

sealed class Failure {
  final String message;
  const Failure(this.message);
}

class ServerFailure extends Failure {
  final int? statusCode;
  const ServerFailure(super.message, {this.statusCode});
}

class CacheFailure extends Failure {
  const CacheFailure(super.message);
}

class NetworkFailure extends Failure {
  const NetworkFailure(super.message);
}

class ValidationFailure extends Failure {
  const ValidationFailure(super.message);
}

Returning Either from a Repository

Here is the classic Clean Architecture repository pattern. The data source throws exceptions; the repository catches them at the boundary and converts each into a typed Failure on the Left.

This is the only place try/catch lives. Above this line, the rest of your app deals exclusively in Either<Failure, T>.

import 'package:dartz/dartz.dart';

class UserRepository {
  final RemoteDataSource remote;
  UserRepository(this.remote);

  Future<Either<Failure, User>> getUser(String id) async {
    try {
      final user = await remote.fetchUser(id);
      return Right(user);
    } on ServerException catch (e) {
      return Left(ServerFailure(e.message, statusCode: e.code));
    } on SocketException {
      return const Left(NetworkFailure('No internet connection'));
    }
  }
}

fold: Collapsing Either into One Value

The primary way to consume an Either is fold. It takes two functions — one for Left, one for Right — and runs whichever case applies, returning a single value of the same type.

fold forces you to handle the failure. You cannot accidentally read the success while ignoring the error, the way a forgotten try/catch lets you.

import 'package:dartz/dartz.dart';

String describe(Either<Failure, int> result) {
  return result.fold(
    (failure) => 'Failed: ${failure.message}',
    (value) => 'Success: $value',
  );
}

void main() {
  final ok = const Right<Failure, int>(7);
  final err = const Left<Failure, int>(CacheFailure('disk full'));
  print(describe(ok));   // Success: 7
  print(describe(err));  // Failed: disk full
}

fold Returns a Value, Not Side Effects

A common confusion: fold is for producing a value, not for branching side effects. In Flutter you typically fold an Either into a UI state object.

Notice both branches return the same type (here, a ViewState). If the branches returned different types, the result would be Object and you would lose type safety — a frequent beginner mistake.

sealed class ViewState {}
class ErrorState extends ViewState {
  final String message;
  ErrorState(this.message);
}
class LoadedState extends ViewState {
  final int data;
  LoadedState(this.data);
}

// In a Bloc/Cubit/Notifier:
// final ViewState next = result.fold(
//   (f) => ErrorState(f.message),
//   (v) => LoadedState(v),
// );

Transforming the Right with map

Either is right-biased: map transforms the success value and leaves a Left untouched. This lets a use case reshape data without unwrapping and rewrapping.

If the value is a Left failure, map is a no-op — the failure flows straight through. This is how you build pipelines that short-circuit on the first error.

import 'package:dartz/dartz.dart';

void main() {
  Either<String, int> success = const Right(10);
  Either<String, int> failure = const Left('boom');

  // map only touches the Right side
  print(success.map((v) => v * 2)); // Right(20)
  print(failure.map((v) => v * 2)); // Left(boom) — unchanged
}

Chaining with flatMap (bind)

When each step itself returns an Either, plain map would nest you into Either<F, Either<F, T>>. Use flatMap (also spelled bind in dartz) to chain failure-producing steps so the first Left short-circuits the rest.

This is the functional replacement for a chain of try/catch blocks: validation, then parsing, then a lookup — any failure stops the pipeline and surfaces as the final Left.

sealed class Either<L, R> {
  Either<L, T> flatMap<T>(Either<L, T> Function(R) f) =>
      switch (this) {
        Left(value: final l) => Left(l),
        Right(value: final r) => f(r),
      };
}

class Left<L, R> extends Either<L, R> {
  final L value;
  Left(this.value);
}
class Right<L, R> extends Either<L, R> {
  final R value;
  Right(this.value);
}

Either<String, int> parse(String s) =>
    int.tryParse(s) is int n ? Right(n) : Left('bad int');
Either<String, int> mustBePositive(int n) =>
    n > 0 ? Right(n) : Left('not positive');

void main() {
  final r = parse('5').flatMap(mustBePositive);
  print(switch (r) {
    Left(value: final e) => 'fail: $e',
    Right(value: final v) => 'ok: $v',
  });
}

Use Cases Return Either Too

In Clean Architecture, a use case sits between the presentation layer and the repository. It also returns Either<Failure, T>, often adding domain-level validation that produces its own ValidationFailure.

The use case never knows or cares whether the failure came from the network or from its own checks — both are just Failure values flowing on the Left.

import 'package:dartz/dartz.dart';

class GetUser {
  final UserRepository repo;
  GetUser(this.repo);

  Future<Either<Failure, User>> call(String id) async {
    if (id.trim().isEmpty) {
      return const Left(ValidationFailure('id must not be empty'));
    }
    return repo.getUser(id);
  }
}

Consuming Either in the UI Layer

At the edge — inside a Bloc, Cubit, or Riverpod notifier — you finally fold the Either into emitted UI states. The widget tree then reacts to those states.

Because every failure is a typed subtype of the sealed Failure, you can switch on it to show tailored messages: a retry button for NetworkFailure, a form error for ValidationFailure, and so on.

Future<void> loadUser(String id) async {
  emit(UserLoading());
  final result = await getUser(id);
  result.fold(
    (failure) => emit(UserError(_mapFailure(failure))),
    (user) => emit(UserLoaded(user)),
  );
}

String _mapFailure(Failure f) => switch (f) {
  NetworkFailure() => 'You are offline. Tap to retry.',
  ServerFailure(:final statusCode) => 'Server error ($statusCode).',
  CacheFailure() => 'Could not read local data.',
  ValidationFailure(:final message) => message,
};

Either vs Throwing Exceptions

Why prefer Either over exceptions across layers?

  • Explicit contracts — the return type tells callers a failure is possible; exceptions are invisible in the signature.
  • Exhaustiveness — sealed Failure + switch means a new error variant is a compile-time prompt, not a runtime surprise.
  • Composability — map/flatMap chain steps and short-circuit cleanly.

Reserve real throw for unrecoverable, programmer-error situations (e.g. assert, invariant violations). Use Either<Failure, T> for expected, recoverable outcomes like network or validation errors.

Quick Check

Test your understanding of functional error handling in Clean Architecture.

Recap

You learned to model recoverable errors as values:

  • Either<Failure, T> makes failure an explicit part of every repository and use case signature — Left for errors, Right for success.
  • A sealed Failure hierarchy (ServerFailure, CacheFailure, NetworkFailure, ValidationFailure) gives exhaustive, type-checked error handling.
  • The repository is the one place that catches raw exceptions and converts them to typed failures.
  • fold collapses an Either into a single value (often a UI state); map and flatMap/bind build short-circuiting pipelines that stop on the first Left.
  • Reserve throw for unrecoverable programmer errors; use Either for expected, recoverable ones.

常见问题解答

「Either、失败类型与函数式错误处理」课时是免费的吗？

是的 — 「Either、失败类型与函数式错误处理」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Flutter Mobile Development 课程的其余内容，请升级到 CoddyKit PRO。 Flutter Mobile Development 课程共包含 4 节课。

「Either、失败类型与函数式错误处理」这节课中我会学到什么？

使用 dartz Either 和密封失败类型，将可恢复错误建模为值。 你通过在浏览器中直接运行的动手代码来练习 Flutter Mobile Development，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Flutter Mobile Development 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Flutter Mobile Development 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 4 节课，共 4 节。

「Either、失败类型与函数式错误处理」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Flutter Mobile Development 课中编写并运行代码吗？

能。每节 Flutter Mobile Development 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

  1. 领域、数据与表示层边界
  2. 使用 get_it 和 injectable 进行依赖注入
  3. 功能优先的文件夹结构与 Melos 单体仓库
  4. Either、失败类型与函数式错误处理
← 返回 Flutter Mobile Development