Utils

declare const adapter: <F extends TypeLambda>() => Adapter<F>;

declare class GenKindImpl<F extends TypeLambda, R, O, E, A> implements GenKind<F, R, O, E, A> {
  constructor<F extends TypeLambda, R, O, E, A>(value: Kind<F, R, O, E, A>);
  readonly [GenKindTypeId]: typeof GenKindTypeId;
  readonly value: Kind<F, R, O, E, A>;
  _E: (_: never) => E;
  _F: <A>(a: A) => A;
  _O: (_: never) => O;
  _R: (_: R) => R;
  [iterator](): IterableIterator<GenKind<F, R, O, E, A>, A>;
}

declare function makeGenKind<F extends TypeLambda, R, O, E, A>(
  kind: Kind<F, R, O, E, A>,
): GenKind<F, R, O, E, A>;

declare class SingleShotGen<T, A> implements IterableIterator<T, A> {
  constructor<T, A>(self: T);
  readonly self: T;
  [iterator](): IterableIterator<T, A>;
  next(a: A): IteratorResult<T, A>;
  return(a: A): IteratorResult<T, A>;
  throw(e: unknown): IteratorResult<T, A>;
}

type OptionalNumber = number | null | undefined;

declare class PCGRandom {
  constructor(seed?: OptionalNumber);
  constructor(seedHi: OptionalNumber, seedLo: OptionalNumber, inc?: OptionalNumber);
  constructor(
    seedHi: OptionalNumber,
    seedLo: OptionalNumber,
    incHi: OptionalNumber,
    incLo: OptionalNumber,
  );
  getState(): PCGRandomState;
  integer(max: number): number;
  number(): number;
  setState(state: PCGRandomState): void;
}

type PCGRandomState = [number, number, number, number];

