free-types-core 0.8.4 → 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/dist/utils.d.ts

@@ -9,9 +9,9 @@ declare type _Next = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
 declare type Subtract<A extends number, B extends number> = number extends A ? number : number extends B ? number : _Subtract<A, B>;
 declare type _Subtract<A extends number, B extends number, _A = Prev<A>, _B = Prev<B>> = B extends 0 ? A : [_A] extends [never] ? never : [_B] extends never ? never : _Subtract<_A & number, _B & number>;
 declare type ArrayKeys = Exclude<keyof [], never>;
-declare type Slice<T extends unknown[], From extends number, To extends number = Required<T>['length'], I extends number = From, R extends unknown[] = []> = number extends To ? SliceOpenEndedTuple<T, From> : SliceTuple<T, From, To, I, R>;
-declare type SliceOpenEndedTuple<T extends unknown[], From extends number> = From extends 0 ? T : T extends [unknown, ...infer R] ? SliceOpenEndedTuple<R, Prev<From>> : never;
-declare type SliceTuple<T extends unknown[], From extends number, To extends number = Required<T>['length'], I extends number = From, R extends unknown[] = []> = I extends To ? R : Slice<T, From, To, Next<I>, IsOptional<T, I> extends true ? [...R, T[I]?] : [...R, T[I]]>;
+declare type Slice<T extends readonly unknown[], From extends number, To extends number = Required<T>['length'], I extends number = From, R extends unknown[] = []> = number extends To ? SliceOpenEndedTuple<T, From> : SliceTuple<T, From, To, I, R>;
+declare type SliceOpenEndedTuple<T extends readonly unknown[], From extends number> = From extends 0 ? T : T extends [unknown, ...infer R] ? SliceOpenEndedTuple<R, Prev<From>> : never;
+declare type SliceTuple<T extends readonly unknown[], From extends number, To extends number = Required<T>['length'], I extends number = From, R extends unknown[] = []> = I extends To ? R : Slice<T, From, To, Next<I>, IsOptional<T, I> extends true ? [...R, T[I]?] : [...R, T[I]]>;
 declare type IsOptional<T extends readonly unknown[], I extends number> = [
     {
         [K in T['length'] as K]: K extends I ? never : unknown;
@@ -19,10 +19,10 @@ declare type IsOptional<T extends readonly unknown[], I extends number> = [
 ] extends [never] ? true : false;
 declare type ToTuple<T extends readonly unknown[], I extends number = 0, R extends unknown[] = []> = any[] extends T ? T[0][] : I extends T['length'] ? R : ToTuple<T, Next<I>, [...R, T[I]]>;
 declare type Tuple<L extends number, T = unknown, R extends unknown[] = []> = number extends L ? T[] : L extends R['length'] ? R : Tuple<L, T, [T, ...R]>;
-declare type Head<T extends [unknown, ...unknown[]]> = T[0];
-declare type Tail<T extends [unknown, ...unknown[]]> = T extends [unknown, ...infer R] ? R : never;
-declare type Last<T extends unknown[]> = T[Prev<T['length']>];
-declare type Init<T extends [unknown, ...unknown[]]> = T extends [...infer R, unknown] ? R : never;
+declare type Head<T extends readonly [unknown, ...unknown[]]> = T[0];
+declare type Tail<T extends readonly [unknown, ...unknown[]]> = T extends [unknown, ...infer R] ? R : never;
+declare type Last<T extends readonly unknown[]> = T[Prev<T['length']>];
+declare type Init<T extends readonly [unknown, ...unknown[]]> = T extends [...infer R, unknown] ? R : never;
 declare type IsUnknown<T> = unknown extends T ? IsAny<T> extends false ? true : false : false;
 declare type IsAny<T> = Extends<T | anything, T & anything>;
 declare type Extends<A, B> = [A] extends [B] ? true : false;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "free-types-core",
-    "version": "0.8.4",
+    "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",