free-types-core 0.9.0 → 1.0.0

package/dist/$Before.d.ts

@@ -0,0 +1,52 @@
+import { Const } from "./Const";
+import { _apply } from "./apply";
+import { Next, ArrayLike } from "./utils";
+import { Contra, NamedConstraints } from "./Type";
+type Type = {
+    type: any;
+    constraints: any;
+    names: any;
+    arg: any;
+};
+type Unconstrained = {
+    [k: number]: unknown;
+};
+export type $Before<$T extends Type, $P extends ContraIndex<$P, $T, I>, I extends number = never> = [I] extends [never] ? $BeforeN<$T, $P> : $BeforeI<$T, $P, I>;
+interface $BeforeI<$T extends Type, $P extends Type, I extends number, Constraints extends Unconstrained = ReplaceAt<$T['constraints'], I, Const<$P['constraints'][0]>>> extends $Type<$T> {
+    type: _apply<$T, ReplaceAt<this['arguments'], I, $P>>;
+    constraints: Constraints;
+    contra: Contra<Constraints>;
+    namedConstraints: NamedConstraints<this>;
+}
+interface $BeforeN<$T extends Type, $P extends Type, Constraints extends Unconstrained = $T['constraints'] extends infer I extends unknown[] ? {
+    [K in keyof I]: $P['constraints'][0];
+} : unknown[]> extends $Type<$T> {
+    type: _apply<$T, this['arguments'] extends (infer I extends ArrayLike) & unknown[] ? {
+        [K in keyof I]: _apply<$P, [I[K]]>;
+    } : ArrayLike>;
+    constraints: Constraints;
+    contra: Contra<Constraints>;
+    namedConstraints: NamedConstraints<this>;
+}
+interface $Type<$T extends Type> {
+    [k: number]: unknown;
+    names: $T['names'];
+    arg: $T['arg'];
+    arguments: unknown[];
+}
+type ContraIndex<$T extends Type, M extends Type, I extends number, Model = [I] extends [never] ? M['constraints'][number] : M['constraints'][I]> = [Model] extends $T['constraints'] ? {
+    constraints: any[];
+    type: Model;
+    names: any;
+    arg: any;
+} : {
+    constraints: [Model];
+    type: Model;
+    names: any;
+    arg: any;
+};
+type ReplaceAt<T extends {
+    [k: number]: unknown;
+    length: number;
+}, N extends number, $P extends Type, L extends number = T['length'], I extends number = 0, R extends unknown[] = []> = I extends L ? R : ReplaceAt<T, N, $P, L, Next<I>, [...R, I extends N ? _apply<$P, [T[I]]> : T[I]]>;
+export {};

package/dist/Const.d.ts

@@ -3,24 +3,26 @@ export { Const, $Const };
 /**
  * Turn a type `T` into a constant `Type<❋, T>`, totally ignoring arity and type constraints on its input.
 */
-declare type Const<T> = {
+type Const<T> = ConstantType<{
     type: T;
+}, {
     constraints: any;
+    names: any;
+}>;
+interface ConstantType<Out extends {
+    type: any;
+}, __> {
+    [k: number]: any;
+    type: Out['type'];
     arguments: any[] & {
         length: any;
     };
-    labels: any;
-    0: any;
-    1: any;
-    2: any;
-    3: any;
-    4: any;
-    5: any;
-    6: any;
-    7: any;
-    8: any;
-    9: any;
-};
+    namedConstraints: any;
+    arg: any;
+    constraints: any;
+    names: any;
+    contra: any;
+}
 /**
  * Turn the input into a constant `Type<❋, T>`, totally ignoring arity and type constraints on its input.
 */

package/dist/Flow.d.ts

@@ -0,0 +1,31 @@
+import { _apply, _Type } from './apply';
+import { Type } from './Type';
+import { Next } from './utils';
+export { Flow };
+type Flow<$Ts extends Composable, Composable extends (_Type & {
+    contra: any;
+})[] = $Ts extends [_Type] ? [_Type] : Check<$Ts>> = Composition<{
+    type: Fallback<$Ts>;
+    constraints: $Ts[0]['constraints'];
+    names: $Ts[0]['names'];
+}, $Ts>;
+type Descriptor = {
+    type: any;
+    constraints: any;
+    names: any;
+};
+interface Composition<D extends Descriptor, $Ts extends (_Type & {
+    contra: any;
+})[]> extends Type {
+    type: unknown[] extends this['arguments'] ? D['type'] : Pipe<[_apply<$Ts[0], this['arguments']>], $Ts>;
+    names: D['names'];
+    constraints: D['constraints'];
+    contra: $Ts[0]['contra'];
+    namedConstraints: $Ts[0]['namedConstraints'];
+}
+type Fallback<$Ts> = $Ts extends [...any, infer $T extends {
+    type: unknown;
+}] ? $T['type'] : never;
+export type Check<T extends unknown[], R extends _Type[] = [], Last extends _Type[] = []> = T extends [infer A extends _Type, infer B extends _Type, ...infer Rest] ? Check2<A, B> extends infer C extends [_Type, _Type] ? Check<Rest, [...R, ...Last, C[0]], [C[1]]> : never : T extends [infer A extends _Type, infer B extends _Type] ? [...R, ...Last, ...Check2<A, B>] : T extends [infer A extends _Type] ? Last extends [] ? [...R, A] : [...R, ...Check2<Last[0], A>] : [...R, ...Last];
+type Check2<A extends _Type, B extends _Type> = A['type'] extends B['constraints'][0] ? [A, B] : [Type<A['constraints'], B['constraints'][0]>, B];
+type Pipe<Args extends unknown[], $Ts extends _Type[], I extends number = 1, R = _apply<$Ts[I], Args>, N extends number = Next<I>> = N extends $Ts['length'] ? R : R extends $Ts[N]['constraints'][0] ? Pipe<[R], $Ts, N> : never;

package/dist/Flow.js

@@ -0,0 +1 @@
+export {};

package/dist/From.d.ts

