Class Effected

src/effected.ts:361–2247

 * An effected program.
 */
export class Effected<out E extends Effect, out R> implements Iterable<E, R, unknown> {
  declare public readonly [Symbol.iterator]: () => Iterator<E, R, unknown>;

  declare public readonly runSync: [ExtractUnhandled<E>] extends [never] ?
    () => ExtractDefaultTerminateType<E> | R
  : UnhandledEffect<ExtractUnhandled<E>>;
  declare public readonly runAsync: [ExtractUnhandled<E>] extends [never] ?
    () => Promise<ExtractDefaultTerminateType<E> | R>
  : UnhandledEffect<ExtractUnhandled<E>>;
  declare public readonly runSyncUnsafe: () => ExtractDefaultTerminateType<E> | R;
  declare public readonly runAsyncUnsafe: () => Promise<ExtractDefaultTerminateType<E> | R>;

  private constructor(fn: () => Iterator<E, R, unknown>, magicWords?: string) {
    if (magicWords !== "Yes, I’m sure I want to call the constructor of Effected directly.")
      logger.warn(
        "You should not call the constructor of `Effected` directly. Use `effected` instead.",
      );

    this[Symbol.iterator] = fn;

    this.runSync = (() => runSync(this as never)) as never;
    this.runAsync = (() => runAsync(this as never)) as never;
    this.runSyncUnsafe = () => runSync(this as never);
    this.runAsyncUnsafe = () => runAsync(this as never);
  }

  /**
   * Create an {@link Effected} instance that just returns the value.
   * @param value The value to return.
   * @returns
   *
   * @since 0.1.2
   */
  static of<R>(value: R): Effected<never, R> {
    return effected(() => ({ next: () => ({ done: true, value }) })) as Effected<never, R>;
  }

  /**
   * Create an {@link Effected} instance that just returns the value from a getter.
   * @param getter The getter to get the value.
   * @returns
   */
  static from<R>(getter: () => R): Effected<never, R> {
    return effected(() => ({ next: () => ({ done: true, value: getter() }) })) as Effected<
      never,
      R
    >;
  }

  /**
   * Combine multiple effected programs into one, running them in parallel and produces a tuple or
   * object with the results.
   * @param effects An iterable of effected programs or an object with effected programs as values.
   * @returns
   *
   * @see {@linkcode Effected.allSeq} for the sequential version.
   *
   * @since 0.3.2