Method zip

src/effected.ts:1002–1032

(that: Effected<Effect, unknown>, mapper?: any)

    mapper: (a: R, b: S) => T | Generator<G, T, unknown> | Effected<G, T>,
  ): Effected<E | F | G, T>;
  zip(that: Effected<Effect, unknown>, mapper?: any): Effected<Effect, unknown> {
    return effected(() => {
      const iterator = this[Symbol.iterator]();
      const thatIterator = that[Symbol.iterator]();
      let selfDone = false;
      let selfDoneValue: unknown;
      let thatDone = false;
      let appendedIterator: Iterator<Effect, unknown, unknown>;
      return {
        next: (...args: [] | [unknown]) => {
          if (selfDone && thatDone) return appendedIterator.next(...args);
          if (!selfDone) {
            const result = iterator.next(...args);
            if (!result.done) return result;
            selfDone = true;
            selfDoneValue = result.value;
          }
          const thatResult = thatIterator.next(...args);
          if (!thatResult.done) return thatResult;
          thatDone = true;
          if (mapper) {
            const it = mapper(selfDoneValue, thatResult.value);
            if (!(it instanceof Effected) && !isGenerator(it)) return { done: true, value: it };
            appendedIterator = it[Symbol.iterator]();
            return appendedIterator.next();
          }
          return { done: true, value: [selfDoneValue, thatResult.value] };
        },
      };
    }) as never;
  }

  /**
   * Catch an error effect with a handler.