@@ -0,0 +1,67 @@
+import { NamedConstraints } from './Type';
+import { ArrayLike, Next, IsOptional, Mappable, Union2Tuple, Int } from './utils';
+export { From };
+type Named = ({
+    [k: PropertyKey]: string;
+} | undefined)[];
+/** Create a new `Type` based upon a Mappable `T`.
+ *
+ * Optionally take a tuple `Args` to specify which fields to turn into a parameter and in what order they must be applied. Parameters can be set to be optional. Named parameters are created automatically for object types, they can be renamed.
+ *
+ * */
+type From<T extends Mappable<any>, Args extends readonly (keyof T | undefined)[] | Named = never> = ([
+    Args
+] extends [never] ? (T extends unknown[] ? GetIndices<T> : Union2Tuple<keyof T>) extends infer K ? {
+    type: T;
+    constraints: PseudoTuple<T, K>;
+    names: {};
+    keys: K;
+} : never : Args extends Named ? {
+    type: T;
+    constraints: ToConstraints<T, Args>;
+    names: GetNames<Args>;
+    keys: GetKeys<Args>;
+} : {
+    type: T;
+    constraints: PseudoTuple<T, Args>;
+    names: Args extends (string | undefined)[] ? GenerateNames<Args> : {};
+    keys: Required<Args>;
+}) extends infer D extends Descriptor ? FromTemplate<D> : never;
+type Descriptor = {
+    type: any;
+    constraints: any;
+    names: any;
+    keys: any;
+};
+interface FromTemplate<D extends Descriptor> {
+    [k: number]: unknown;
+    type: D['type'] extends infer Type ? unknown[] extends this['arguments'] ? Type : {
+        [K in keyof Type]: Value<Type[K], this['arguments'], IndexOf<K, D['keys']>, D['constraints']>;
+    } : never;
+    namedConstraints: NamedConstraints<D>;
+    names: D['names'];
+    constraints: D['constraints'];
+    arguments: unknown[];
+}
+type GetIndices<T extends unknown[]> = {
+    [K in keyof T]-?: K;
+};
+export type Value<T, This extends ArrayLike, I, Constraints extends ArrayLike> = [
+    I
+] extends [never] ? T : This[I & number] extends infer Arg ? (IsOptional<Constraints, I> extends true ? Arg extends undefined ? T : Arg : Arg) : never;
+export type IndexOf<T, Ts extends ArrayLike, L = Required<Ts>['length'], I = 0> = I extends L ? never : [T] extends [`${Ts[I & number]}`] ? I : IndexOf<T, Ts, L, Next<I>>;
+type PseudoTuple<T, Keys> = {
+    [K in keyof Keys]: Exclude<T[Keys[K] & keyof T], undefined>;
+};
+type ToConstraints<T, Args extends Named> = {
+    [K in keyof Args]: T[keyof (Args[K] & {}) & keyof T];
+};
+type GetKeys<Args extends Named, R = Required<Args>> = {
+    [K in keyof R]: keyof R[K];
+};
+type GetNames<Args extends Named, T extends Required<Named> = Required<Args>> = unknown & {
+    [K in keyof T as T[K & `${number}`][keyof T[K]]]: Int<K>;
+};
+type GenerateNames<Args extends (string | undefined)[]> = unknown & {
+    [K in Exclude<keyof Args, keyof []> as Args[K] & string]: Int<K>;
+};

package/dist/From.js

@@ -0,0 +1 @@
+export {};

package/dist/Pipe.d.ts

@@ -0,0 +1,27 @@
+import { Next } from "./utils";
+import { _apply, apply, _Type as Type } from './apply';
+type _Type<C = any> = {
+    type: any;
+    constraints: C;
+};
+type TooManyArgs = 'You can compose up to 10 free types with Pipe';
+type WrongArg = 'would be called with wrong argument';
+/** Pipe an arguments list or named arguments through a composition of free types
+ * ```
+ * type Foo = Pipe<[1, 2], $Add, $Next, $Exclaim> // "4!"
+ * ```
+ * ---
+ * **Note**: Error messages are narrower than they need to be:
+ * ```
+ * Pipe<['foo'], $Exclain, $Next>
+ * //                      ~~~~~
+ * // Type<[number], number>' does not satisfy the constraint 'Type<["foo!"], number>
+ * ```
+ * Understand it as `Type<[number], number>` would be called with wrong argument `"foo!"`. This inconvenience is required for generic higher order compositions to work properly.
+ */
+export type Pipe<Args extends [STOP] extends [never] ? Check : TooManyArgs, A extends Type = never, B extends _<B, WrongArg, RA> = never, C extends _<C, WrongArg, RB> = never, D extends _<D, WrongArg, RC> = never, E extends _<E, WrongArg, RD> = never, F extends _<F, WrongArg, RE> = never, G extends _<G, WrongArg, RF> = never, H extends _<H, WrongArg, RG> = never, I extends _<I, WrongArg, RH> = never, J extends _<J, WrongArg, RI> = never, STOP = never, RA = apply<A, Args, any>, RB = _apply<B, [RA]>, RC = _apply<C, [RB]>, RD = _apply<D, [RC]>, RE = _apply<E, [RD]>, RF = _apply<F, [RE]>, RG = _apply<G, [RF]>, RH = _apply<H, [RG]>, RI = _apply<I, [RH]>, RJ = _apply<J, [RI]>, Check = Args extends readonly unknown[] ? A['constraints'] : A['namedConstraints']> = Result<[RA, RB, RC, RD, RE, RF, RG, RH, RI, RJ]>;
+type Result<T extends unknown[], I extends number = 0, R = never> = [
+    T[I]
+] extends [never] ? R : I extends T['length'] ? R : Result<T, Next<I>, T[I]>;
+type _<$T extends _Type, _, $U> = [$U] extends $T['constraints'] ? any : _Type<[$U]>;
+export {};

package/dist/Pipe.js

@@ -0,0 +1 @@
+export {};

package/dist/Replace.d.ts

@@ -1,9 +1,9 @@
 import { unwrap, Unwrapped, Search } from './unwrap';
-import { apply } from './apply';
+import { _apply } from './apply';
 import { TypesMap } from './TypesMap';
 export { Replace };
 /** Replace the inner value of a type with compatible arguments.
  *
  *  Can be used to constrain the inner value of a type
  */
