free-types-core 0.8.5 → 0.9.0

package/dist/Const.d.ts

@@ -9,6 +9,7 @@ declare type Const<T> = {
     arguments: any[] & {
         length: any;
     };
+    labels: any;
     0: any;
     1: any;
     2: any;

package/dist/Type.d.ts

@@ -1,20 +1,28 @@
 import { Tuple } from './utils';
 export { Type };
 /** Extend `Type<Input?, Output?>` with an interface to produce a free type, or use it as a type constraint.*/
-declare type Type<Input extends number | unknown[] = unknown[], Output = unknown> = CreateType<{
+declare type Type<Input extends number | unknown[] = unknown[], Output = unknown, Labels extends string[] = []> = CreateType<{
     type: Output;
     constraints: Constraints<Input, Slots<Input>>;
     arguments: unknown[];
+    labels: ReverseMap<Labels>;
 }>;
 interface CreateType<T extends {
     type: unknown;
     constraints: unknown[];
+    labels: {
+        [k: string]: number;
+    };
 }> {
     [k: number]: unknown;
     type: T['type'];
     constraints: T['constraints'];
     arguments: unknown[];
+    labels: T['labels'];
 }
+declare type ReverseMap<T extends string[]> = {
+    [K in keyof T as K extends `${number}` ? T[K] : never]: K extends `${infer I extends number}` ? I : never;
+};
 declare type Slots<T> = T extends Precomputable ? PrecomputedSlots[T & Precomputable] : Tuple<T extends unknown[] ? T['length'] : T extends number ? T : number>;
 declare type Constraints<Input, Slots> = number extends Input ? unknown[] : unknown[] extends Input ? unknown[] : Input extends unknown[] ? Input : Slots;
 declare type PrecomputedSlots = {

package/dist/apply.d.ts

@@ -1,14 +1,38 @@
 import { Type } from './Type';
 import { ArrayKeys, Next } from './utils';
-export { apply, $apply, Generic };
-/** Apply a free type with all its arguments and evaluate the type */
-declare type apply<$T extends Type, Args extends $T['constraints'] = []> = applyUnsafe<$T, Args>;
+declare type NamedType = {
+    type: unknown;
+    constraints: {
+        [k: number]: unknown;
+        length: number;
+    };
+    labels: Labels;
+};
+declare type Labels = {
+    [k: string]: number;
+};
+export { apply, applyNamed, $apply, Generic };
+/** Apply a free type with its complete arguments list and evaluate the type */
+declare type apply<$T extends Type, Args extends $T['constraints'] = []> = applyPositional<$T, Args>;
+/** Apply a free type with its complete arguments struct and evaluate the type */
+declare type applyNamed<$T extends NamedType, Args extends CheckNamed<$Model>, $Model extends NamedType = $T> = applyPositional<$T, ToPositional<$T, Args>>;
+declare type RecoverLabels<T extends Labels> = {
+    [K in keyof T as T[K]]: K;
+};
+declare type ToPositional<$T extends NamedType, Args extends {
+    [k: string]: unknown;
+}, Labels extends {
+    [k: number]: string;
+} = RecoverLabels<$T['labels']>, I extends number = 0, R extends unknown[] = []> = I extends $T['constraints']['length'] ? R : ToPositional<$T, Args, Labels, Next<I>, [...R, Args[Labels[I]]]>;
+declare type CheckNamed<$T extends NamedType> = {
+    [K in keyof $T['labels']]: $T['constraints'][$T['labels'][K]];
+};
 interface $apply<Args extends unknown[] = []> extends Type<[Type]> {
     type: apply<this[0] extends Type ? this[0] : Type, Args>;
 }
 /** Apply a free type `$T` with its type constraints. */
 declare type Generic<$T extends Type> = _apply<$T, $T['constraints']>;
-declare type applyUnsafe<$T extends {
+declare type applyPositional<$T extends {
     type: unknown;
     constraints: {
         length: number;

package/dist/helpers.d.ts

@@ -1,40 +1,52 @@
 import { Next, IsUnknown, Prev } from './utils';
 export { At, Checked, Lossy, Optional, A, B, C, D, E };
-declare type Type<N extends number> = {
-    constraints: {
+declare type Type<N extends number = number> = {
+    constraints: N extends number ? {
         [K in Prev<N>]: unknown;
-    };
+    } : unknown[];
     arguments: unknown[];
+    labels: {
+        [k: string]: number;
+    };
 };
 declare type Type_<N extends number> = {
     constraints: {
         [K in Prev<N>]?: unknown;
     };
     arguments: unknown[];
+    labels: {
+        [k: string]: number;
+    };
 };
 declare type Default = {
     constraints: [0, 1, 2, 3, 4];
     arguments: unknown[];
+    labels: {
+        [k: string]: number;
+    };
 };
 /** - safely index `this`
  * - optionally take a fallback
 */
-declare type At<N extends number, This extends Type<Next<N>>, Fallback = unknown> = IsUnknown<This['arguments'][N]> extends true ? Fallback : This['arguments'][N];
+declare type At<N extends Check, This extends N extends number ? Type<Next<N>> : Type, Fallback = unknown, Check extends string | number = N extends string ? keyof This['labels'] & string : number> = N extends number ? AtImpl<This, Fallback, N> : AtImpl<This, Fallback, This['labels'][N]>;
+declare type AtImpl<This extends Type, Fallback, I extends number> = IsUnknown<This['arguments'][I]> extends true ? Fallback : This['arguments'][I];
 /** - safely index `this`
  * - defuse the corresponding type constraint with an inline conditional
  * - optionally take a fallback
  */
-declare type Checked<N extends number, This extends Type<Next<N>>, Fallback = N extends keyof This['constraints'] ? This['constraints'][N] : never> = N extends keyof This['constraints'] ? This['arguments'][N] extends This['constraints'][N] ? This['arguments'][N] : Fallback : never;
+declare type Checked<N extends Check, This extends N extends number ? Type<Next<N>> : Type, Fallback = N extends number ? This['constraints'][N] : N extends string ? This['constraints'][This['labels'][N]] : never, Check extends string | number = N extends string ? keyof This['labels'] & string : number> = N extends number ? CheckedImpl<N, This, Fallback> : CheckedImpl<This['labels'][N], This, Fallback>;
+declare type CheckedImpl<N extends number, This extends Type, Fallback> = This['arguments'][N] extends This['constraints'][N] ? This['arguments'][N] : Fallback;
 /** - safely index `this`
  * - works on optional parameters
  * - defuse the corresponding type constraint with an inline conditional
  * - optionally take a fallback
  */
-declare type Optional<N extends number, This extends Type_<Next<N>>, Fallback = N extends keyof This['constraints'] ? Exclude<This['constraints'][N], undefined> : never> = N extends keyof This['constraints'] ? This['arguments'][N] extends Exclude<This['constraints'][N], undefined> ? This['arguments'][N] : Fallback : never;
+declare type Optional<N extends Check, This extends N extends number ? Type_<Next<N>> : Type, Fallback = N extends number ? Exclude<This['constraints'][N], undefined> : N extends string ? Exclude<This['constraints'][This['labels'][N]], undefined> : never, Check extends string | number = N extends string ? keyof This['labels'] & string : number> = N extends number ? OptionalImpl<N, This, Fallback> : OptionalImpl<This['labels'][N], This, Fallback>;
+declare type OptionalImpl<N extends number, This extends Type, Fallback> = This['arguments'][N] extends Exclude<This['constraints'][N], undefined> ? This['arguments'][N] : Fallback;
 /** - safely index `this`
  * - intersect the corresponding type constraint
  */
-declare type Lossy<N extends number, This extends Type<Next<N>>> = N extends keyof This['constraints'] ? This['arguments'][N] & This['constraints'][N] : never;
+declare type Lossy<N extends Check, This extends N extends number ? Type<Next<N>> : Type, Check extends string | number = N extends string ? keyof This['labels'] & string : number> = N extends number ? This['arguments'][N] & This['constraints'][N] : This['arguments'][This['labels'][N]] & This['constraints'][This['labels'][N]];
 /** - safely index `this`
  * - intersect the corresponding type constraint
  * - equals `0` When no argument is supplied

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "free-types-core",
-    "version": "0.8.5",
+    "version": "0.9.0",
     "description": "A type-level library enabling the creation and the manipulation of type constructors which are detached from their type parameters.",
     "keywords:": [
         "higher kinded type",