//#region src/hkt.d.ts
/** Symbol key for the argument tuple applied to an HKT instance. */
declare const PARAMS: unique symbol;
/** Symbol key for the applied type produced by an HKT instance. */
declare const TYPE: unique symbol;
/**
 * Encoding for a higher-kinded type
 *
 * @example
 * type Maybe<A> =
 *   | { readonly _tag: "Some"; readonly value: A }
 *   | { readonly _tag: "None" };
 *
 * interface MaybeF extends HKT {
 *   readonly [HKT.TYPE]: Maybe<HKT.Param<this, 0>>;
 * }
 *
 * type Name = HKT.Apply<MaybeF, readonly [string]>;
 * //   ^? Maybe<string>
 */
interface HKT extends HKT.Parameterized<readonly unknown[]> {
  readonly [TYPE]: unknown;
}
declare const HKT: Readonly<{
  PARAMS: typeof PARAMS;
  TYPE: typeof TYPE;
}>;
declare namespace HKT {
  type PARAMS = typeof PARAMS;
  type TYPE = typeof TYPE;
  /** Phantom slot carrying the argument tuple for an {@link Apply} instantiation. */
  interface Parameterized<Args extends readonly unknown[]> {
    readonly [PARAMS]: Args;
  }
  /** Gets the `N`th argument from an HKT instance */
  type Param<Self extends HKT, N extends keyof Self[PARAMS]> = Self[PARAMS][N];
  /**
   * Value-level witness that constructor `F` is already applied to `Args`.
   *
   * Compositional helpers such as {@link Fix12} should target the bare constructor
   * (`Fix12<F, ...>`), not `Fix12<Applied<F, Args>, ...>`: {@link Apply} intersects a new
   * arg tuple onto `[PARAMS]`, so rebinding an {@link Applied} instance collides with the
   * stored tuple and collapses slots to `never`.
   */
  type Applied<F extends HKT, Args extends readonly unknown[]> = F & Parameterized<Args>;
  /** Applies HKT `F` to argument tuple `Args` and returns the `[TYPE]` type. */
  type Apply<F extends HKT, Args extends readonly unknown[]> = (F & Parameterized<Args>)[typeof TYPE];
  /** Composes two HKTs: the applied type of `G` on the first argument flows into `F`. */
  interface Compose<F extends HKT, G extends HKT> extends HKT {
    readonly [TYPE]: Apply<F, [Apply<G, [Param<this, 0>]>]>;
  }
  /** Swaps the first two arguments before applying `F`. */
  interface Flip<F extends HKT> extends HKT {
    readonly [TYPE]: Apply<F, [Param<this, 1>, Param<this, 0>]>;
  }
  /** Fixes the first argument to `A` before applying `F`. */
  interface Fix1<F extends HKT, A> extends HKT {
    readonly [TYPE]: Apply<F, [A, Param<this, 0>]>;
  }
  /** Fixes the second argument to `B` before applying `F`. */
  interface Fix2<F extends HKT, B> extends HKT {
    readonly [TYPE]: Apply<F, [Param<this, 0>, B]>;
  }
  /** Fixes the first two arguments to `A` and `B` before applying `F`. */
  interface Fix12<F extends HKT, A, B> extends HKT {
    readonly [TYPE]: Apply<F, [A, B, Param<this, 0>]>;
  }
}
//#endregion
export { HKT as t };
//# sourceMappingURL=hkt-C84w3kEn.d.mts.map