-declare type Replace<T, Args extends U['type']['constraints'], From extends Search = TypesMap, U extends Unwrapped = unwrap<T, From>> = apply<U['type'], Args>;
+type Replace<T, Args extends U['type']['constraints'], From extends Search = TypesMap, U extends Unwrapped = unwrap<T, From>> = _apply<U['type'], Args>;

package/dist/Type.d.ts

@@ -1,32 +1,83 @@
-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, Labels extends string[] = []> = CreateType<{
-    type: Output;
-    constraints: Constraints<Input, Slots<Input>>;
-    arguments: unknown[];
-    labels: ReverseMap<Labels>;
+import { Tuple, ToTuple, Int, Slice, ArrayLike, ArrayKeys, OptionalKeys, IsAny, NumericKeys } from './utils';
+export { Type, Input, Arg, NamedConstraints, Contra };
+/** Extend `Type<Input?, Output?>` with an interface to produce a free type, or use it as a type constraint.
+*/
+type Type<In extends Input = any, Out = unknown> = CreateType<{
+    type: Out;
+}, {
+    constraints: Constraints<In>;
+    names: In extends Detailed ? {
+        [K in Exclude<keyof In, symbol>]: GetIndex<In[K]>;
+    } : None;
 }>;
-interface CreateType<T extends {
-    type: unknown;
-    constraints: unknown[];
-    labels: {
-        [k: string]: number;
-    };
-}> {
+type None = {};
+type Descriptor = {
+    constraints: any;
+    names: any;
+};
+type Input = number | readonly unknown[] | PseudoTuple | Detailed;
+type PseudoTuple = {
+    [k: number]: any;
+    length?: number;
+};
+type Detailed = {
+    [k: string]: [index: number, constraint?: unknown] | number;
+    [k: number]: never;
+};
+interface CreateType<Out extends {
+    type: any;
+}, T extends Descriptor> {
     [k: number]: unknown;
-    type: T['type'];
+    type: Out['type'];
     constraints: T['constraints'];
+    contra: Contra<T['constraints']>;
+    namedConstraints: NamedConstraints<T>;
+    arg: Arg<this>;
     arguments: unknown[];
-    labels: T['labels'];
+    names: T['names'];
 }
-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;
+type Contra<T extends Variadic> = any[] extends T ? IsAny<T[number]> extends true ? (constraints: any) => void : (constraints: {
+    [k: number]: T[number];
+}) => void : NumericKeys<T> extends infer Keys extends number ? Int<OptionalKeys<T>> extends infer O extends number ? (constraints: unknown & {
+    [K in Keys as K extends O ? never : K]: T[K];
+} & {
+    [K in Keys as K extends O ? K : never]?: T[K];
+}) => void : never : never;
+type NamedConstraints<T extends {
+    constraints: any;
+    names: any;
+}, O = Int<OptionalKeys<T['constraints']>>> = {
+    [K in keyof T['names'] as T['names'][K] extends O ? never : K]: T['constraints'][T['names'][K]];
+} & {
+    [K in keyof T['names'] as T['names'][K] extends O ? K : never]?: T['constraints'][T['names'][K]];
+};
+type _Type = {
+    [k: number]: unknown;
+    constraints: ArrayLike;
+    names: {
+        [k: string]: number;
+    };
+};
+type Arg<This extends _Type, Args = This['names'] & This['constraints'], O extends PropertyKey = FindOptionalKeys<This['constraints'], This['names']>, R extends PropertyKey = Exclude<Norm<Exclude<keyof Args, ArrayKeys>>, O>> = {
+    [K in Norm<R>]: ArgVal<This, K>;
+} & {
+    [K in Norm<O>]?: ArgVal<This, K>;
 };
-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 = {
-    [I in Precomputable]: Tuple<Seq10[I]>;
+type FindOptionalKeys<Constraints, Names, O = Int<OptionalKeys<Constraints>>> = O | (keyof {
+    [K in keyof Names as Names[K] extends O ? K : never]: never;
+});
+type ArgVal<This extends _Type, K> = K extends `${number}` | number ? Int<K> extends infer Key extends number ? GetValue<This, Key> : never : K extends string ? GetValue<This, This['names'][K]> : never;
+type GetValue<This extends _Type, I extends number> = This['constraints'][I] extends infer Constraint ? This[I] extends Constraint ? This[I] : Constraint & This[I] : never;
+type Norm<T> = T extends `${number}` ? Int<T> : T;
+type Unconstrained = {
+    [k: number]: any;
 };
-declare type Precomputable = Seq10[number];
-declare type Seq10 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+type Variadic = {
+    [k: number]: unknown;
+};
+type Constraints<T> = IsAny<T> extends true ? Unconstrained : unknown[] extends T ? IsAny<Extract<T, unknown[]>[number]> extends true ? Unconstrained : Variadic : readonly unknown[] extends T ? Variadic : T extends readonly unknown[] ? T : T extends number ? number extends T ? Variadic : Tuple<T, any> : T extends Detailed ? DetailedToConstraints<T> : T extends PseudoTuple ? T extends ArrayLike ? Slice<T, 0, T['length']> : ToTuple<T> : Variadic;
+type DetailedToConstraints<T extends Detailed> = ToTuple<{
+    [K in keyof T as GetIndex<T[K]>]: GetConstraint<T[K]>;
+}>;
+type GetIndex<T> = Exclude<T extends [infer N extends number, any?] ? N : T, undefined>;
+type GetConstraint<T> = Exclude<T, undefined> extends [any, infer C] ? C : unknown;

package/dist/TypeDoc.d.ts

@@ -0,0 +1,15 @@
+export { TypeDoc };
+type Type = {
+    type: any;
+    constraints: any;
+    names: any;
+};
+type TypeDoc<$T extends Type> = CreateType<{
+    type: $T['type'];
+}, {
+    constraints: $T['constraints'];
+    names: $T['names'];
+}, $T>;
+/** @ts-ignore: Nasty hack */
+interface CreateType<_, __, $T extends {}> extends $T {
+}

package/dist/TypeDoc.js

@@ -0,0 +1 @@
+export {};

package/dist/apply.d.ts

@@ -1,46 +1,49 @@
 import { Type } from './Type';
-import { ArrayKeys, Next } from './utils';
-declare type NamedType = {
+import { ArrayLike, ArrayKeys, Indexable, Next } from './utils';
+export { apply, _apply, _applyPositional as applyPositional, $apply, Generic, _Type };
+/** A type definition to be used as a type constraint in internal library code to improve performance */
+type _Type<I = any, O = unknown> = {
+    type: O;
+    constraints: I;
+    names: any;
+    namedConstraints: any;
+};
+type PositionalType = {
     type: unknown;
-    constraints: {
-        [k: number]: unknown;
-        length: number;
-    };
-    labels: Labels;
+    constraints: Indexable;
 };
-declare type Labels = {
+type Names = {
     [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 {
+/** Apply a free type with all its arguments and evaluate the type */
+type apply<$T extends _Type, Args extends Check = never, Check = Args extends ArrayLike ? $T['constraints'] : $T['namedConstraints']> = applyPositional<$T, ([
+    Args
+] extends [never] ? [] : Args extends ArrayLike ? Args : Args extends {
+    [k: string]: unknown;
+} ? ToPositional<GetLength<$T['constraints']>, Args, RecoverNames<$T['names']>> : [])>;
+type GetLength<T> = Extract<T extends ArrayLike ? T['length'] : number, number>;
+type _applyPositional<$T extends PositionalType, Args extends $T['constraints'] = []> = applyPositional<$T, Args>;
+type ToPositional<L extends number, Args extends {
     [k: string]: unknown;
-}, Labels extends {
+}, Names 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]];
+}, I extends number = 0, R extends any[] = []> = I extends L ? R : ToPositional<L, Args, Names, Next<I>, [...R, Args[Names[I]]]>;
+type RecoverNames<T extends Names> = {
+    [K in keyof T as T[K]]: K;
 };
-interface $apply<Args extends unknown[] = []> extends Type<[Type]> {
-    type: apply<this[0] extends Type ? this[0] : Type, Args>;
+interface $apply<Args extends ArrayLike = []> extends Type<[_Type]> {
+    type: this[0] extends _Type ? _apply<this[0], Args> : unknown;
 }
 /** Apply a free type `$T` with its type constraints. */
-declare type Generic<$T extends Type> = _apply<$T, $T['constraints']>;
-declare type applyPositional<$T extends {
-    type: unknown;
-    constraints: {
-        length: number;
-    };
-}, Args extends unknown[]> = number extends $T['constraints']['length'] ? _apply<$T, Args> : _apply<$T, Take<Args, Required<$T['constraints']>['length']>>;
-declare type _apply<T extends {
+type Generic<$T extends _Type> = _apply<$T, $T['constraints']>;
+type applyPositional<$T extends PositionalType, Args extends Indexable> = number extends GetLength<$T['constraints']> ? _apply<$T, Args> : _apply<$T, Take<Args, 0, GetLength<Required<$T['constraints']>>>>;
+/** A looser version of `apply` which can be used in internal library code to improve performance */
+type _apply<$T extends {
     type: unknown;
-}, Args> = (T & Omit<Args, ArrayKeys> & {
+}, Args extends _Constraints> = ($T & Omit<Args, ArrayKeys> & {
     arguments: Args;
 })['type'];
-declare type Take<T extends unknown[], To extends number, I extends number = 0, R extends unknown[] = []> = I extends To ? R : Take<T, To, Next<I>, [...R, T[I]]>;
+type _Constraints = {
+    [k: number]: unknown;
+};
+type Take<T extends Indexable, From extends number, To, R extends any[] = []> = From extends To ? R : Take<T, Next<From>, To, [...R, T[From]]>;

package/dist/free-types.d.ts

@@ -1,38 +1,40 @@
 import { Type } from './Type';
-import { ToTuple } from './utils';
+type ToTuple<T> = T extends infer I extends unknown[] & unknown[] ? I : never;
 export { $Id as Id, $Record as Record, $Array as Array, $Tuple as Tuple, $ReadonlyTuple as ReadonlyTuple, $ReadonlyArray as ReadonlyArray, $Set as Set, $ReadonlySet as ReadonlySet, $WeakSet as WeakSet, $Map as Map, $ReadonlyMap as ReadonlyMap, $WeakMap as WeakMap, $Function as Function, $UnaryFunction as UnaryFunction, $Promise as Promise };
-interface $Id extends Type<1> {
+type $Unary = Type<1>;
+type $Binary = Type<2>;
+type $Variadic = Type;
+interface $Id extends $Unary {
     type: this[0];
 }
-declare type Key = string | number | symbol;
-interface $Record extends Type<[Key, unknown]> {
-    type: Record<this[0] & Key, this[1]>;
+interface $Record extends Type<[PropertyKey, unknown]> {
+    type: Record<this[0] & PropertyKey, this[1]>;
 }
-interface $Array extends Type<1> {
+interface $Array extends $Unary {
     type: Array<this[0]>;
 }
-interface $Tuple extends Type {
+interface $Tuple extends $Variadic {
     type: ToTuple<this['arguments']>;
 }
-interface $ReadonlyTuple extends Type {
-    type: Readonly<ToTuple<this['arguments']>>;
+interface $ReadonlyTuple extends $Variadic {
+    type: readonly [...ToTuple<this['arguments']>];
 }
-interface $ReadonlyArray extends Type<1> {
+interface $ReadonlyArray extends $Unary {
     type: ReadonlyArray<this[0]>;
 }
-interface $Set extends Type<1> {
+interface $Set extends $Unary {
     type: Set<this[0]>;
 }
-interface $ReadonlySet extends Type<1> {
+interface $ReadonlySet extends $Unary {
     type: ReadonlySet<this[0]>;
 }
 interface $WeakSet extends Type<[object]> {
     type: WeakSet<this[0] extends object ? this[0] : object>;
 }
-interface $Map extends Type<2> {
+interface $Map extends $Binary {
     type: Map<this[0], this[1]>;
 }
-interface $ReadonlyMap extends Type<2> {
+interface $ReadonlyMap extends $Binary {
     type: ReadonlyMap<this[0], this[1]>;
 }
 interface $WeakMap extends Type<[object, unknown]> {
@@ -41,10 +43,10 @@ interface $WeakMap extends Type<[object, unknown]> {
 interface $Function extends Type<[any[], unknown]> {
     type: (...args: this[0] extends any[] ? this[0] : any[]) => this[1];
 }
-interface $UnaryFunction extends Type<2> {
+interface $UnaryFunction extends $Binary {
     type: (a: unknown extends this[0] ? any : this[0]) => this[1];
 }
-interface $Promise extends Type<1> {
+interface $Promise extends $Unary {
     type: Promise<this[0]>;
 }
 declare global {

package/dist/helpers.d.ts

@@ -1,74 +1,94 @@
-import { Next, IsUnknown, Prev } from './utils';
-export { At, Checked, Lossy, Optional, A, B, C, D, E };
-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> = {
+import { Next, IsUnknown, Prev, OptionalKeys } from './utils';
+export { Get, At, Checked, Lossy, Optional, A, B, C, D, E, Applied };
+/** Fake `Type` for user friendly error messages */
+interface Type<In extends number | Names> extends BaseType {
+    arg: Constraints<In>;
+    constraints: Constraints<In>;
+    names: In extends number ? any : In;
+}
+type Constraints<In> = In extends number ? {
+    [K in Prev<In>]: unknown;
+} : any;
+/** Fake `Type` for user friendly error messages */
+interface OptionalType<In extends number | Names> extends BaseType {
+    constraints: Partial<Constraints<In>>;
+    names: In extends number ? any : In;
+}
+/** fast Type definition */
+interface BaseType {
     constraints: {
-        [K in Prev<N>]?: unknown;
+        [k: number]: unknown;
     };
-    arguments: unknown[];
-    labels: {
-        [k: string]: number;
+    arguments: {
+        [k: number]: unknown;
     };
+    names: Names;
+}
+type Names = {
+    [k: string]: number;
 };
-declare type Default = {
-    constraints: [0, 1, 2, 3, 4];
-    arguments: unknown[];
-    labels: {
-        [k: string]: number;
-    };
+type Normalise<Index extends string | number> = Index extends number ? Next<Index> : {
+    [K in Index]: number;
 };
+/** tell whether a Type is applied with all its arguments or not */
+type Applied<This extends {
+    arguments: any;
+}> = unknown[] extends This['arguments'] ? false : true;
+/** safely index `this` */
+type Get<K extends keyof This['arg'], This extends {
+    arg: any;
+}> = K extends OptionalKeys<This['arg']> ? Exclude<This['arg'][K], undefined> : This['arg'][K];
 /** - safely index `this`
  * - optionally take a fallback
 */
-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];
+type At<Index extends string | number, This extends Type<Normalise<Index>>, Fallback = unknown, I extends number = Index extends number ? Index : This['names'][Index]> = 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 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;
+type Checked<Index extends string | number, This extends Type<Normalise<Index>>, Fallback = Index extends number ? This['constraints'][Index] : This['constraints'][This['names'][Index]], I extends number = Index extends number ? Index : This['names'][Index]> = This['arguments'][I] extends This['constraints'][I] ? This['arguments'][I] : 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 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;
+type Optional<Index extends string | number, This extends OptionalType<Normalise<Index>>, Fallback = Index extends number ? Exclude<This['constraints'][Index], undefined> : Exclude<This['constraints'][This['names'][Index]], undefined>, I extends number = Index extends number ? Index : This['names'][Index]> = This['arguments'][I] extends Exclude<This['constraints'][I], undefined> ? This['arguments'][I] : Fallback;
 /** - safely index `this`
  * - intersect the corresponding type constraint
  */
-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]];
+type Lossy<Index extends string | number, This extends Type<Normalise<Index>>, I extends number = Index extends number ? Index : This['names'][Index]> = This['arguments'][I] & This['constraints'][I];
+interface NumericValue extends BaseType {
+    constraints: any;
+    arg: {
+        0: 0;
+        1: 1;
+        2: 2;
+        3: 3;
+        4: 4;
+    };
+}
 /** - safely index `this`
  * - intersect the corresponding type constraint
  * - equals `0` When no argument is supplied
 */
-declare type A<This extends Type<1> = Default> = This['arguments'][0] & This['constraints'][0];
+type A<This extends Type<1> = NumericValue> = Get<0, This>;
 /** - safely index `this`
  * - intersect the corresponding type constraint
  * - equals `1` When no argument is supplied
 */
-declare type B<This extends Type<2> = Default> = This['arguments'][1] & This['constraints'][1];
+type B<This extends Type<2> = NumericValue> = Get<1, This>;
 /** - safely index `this`
  * - intersect the corresponding type constraint
  * - equals `2` When no argument is supplied
 */
-declare type C<This extends Type<3> = Default> = This['arguments'][2] & This['constraints'][2];
+type C<This extends Type<3> = NumericValue> = Get<2, This>;
 /** - safely index `this`
  * - intersect the corresponding type constraint
  * - equals `3` When no argument is supplied
 */
-declare type D<This extends Type<4> = Default> = This['arguments'][3] & This['constraints'][3];
+type D<This extends Type<4> = NumericValue> = Get<3, This>;
 /** - safely index `this`
  * - intersect the corresponding type constraint
  * - equals `4` When no argument is supplied
 */
-declare type E<This extends Type<5> = Default> = This['arguments'][4] & This['constraints'][4];
+type E<This extends Type<5> = NumericValue> = Get<4, This>;

package/dist/hkt.d.ts

@@ -1,19 +1,15 @@
-import { Type } from "./Type";
-export { HKT, Contra };
+import { _Type } from "./apply";
+export { HKT, Contra, Expect };
 /** Interfaces extending this type are able to use `hkt` internally. */
-declare type HKT = {
+type HKT = {
     HKT: [any, ...any[]];
 };
-/** Expect a free type with contravariant arguments */
-declare type Contra<$T, $U extends Type> = Type & _Contra<$T, $U>['type'];
-interface _Contra<$T, $U extends Type> {
-    type: $U['constraints'] extends this['$T']['constraints'] ? this['$T']['type'] extends $U['type'] ? Type : Type<this['$T']['constraints'], $U['type']> : {
-        [K in 'Contravariance issue']: [
-            'the input',
-            $U['constraints'],
-            'is not assignable to',
-            this['$T']['constraints']
-        ];
-    };
-    $T: $T extends Type ? $T : never;
-}
+/** Expect a free type with contravariant arguments
+ * @deprecated use `Expect` instead
+ * */
+type Contra<$T, $U extends _Type> = _Contra<Extract<$T, _Type>, $U>;
+type _Contra<$T extends _Type, $U extends _Type> = $U['constraints'] extends $T['constraints'] ? $T['type'] extends $U['type'] ? _Type : _Type<$T['constraints'], $U['type']> : _Type<[$U['constraints'], 'is not assignable to', $T['constraints']]>;
+type Expect<$T, Active extends boolean = true> = Active extends false ? $T : {
+    [K in keyof $T]: K extends CovariantKey ? any : $T[K];
+};
+type CovariantKey = 'namedConstraints' | 'constraints' | 'arg' | 'names';

package/dist/index.d.ts

@@ -1,8 +1,12 @@
 export * from './apply';
 export * from './partial';
-export * from './Remaining';
-export * from './Type';
+export { Type, Input } from './Type';
+export * from './TypeDoc';
 export * from './Const';
+export { From } from './From';
+export { Flow } from './Flow';
+export * from './$Before';
+export * from './Pipe';
 export * from './helpers';
 export * from './inferArgs';
 export * from './unwrap';

package/dist/index.js

@@ -1,8 +1,9 @@
 export * from './apply';
 export * from './partial';
-export * from './Remaining';
-export * from './Type';
+export * from './TypeDoc';
 export * from './Const';
+export * from './$Before';
+export * from './Pipe';
 export * from './helpers';
 export * from './inferArgs';
 export * from './unwrap';

package/dist/inferArgs.d.ts

@@ -1,7 +1,6 @@
-import { Type } from './Type';
-import { apply } from './apply';
+import { _apply, _Type } from './apply';
 export { inferArgs };
-declare type inferArgs<T, $T extends Type> = T extends apply<$T, [
+type inferArgs<T, $T extends _Type> = T extends _apply<$T, [
     infer A,
     infer B,
     infer C,

package/dist/partial.d.ts

@@ -1,20 +1,55 @@
-import { Type } from './Type';
-import { apply } from './apply';
-import { Slice, Subtract, ToTuple } from './utils';
+import { Arg, Type, NamedConstraints, Contra } from './Type';
+import { _apply, _Type } from './apply';
+import { ArrayKeys, ArrayLike, Int, Next, Slice, Subtract, Tuple } from './utils';
 export { partial, partialRight, PartialRight, $partial };
 export { PartialType };
-/** Return a new type based upon `$T`, with `Args` already applied, expecting the remaining arguments */
-declare type partial<$T extends Type, Args extends Partial<$Model['constraints']>, $Model extends Type = $T> = $T extends $Model ? Args extends unknown[] ? _partial<$T, Args> : never : never;
+/** Return a new type based upon `$T`, with `Args` already applied, expecting the constraints arguments */
+type partial<$T extends _Type, Args extends Partial<$Model['constraints']>, $Model extends _Type = $T> = $T extends $Model ? Args extends unknown[] ? _partial<$T, Args> : never : never;
 /** A free version of `partial` */
-interface $partial<$T extends Type> extends Type<1> {
+interface $partial<$T extends _Type> extends Type<1> {
     type: _partial<$T, [this['arguments'][0]]>;
 }
-declare type _partial<$T extends Type, Args extends unknown[]> = PartialType<$T, Args, Slice<$T['constraints'], Args['length'], Required<$T['constraints']>['length']>, 'left'>;
+type _partial<$T extends _Type, Args extends ArrayLike, From extends number = Args['length'], To = Required<$T['constraints']>['length']> = PartialType<{
+    type: $T['type'];
+    constraints: Slice<$T['constraints'], From, To>;
+    names: FilterNamesLeft<$T['names'], Args>;
+    applied: Args;
+    direction: 'left';
+}, $T>;
+type FilterNamesLeft<T, Args extends ArrayLike> = unknown & {
+    [K in keyof T as T[K] extends Int<Exclude<keyof Args, ArrayKeys>> ? never : K]: Subtract<T[K] & number, Args['length']>;
+};
 /** Return a new type based upon `$T`, with `Args` already applied to the rightmost parameters of `$T`, and expecting the remaining arguments */
-declare type partialRight<$T extends Type, Args extends PartialRight<$Model['constraints']>, $Model extends Type = $T> = $T extends $Model ? PartialType<$T, Args, Slice<$T['constraints'], 0, Subtract<Required<$T['constraints']>['length'], Args['length']>>, 'right'> : never;
-declare type PartialRight<T extends unknown[], R = never> = T extends [unknown, ...(infer Rest)] ? PartialRight<Rest, T | R> : [] | R;
-interface PartialType<$T extends Type, Applied extends unknown[], Constraints extends unknown[], Direction> extends Type {
-    type: apply<$T, Direction extends 'left' ? [...Applied, ...ToTuple<this['arguments']>] : [...ToTuple<this['arguments']>, ...Applied]>;
+type partialRight<$T extends _Type, Args extends PartialRight<$Model['constraints']>, $Model extends _Type = $T> = $T extends $Model ? _partialRight<$T, Args, Subtract<Required<$T['constraints']>['length'], Args['length']>> : never;
+type _partialRight<$T extends _Type, Args extends ArrayLike, To> = Slice<$T['constraints'], 0, To> extends infer Constraints ? PartialType<{
+    type: $T['type'];
     constraints: Constraints;
+    names: FilterNamesRight<$T['names'], Constraints>;
+    applied: Args;
+    direction: 'right';
+}, $T> : never;
+type FilterNamesRight<T, Args> = unknown & {
+    [K in keyof T as T[K] extends Int<Exclude<keyof Args, ArrayKeys>> ? K : never]: T[K];
+};
+type PartialRight<T extends unknown[], R = never> = T extends [unknown, ...(infer Rest)] ? PartialRight<Rest, T | R> : [] | R;
+type Descriptor = {
+    applied: any;
+    direction: any;
+    constraints: any;
+    names: any;
+};
+interface PartialType<D extends Descriptor, $T extends _Type> {
+    [k: number]: unknown;
+    type: _apply<$T, D['direction'] extends 'left' ? [...D['applied'], ...Complement<this['arguments'], D['constraints']>] : [...Complement<this['arguments'], D['constraints']>, ...D['applied']]>;
+    names: D['names'];
+    namedConstraints: NamedConstraints<{
+        names: D['names'];
+        constraints: D['constraints'];
+    }>;
+    arg: Arg<this>;
+    constraints: D['constraints'];
+    contra: Contra<D['constraints']>;
     arguments: unknown[];
 }
+type Complement<Args extends unknown[], Constraints extends unknown[]> = unknown[] extends Args ? Tuple<Constraints['length']> : _Complement<Constraints['length'], Args['length'], Args extends unknown[] & infer I extends unknown[] ? I : never>;
+type _Complement<L, I, R extends unknown[]> = I extends L ? R : _Complement<L, Next<I>, [...R, unknown]>;

package/dist/unwrap.d.ts

@@ -1,12 +1,12 @@
-import { ArrayKeys, Eq, And, Extends, Not, IsAny } from './utils';
+import { ArrayKeys, Eq, IsAny } from './utils';
 import { Type } from './Type';
 import { inferArgs } from './inferArgs';
-import { Generic, apply } from './apply';
+import { Generic, _apply, _Type } from './apply';
 import { TypesMap } from './TypesMap';
 import { Tuple, ReadonlyTuple, Array, ReadonlyArray } from './free-types';
-declare type Search = Type | SearchList;
-declare type SearchList = Type[] | Record<string, Type> | Interface;
-declare type Interface = {
+type Search = _Type | SearchList;
+type SearchList = _Type[] | Record<string, _Type> | Interface;
+type Interface = {
     [k: string]: any;
 } & {
     [Symbol.toStringTag]?: never;
@@ -22,21 +22,17 @@ declare global {
 }
 export { unwrap, Unwrapped, Search };
 /** Decompose a type into its constituents */
-declare type unwrap<T, From extends Search = TypesMap> = IsAny<T> extends true ? Any : And<Extends<T, readonly unknown[]>, Not<Extends<From, Type | Type[]>>> extends true ? unwrapLists<T extends readonly unknown[] ? T : never> : _unwrap<T, From extends Type ? [From] : From>;
-declare type unwrapLists<T> = T extends unknown[] ? T extends [unknown, ...unknown[]] ? Unwrapped<'Tuple', Tuple, T> : Unwrapped<'Array', Array, [T[0]]> : T extends readonly [unknown, ...unknown[]] ? Unwrapped<'ReadonlyTuple', ReadonlyTuple, Mutable<T>> : Unwrapped<'ReadonlyArray', ReadonlyArray, [(T & unknown[])[0]]>;
-declare type Mutable<T> = {
-    -readonly [K in keyof T]: K extends ArrayKeys ? T[K] : T[K];
+type unwrap<T, From extends Search = TypesMap> = IsAny<T> extends true ? Any : (T extends readonly unknown[] ? From extends _Type | _Type[] ? null : unwrapLists<T> : null) extends infer R extends Unwrapped ? R : _unwrap<T, From extends _Type ? [From] : From>;
+type unwrapLists<T extends readonly unknown[]> = T extends unknown[] ? any[] extends T ? Unwrapped<'Array', Array, [T[0]]> : Unwrapped<'Tuple', Tuple, T> : readonly any[] extends T ? Unwrapped<'ReadonlyArray', ReadonlyArray, [T[0]]> : Unwrapped<'ReadonlyTuple', ReadonlyTuple, Mutable<T>>;
+type Mutable<T> = {
+    -readonly [K in keyof T]: T[K];
 };
-declare type _unwrap<T, From extends SearchList, R = {
-    [K in keyof From as K extends ArrayKeys ? never : K extends string ? K : never]: From[K] extends Type ? Branch<T, From[K], K>[T extends Generic<From[K]> ? 'match' : 'miss'] : never;
-}> = R[keyof R];
-interface Branch<T, $T extends Type, K> {
-    match: Disambiguate<T, $T, inferArgs<T, $T>, K & string>;
-    miss: never;
-}
-declare type Disambiguate<T, $T extends Type, Args extends unknown[], K extends string> = Eq<T, apply<$T, Args>> extends true ? Unwrapped<K, $T, Args> : never;
+type _unwrap<T, From> = {
+    [K in keyof From as K extends ArrayKeys ? never : K extends string ? K : never]: From[K] extends _Type ? T extends Generic<From[K]> ? Disambiguate<T, From[K], inferArgs<T, From[K]>, K & string> : never : never;
+} extends infer R ? R[keyof R] : never;
+type Disambiguate<T, $T extends _Type, Args extends unknown[], K extends string> = Eq<T, _apply<$T, Args>> extends true ? Unwrapped<K, $T, Args> : never;
 /** The result of unwrapping a type with `unwrap` */
-declare type Unwrapped<URI extends string = string, T extends Type = Type, A = unknown[]> = {
+type Unwrapped<URI extends string = string, T extends _Type = Type, A = unknown[]> = {
     URI: URI;
     type: T;
     args: A;
@@ -44,4 +40,4 @@ declare type Unwrapped<URI extends string = string, T extends Type = Type, A = u
 interface $Any extends Type {
     type: any;
 }
-declare type Any = Unwrapped<'any', $Any, any>;
+type Any = Unwrapped<'any', $Any, any>;

package/dist/utils.d.ts

@@ -1,34 +1,69 @@
-export { Natural, Prev, Next, Subtract };
-export { ArrayKeys, Slice, ToTuple, Tuple, Head, Tail, Last, Init };
-export { Extends, Eq, And, Not, IsUnknown, IsAny, IsOptional };
-declare type Natural = [0, ..._Next];
-declare type Prev<I extends number> = number extends I ? number : number & _Prev[I];
-declare type _Prev = [never, ...Natural];
-declare type Next<I extends number> = number extends I ? number : number & _Next[I];
-declare type _Next = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64];
-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 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;
-    }[I]
-] 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 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;
-declare type Eq<A, B> = [A] extends [B] ? [B] extends [A] ? true : false : false;
-declare type And<A, B> = Fork<A, Fork<B, B, false>, false>;
-declare type Fork<P, T, F> = P extends false ? F : T;
-declare type Not<T> = Extends<T, false>;
+export { Int, Cardinal as Natural, Prev, Next, Subtract };
+type Int<T> = T extends `${infer I extends number}` ? I : T & number;
+type Next<I> = number & _Next[I & number];
+interface _Next extends Numeric, __Next {
+}
+type __Next = Omit<Natural, ArrayKeys>;
+type Prev<I> = number & _Prev[I & number];
+interface _Prev extends Numeric, __Prev {
+}
+type __Prev = Omit<[never, ...Cardinal], ArrayKeys>;
+type Natural = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64];
+type Cardinal = [0, ...Natural];
+interface Numeric {
+    [k: number]: number;
+}
+type Subtract<A extends number, B extends number> = number extends A ? number : number extends B ? number : _Subtract<A, B>;
+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>;
+export { Mappable, OptionalKeys, ReverseMap };
+type Mappable<T = unknown> = {
+    [k: PropertyKey]: T | undefined;
+} | readonly (T | undefined)[];
+type OptionalKeys<T> = {
+    [K in keyof T as K extends ArrayKeys ? number extends K ? never : K extends number ? K : never : K]-?: {} extends {
+        [P in K]: T[P];
+    } ? K : never;
+} extends infer U ? U[keyof U] : never;
+type ReverseMap<T extends {
+    [k: string]: any;
+}> = {
+    [K in keyof T as T[K]]: K;
+};
+export { ArrayLike, Indexable, ArrayKeys, Slice, ToTuple, Tuple, NumericKeys, Head, Tail, Last, Init, IsOptional, GetRest };
+type ArrayKeys = Exclude<keyof [], never>;
+type ArrayLike = {
+    [k: number]: any;
+    length: any;
+};
+type Indexable = {
+    [k: number]: any;
+};
+type Slice<T extends Indexable, From extends number, To = T extends ArrayLike ? Required<T>['length'] : number, R extends any[] = [], Optional = Int<OptionalKeys<T>>> = number extends To ? SliceOpenEnded<T, From> : SliceOptional<T, From, To, R, Optional>;
+type SliceOpenEnded<T extends Indexable, I> = I extends 0 ? T : T extends [unknown, ...infer R] ? SliceOpenEnded<R, Prev<I>> : never;
+type SliceOptional<T extends Indexable, I, To, R extends any[], Optional> = I extends To ? R : SliceOptional<T, Next<I>, To, I extends Optional ? [...R, T[I & number]?] : [...R, T[I & number]], Optional>;
+type IsOptional<T extends {
+    length: any;
+}, I> = (T['length'] extends infer L ? L extends I ? true : false : never) extends false ? false : true;
+type NumericKeys<T> = Int<ExcludeNumber<keyof T>>;
+type ExcludeNumber<T> = T extends any ? number extends T ? never : T : never;
+type ToTuple<T extends {
+    [k: number]: unknown;
+    length?: number;
+}, Keys extends number = NumericKeys<T>, Optionals = Int<OptionalKeys<T>>, I extends number = 0, R extends unknown[] = []> = [Keys] extends [never] ? R : ToTuple<T, Exclude<Keys, I>, Optionals, Next<I>, I extends Optionals ? [...R, T[I]?] : [...R, T[I]]>;
+type GetRest<T, U extends unknown[]> = T extends [...U, ...infer Rest] ? Rest : [];
+type Tuple<L extends number, T = unknown, R extends any[] = number extends L ? T[] : []> = R['length'] extends L ? R : Tuple<L, T, [T, ...R]>;
+type Head<T extends readonly unknown[]> = T[0];
+type Tail<T extends readonly unknown[]> = T extends [unknown, ...infer R] ? R : never;
+type Last<T extends readonly unknown[]> = T[Prev<T['length']>];
+type Init<T extends readonly unknown[]> = T extends [...infer R, unknown] ? R : never;
+export { Eq, IsUnknown, IsAny, UnknownToAny, PickUnionMember, Union2Tuple };
+type IsUnknown<T> = unknown extends T ? IsAny<T> extends false ? true : false : false;
+type IsAny<T> = [T | anything] extends [T & anything] ? true : false;
+type UnknownToAny<T> = unknown extends T ? any : T;
+type Eq<A, B> = [A] extends [B] ? [B] extends [A] ? true : false : false;
 declare const thing: unique symbol;
-declare type anything = typeof thing;
+type anything = typeof thing;
+type PickUnionMember<T, HOFs = T extends any ? (a: () => T) => void : never, Overloads = [HOFs] extends [(a: infer I) => any] ? I : never> = Overloads extends () => (infer R) ? R : never;
+type Union2Tuple<U, T = PickUnionMember<U>> = [
+    U
+] extends [never] ? [] : [...Union2Tuple<Exclude<U, T>>, T];

package/dist/utils.js

@@ -1 +1,2 @@
+// Numbers
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "free-types-core",
-    "version": "0.9.0",
+    "version": "1.0.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",
@@ -19,11 +19,16 @@
     },
     "license": "ICS",
     "devDependencies": {
-        "typescript": "^4.7.2"
+        "foo": "github:geoffreytools/Foo",
+        "ts-spec": "^1.7.0",
+        "ts-trace": "github:geoffreytools/ts-trace",
+        "typescript": "^4.9.5"
     },
     "scripts": {
-        "build": "tsc",
-        "watch": "tsc --watch",
-        "trace": "tsc --generateTrace traceDir"
+        "watch build": "tsc -p ./tsconfig-build.json --watch",
+        "watch test": "tsc --watch",
+        "build": "tsc -p ./tsconfig-build.json",
+        "trace": "bash ./node_modules/ts-trace/ts-trace.sh -i ./tsconfig-perf.json",
+        "diagnostics": "tsc -p ./tsconfig-perf.json --extendedDiagnostics"
     }
 }

package/dist/Remaining.d.ts

@@ -1,5 +0,0 @@
-import { Type } from './Type';
-import { Slice, Subtract } from './utils';
-export { Remaining };
-/** Use as a type constraint to match a Type whose state of application is known */
-declare type Remaining<T extends Type, R extends number> = unknown[] extends T['constraints'] ? Type : Type<Slice<T['constraints'], Subtract<T['constraints']['length'], R>, T['constraints']['length']>, T['type']>;