标签: dartz

我有一段代码，如下所示：

final Either<Failure, Unit> resA = await deleteA();

resA.fold(
  (failure) => handleFailure(),
  (success) async {
    final Either<Failure, Unit> resB = await deleteB();
    resB.fold(
      (failure) => handleFailure(),
      (success) => handleSuccess(),
    );
  },
);

基本上，我想调用第一个函数，它返回失败或单位（成功值并不重要）。

然后，如果第一个函数成功，我想调用另一个函数，它也返回 Future 或 Unit。

我该如何避免fold另一个内部的这种丑陋的嵌套调用fold？

我正在使用dartz包，它非常酷，但缺乏文档。

我正在使用冻结包来创建我的 json 解析器和数据类。到目前为止，我正在使用dartz的包来创建 Union 案例并在 Flutter 小部件中处理它们。例如，我的一些 Union 类如下所示。

Either<ApiFailure,ModelA> apiResult1;
Either<ApiFailure,ModelB> apiResult2;

我在我的颤振小部件的构建器中使用它们，方法是折叠它们并为每种情况返回特定的小部件。例如。

return apiResul1.fold<Widget>(
  (left) => ErrorWidget(),
  (right) => SuccessWidget(),
);

我使用冻结包创建了ApiFailure、ModelA和ModelB作为数据类。我知道冻结带有类似的联合类支持，例如 dartz，我们可以在其中定义联合案例。因此，我尝试按如下方式使用它们，并且根据我的初步理解，使用现有的数据类无法实现以下目标，例如。ModelA andApiFailure`。

@freezed
abstract class ApiResult1 with _$ApiResult1{
  const factory ApiResult1.modelA() =  ModelA;
  const factory ApiResult1.apiFailure() =  ApiFailure;
}

@freezed
abstract class ApiResult2 with _$ApiResult1{
  const factory ApiResult2.modelB() =  ModelB;
  const factory ApiResult2.apiFailure() =  ApiFailure;
}

请注意，在上述两个工会班我重新定义ApiFailure在ApiResult2这正是我想避免的。

问题：是否可以利用现有的数据类来构建联合类，这样我就不必为了更改ApiFailure …

我想了解 dartz，但文档不够清晰。我需要了解 dartz 中任一选项和选项之间的区别？

abstract class Option<A> implements TraversableMonadPlusOps<Option, A>

VS

abstract class Either<L, R> implements TraversableMonadOps<Either<L, dynamic>, R> 

var newRight;
if(either.isRight()) {
  newRight = either.getOrElse(() => throw UnimplementedError());
} else {
  return Left(either.fold((f) => f, (r) => throw UnimplementedError()))
}

我怎样才能得到其中任何一个的左侧并将其返回，如上例所示？还有其他更清洁的解决方案吗？

我正在将我的项目迁移到新版本的 Flutter，并使用 BloC 包。如您所知，Bloc 已经更新，并且更改了大部分代码，所以现在我正在调整我的代码，但有一些错误。

参数类型“Future Function(bool)”无法分配给参数类型“UserState Function(bool)”

正文可能正常完成，导致返回“null”，但返回类型可能是不可为 null 的类型。

前 ：

  Stream<UserState> _validate(ValidateEvent event) async* {

    final successOrFailure = await services.validate();
    
    yield* successOrFailure.fold(
      (sucess) async* {
        final session = await services.getSession();
        yield* session.fold(
          (session) async* {
            yield UserSuccess(session);

            yield UserLogged(session);
          },
          (failure) async* {
            yield UserError(failure.message);
          },
        );
      },
      (failure) async* {
        yield UserError(failure.message);
      },
    );
  }

后 ：

UserBloc({this.services}) : super(UserInitial()) {
    on<ValidateEvent>(_onValidate);
  }

void _onValidate(
    ValidateEvent event,
    Emitter<UserState> emit,
  ) async {

    final successOrFailure = await …