interface Adapter<Z extends TypeLambda> {
  <_R, _O, _E, _A>(self: Kind<Z, _R, _O, _E, _A>): GenKind<Z, _R, _O, _E, _A>;
  <A, _R, _O, _E, _A>(a: A, ab: (a: A) => Kind<Z, _R, _O, _E, _A>): GenKind<Z, _R, _O, _E, _A>;
  <A, B, _R, _O, _E, _A>(
    a: A,
    ab: (a: A) => B,
    bc: (b: B) => Kind<Z, _R, _O, _E, _A>,
  ): GenKind<Z, _R, _O, _E, _A>;
  <A, B, C, _R, _O, _E, _A>(
    a: A,
    ab: (a: A) => B,
    bc: (b: B) => C,
    cd: (c: C) => Kind<Z, _R, _O, _E, _A>,
  ): GenKind<Z, _R, _O, _E, _A>;
  <A, B, C, D, _R, _O, _E, _A>(
    a: A,
    ab: (a: A) => B,
    bc: (b: B) => C,
    cd: (c: C) => D,
    de: (d: D) => Kind<Z, _R, _O, _E, _A>,
  ): GenKind<Z, _R, _O, _E, _A>;
  <A, B, C, D, E, _R, _O, _E, _A>(
    a: A,
    ab: (a: A) => B,
    bc: (b: B) => C,
    cd: (c: C) => D,
    de: (d: D) => E,
    ef: (e: E) => Kind<Z, _R, _O, _E, _A>,
  ): GenKind<Z, _R, _O, _E, _A>;
  <A, B, C, D, E, F, _R, _O, _E, _A>(
    a: A,
    ab: (a: A) => B,
    bc: (b: B) => C,
    cd: (c: C) => D,
    de: (d: D) => E,
    ef: (e: E) => F,
    fg: (f: F) => Kind<Z, _R, _O, _E, _A>,
  ): GenKind<Z, _R, _O, _E, _A>;
  <A, B, C, D, E, F, G, _R, _O, _E, _A>(
    a: A,
    ab: (a: A) => B,
    bc: (b: B) => C,
    cd: (c: C) => D,
    de: (d: D) => E,
    ef: (e: E) => F,
    fg: (f: F) => G,
    gh: (g: F) => Kind<Z, _R, _O, _E, _A>,
  ): GenKind<Z, _R, _O, _E, _A>;
  <A, B, C, D, E, F, G, H, _R, _O, _E, _A>(
    a: A,
    ab: (a: A) => B,
    bc: (b: B) => C,
    cd: (c: C) => D,
    de: (d: D) => E,
    ef: (e: E) => F,
    fg: (f: F) => G,
    gh: (g: G) => H,
    hi: (g: H) => Kind<Z, _R, _O, _E, _A>,
  ): GenKind<Z, _R, _O, _E, _A>;
  <A, B, C, D, E, F, G, H, I, _R, _O, _E, _A>(
    a: A,
    ab: (a: A) => B,
    bc: (b: B) => C,
    cd: (c: C) => D,
    de: (d: D) => E,
    ef: (e: E) => F,
    fg: (f: F) => G,
    gh: (g: G) => H,
    hi: (h: H) => I,
    ij: (i: I) => Kind<Z, _R, _O, _E, _A>,
  ): GenKind<Z, _R, _O, _E, _A>;
  <A, B, C, D, E, F, G, H, I, J, _R, _O, _E, _A>(
    a: A,
    ab: (a: A) => B,
    bc: (b: B) => C,
    cd: (c: C) => D,
    de: (d: D) => E,
    ef: (e: E) => F,
    fg: (f: F) => G,
    gh: (g: G) => H,
    hi: (h: H) => I,
    ij: (i: I) => J,
    jk: (j: J) => Kind<Z, _R, _O, _E, _A>,
  ): GenKind<Z, _R, _O, _E, _A>;
  <A, B, C, D, E, F, G, H, I, J, K, _R, _O, _E, _A>(
    a: A,
    ab: (a: A) => B,
    bc: (b: B) => C,
    cd: (c: C) => D,
    de: (d: D) => E,
    ef: (e: E) => F,
    fg: (f: F) => G,
    gh: (g: G) => H,
    hi: (h: H) => I,
    ij: (i: I) => J,
    jk: (j: J) => K,
    kl: (k: K) => Kind<Z, _R, _O, _E, _A>,
  ): GenKind<Z, _R, _O, _E, _A>;
  <A, B, C, D, E, F, G, H, I, J, K, L, _R, _O, _E, _A>(
    a: A,
    ab: (a: A) => B,
    bc: (b: B) => C,
    cd: (c: C) => D,
    de: (d: D) => E,
    ef: (e: E) => F,
    fg: (f: F) => G,
    gh: (g: G) => H,
    hi: (h: H) => I,
    ij: (i: I) => J,
    jk: (j: J) => K,
    kl: (k: K) => L,
    lm: (l: L) => Kind<Z, _R, _O, _E, _A>,
  ): GenKind<Z, _R, _O, _E, _A>;
  <A, B, C, D, E, F, G, H, I, J, K, L, M, _R, _O, _E, _A>(
    a: A,
    ab: (a: A) => B,
    bc: (b: B) => C,
    cd: (c: C) => D,
    de: (d: D) => E,
    ef: (e: E) => F,
    fg: (f: F) => G,
    gh: (g: G) => H,
    hi: (h: H) => I,
    ij: (i: I) => J,
    jk: (j: J) => K,
    kl: (k: K) => L,
    lm: (l: L) => M,
    mn: (m: M) => Kind<Z, _R, _O, _E, _A>,
  ): GenKind<Z, _R, _O, _E, _A>;
  <A, B, C, D, E, F, G, H, I, J, K, L, M, N, _R, _O, _E, _A>(
    a: A,
    ab: (a: A) => B,
    bc: (b: B) => C,
    cd: (c: C) => D,
    de: (d: D) => E,
    ef: (e: E) => F,
    fg: (f: F) => G,
    gh: (g: G) => H,
    hi: (h: H) => I,
    ij: (i: I) => J,
    jk: (j: J) => K,
    kl: (k: K) => L,
    lm: (l: L) => M,
    mn: (m: M) => N,
    no: (n: N) => Kind<Z, _R, _O, _E, _A>,
  ): GenKind<Z, _R, _O, _E, _A>;
  <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, _R, _O, _E, _A>(
    a: A,
    ab: (a: A) => B,
    bc: (b: B) => C,
    cd: (c: C) => D,
    de: (d: D) => E,
    ef: (e: E) => F,
    fg: (f: F) => G,
    gh: (g: G) => H,
    hi: (h: H) => I,
    ij: (i: I) => J,
    jk: (j: J) => K,
    kl: (k: K) => L,
    lm: (l: L) => M,
    mn: (m: M) => N,
    no: (n: N) => O,
    op: (o: O) => Kind<Z, _R, _O, _E, _A>,
  ): GenKind<Z, _R, _O, _E, _A>;
  <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, _R, _O, _E, _A>(
    a: A,
    ab: (a: A) => B,
    bc: (b: B) => C,
    cd: (c: C) => D,
    de: (d: D) => E,
    ef: (e: E) => F,
    fg: (f: F) => G,
    gh: (g: G) => H,
    hi: (h: H) => I,
    ij: (i: I) => J,
    jk: (j: J) => K,
    kl: (k: K) => L,
    lm: (l: L) => M,
    mn: (m: M) => N,
    no: (n: N) => O,
    op: (o: O) => P,
    pq: (p: P) => Kind<Z, _R, _O, _E, _A>,
  ): GenKind<Z, _R, _O, _E, _A>;
  <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, _R, _O, _E, _A>(
    a: A,
    ab: (a: A) => B,
    bc: (b: B) => C,
    cd: (c: C) => D,
    de: (d: D) => E,
    ef: (e: E) => F,
    fg: (f: F) => G,
    gh: (g: G) => H,
    hi: (h: H) => I,
    ij: (i: I) => J,
    jk: (j: J) => K,
    kl: (k: K) => L,
    lm: (l: L) => M,
    mn: (m: M) => N,
    no: (n: N) => O,
    op: (o: O) => P,
    pq: (p: P) => Q,
    qr: (q: Q) => Kind<Z, _R, _O, _E, _A>,
  ): GenKind<Z, _R, _O, _E, _A>;
  <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, _R, _O, _E, _A>(
    a: A,
    ab: (a: A) => B,
    bc: (b: B) => C,
    cd: (c: C) => D,
    de: (d: D) => E,
    ef: (e: E) => F,
    fg: (f: F) => G,
    gh: (g: G) => H,
    hi: (h: H) => I,
    ij: (i: I) => J,
    jk: (j: J) => K,
    kl: (k: K) => L,
    lm: (l: L) => M,
    mn: (m: M) => N,
    no: (n: N) => O,
    op: (o: O) => P,
    pq: (p: P) => Q,
    qr: (q: Q) => R,
    rs: (r: R) => Kind<Z, _R, _O, _E, _A>,
  ): GenKind<Z, _R, _O, _E, _A>;
  <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, _R, _O, _E, _A>(
    a: A,
    ab: (a: A) => B,
    bc: (b: B) => C,
    cd: (c: C) => D,
    de: (d: D) => E,
    ef: (e: E) => F,
    fg: (f: F) => G,
    gh: (g: G) => H,
    hi: (h: H) => I,
    ij: (i: I) => J,
    jk: (j: J) => K,
    kl: (k: K) => L,
    lm: (l: L) => M,
    mn: (m: M) => N,
    no: (n: N) => O,
    op: (o: O) => P,
    pq: (p: P) => Q,
    qr: (q: Q) => R,
    rs: (r: R) => S,
    st: (s: S) => Kind<Z, _R, _O, _E, _A>,
  ): GenKind<Z, _R, _O, _E, _A>;
  <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, _R, _O, _E, _A>(
    a: A,
    ab: (a: A) => B,
    bc: (b: B) => C,
    cd: (c: C) => D,
    de: (d: D) => E,
    ef: (e: E) => F,
    fg: (f: F) => G,
    gh: (g: G) => H,
    hi: (h: H) => I,
    ij: (i: I) => J,
    jk: (j: J) => K,
    kl: (k: K) => L,
    lm: (l: L) => M,
    mn: (m: M) => N,
    no: (n: N) => O,
    op: (o: O) => P,
    pq: (p: P) => Q,
    qr: (q: Q) => R,
    rs: (r: R) => S,
    st: (s: S) => T,
    tu: (s: T) => Kind<Z, _R, _O, _E, _A>,
  ): GenKind<Z, _R, _O, _E, _A>;
}

