flatten2 method

Implementation

@protected
Resolvable<T> flatten2() {
  switch (this) {
    // Case 1: The outer container is a Sync.
    case Sync(value: final outerResult):
      switch (outerResult) {
        // Case 1a: The outer Sync contains an Ok.
        case Ok(value: final innerResolvable):
          // The inner value is the next Resolvable, which we return directly.
          return innerResolvable;
        // Case 1b: The outer Sync contains an Err.
        case final Err<Resolvable<T>> err:
          // Propagate the error, wrapped in a Sync.
          return Sync.value(err.transfErr());
      }

    // Case 2: The outer container is an Async.
    case Async(value: final outerFutureResult):
      return Async(() async {
        final outerResult = await outerFutureResult;
        // After awaiting, we have a Result. Switch on it.
        switch (outerResult) {
          // Case 2a: The outer Async contained an Ok.
          case Ok(value: final innerResolvable):
            // Await the inner Resolvable and return its value.
            return await innerResolvable.unwrap();
          // Case 2b: The outer Async contained an Err.
          case final Err<Resolvable<T>> err:
            // Re-throw the error to be caught by the Async constructor.
            throw err;
        }
      });
  }
}