interface Gen<F extends TypeLambda, Z> {
  <Self, K extends Variance<F, any, any, any> | YieldWrap<Kind<F, any, any, any, any>>, A>(
    ...args:
      | [self: Self, body: (this: Self, resume: Z) => Generator<K, A, never>]
      | [body: (resume: Z) => Generator<K, A, never>]
  ): Kind<
    F,
    [K] extends [Variance<F, R, any, any>]
      ? R
      : [K] extends [YieldWrap<Kind<F, R, any, any, any>>]
        ? R
        : never,
    [K] extends [Variance<F, any, O, any>]
      ? O
      : [K] extends [YieldWrap<Kind<F, any, O, any, any>>]
        ? O
        : never,
    [K] extends [Variance<F, any, any, E>]
      ? E
      : [K] extends [YieldWrap<Kind<F, any, any, E, any>>]
        ? E
        : never,
    A
  >;
}

interface GenKind<F extends TypeLambda, R, O, E, A> extends Variance<F, R, O, E> {
  readonly value: Kind<F, R, O, E, A>;
  [iterator](): IterableIterator<GenKind<F, R, O, E, A>, A>;
}

interface Variance<in out F extends TypeLambda, in R, out O, out E> {
  readonly _E: Covariant<E>;
  readonly _F: Invariant<F>;
  readonly _O: Covariant<O>;
  readonly _R: Contravariant<R>;
  readonly [GenKindTypeId]: typeof GenKindTypeId;
}

declare function structuralRegion<A>(
  body: () => A,
  tester?: (a: unknown, b: unknown) => boolean,
): A;

declare const structuralRegionState: {
  enabled: boolean;
  tester: (a: unknown, b: unknown) => boolean | undefined;
};

declare function isGeneratorFunction(
  u: unknown,
): u is (...args: Array<any>) => Generator<any, any, any>;

declare class YieldWrap<T> {
  constructor<T>(value: T);
  [YieldWrapTypeId](): T;
}

declare function yieldWrapGet<T>(self: YieldWrap<T>): T;

declare const YieldWrapTypeId: unique symbol;

declare function isGenKind(u: unknown): u is GenKind<any, any, any, any, any>;

declare const GenKindTypeId: unique symbol;

type GenKindTypeId = typeof GenKindTypeId;

declare const internalCall: <A>(body: () => A) => A;