free-types-core 0.4.0 → 0.4.2

package/dist/Const.d.ts

@@ -0,0 +1,28 @@
+import { Type } from './Type';
+export { Const, $Const };
+/**
+ * Turn a type `T` into a constant `Type<❋, T>`, totally ignoring arity and type constraints on its input.
+*/
+type Const<T> = {
+    type: T;
+    constraints: any;
+    arguments: any[] & {
+        length: any;
+    };
+    0: any;
+    1: any;
+    2: any;
+    3: any;
+    4: any;
+    5: any;
+    6: any;
+    7: any;
+    8: any;
+    9: any;
+};
+/**
+ * Turn the input into a constant `Type<❋, T>`, totally ignoring arity and type constraints on its input.
+*/
+interface $Const extends Type<1> {
+    type: Const<this[0]>;
+}

package/dist/Const.js

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

package/dist/Remaining.d.ts

@@ -0,0 +1,5 @@
+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 */
+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']>;

package/dist/Remaining.js

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

package/dist/Replace.d.ts

@@ -0,0 +1,9 @@
+import { unwrap, Unwrapped, Search } from './unwrap';
+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
+ */
+type Replace<T, Args extends U['type']['constraints'], From extends Search = TypesMap, U extends Unwrapped = unwrap<T, From>> = apply<U['type'], Args>;

package/dist/Replace.js

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

package/dist/Type.d.ts

@@ -0,0 +1,33 @@
+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.*/
+type Type<Input extends number | unknown[] = unknown[], Output = unknown> = CreateType<{
+    type: Output;
+    constraints: Constraints<Input, Slots<Input>>;
+    arguments: unknown[];
+}>;
+interface CreateType<T extends {
+    type: unknown;
+    constraints: unknown[];
+}> {
+    type: T['type'];
+    constraints: T['constraints'];
+    arguments: unknown[];
+    0: unknown;
+    1: unknown;
+    2: unknown;
+    3: unknown;
+    4: unknown;
+    5: unknown;
+    6: unknown;
+    7: unknown;
+    8: unknown;
+    9: unknown;
+}
+type Slots<T> = T extends Precomputable ? PrecomputedSlots[T & Precomputable] : Tuple<T extends unknown[] ? T['length'] : T extends number ? T : number>;
+type Constraints<Input, Slots> = number extends Input ? unknown[] : unknown[] extends Input ? unknown[] : Input extends unknown[] ? Input : Slots;
+type PrecomputedSlots = {
+    [I in Precomputable]: Tuple<Seq10[I]>;
+};
+type Precomputable = Seq10[number];
+type Seq10 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

package/dist/Type.js

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

package/dist/TypesMap.d.ts

@@ -0,0 +1,17 @@
+import * as free from './free-types';
+/** A mapping of everyday free types which you can extend with module augmentation. */
+export interface TypesMap {
+    Record: free.Record;
+    Array: free.Array;
+    Tuple: free.Tuple;
+    ReadonlyTuple: free.ReadonlyTuple;
+    ReadonlyArray: free.ReadonlyArray;
+    Set: free.Set;
+    ReadonlySet: free.ReadonlySet;
+    WeakSet: free.WeakSet;
+    Map: free.Map;
+    ReadonlyMap: free.ReadonlyMap;
+    WeakMap: free.WeakMap;
+    Function: free.Function;
+    Promise: free.Promise;
+}

package/dist/TypesMap.js

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

package/dist/apply.d.ts

@@ -0,0 +1,22 @@
+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 */
+type apply<$T extends Type, Args extends $T['constraints'] = []> = applyUnsafe<$T, Args>;
+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. */
+type Generic<$T extends Type> = _apply<$T, $T['constraints']>;
+type applyUnsafe<$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']>>;
+type _apply<T extends {
+    type: unknown;
+}, Args> = (T & Omit<Args, ArrayKeys> & {
+    arguments: Args;
+})['type'];
+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]]>;

package/dist/apply.js

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

package/{free-types.ts → dist/free-types.d.ts}

@@ -1,82 +1,49 @@
-import { Type } from './Type'
-import { ToTuple } from './utils'
-
-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
-}
-
+import { Type } from './Type';
+import { ToTuple } from './utils';
+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: this[0]
+    type: this[0];
 }
-
 type Key = string | number | symbol;
-
 interface $Record extends Type<[Key, unknown]> {
-    type: Record<this[0] & Key, this[1]>
+    type: Record<this[0] & Key, this[1]>;
 }
-
 interface $Array extends Type<1> {
-    type: Array<this[0]>
+    type: Array<this[0]>;
 }
-
 interface $Tuple extends Type {
     type: ToTuple<this['arguments']>;
 }
-
 interface $ReadonlyTuple extends Type {
     type: Readonly<ToTuple<this['arguments']>>;
 }
-
 interface $ReadonlyArray extends Type<1> {
-    type: ReadonlyArray<this[0]>
+    type: ReadonlyArray<this[0]>;
 }
-
 interface $Set extends Type<1> {
-    type: Set<this[0]>
+    type: Set<this[0]>;
 }
-
 interface $ReadonlySet extends Type<1> {
-    type: ReadonlySet<this[0]>
+    type: ReadonlySet<this[0]>;
 }
-
 interface $WeakSet extends Type<[object]> {
-    type: WeakSet<this[0] extends object ? this[0] : object>
+    type: WeakSet<this[0] extends object ? this[0] : object>;
 }
-
 interface $Map extends Type<2> {
-    type: Map<this[0], this[1]>
+    type: Map<this[0], this[1]>;
 }
-
 interface $ReadonlyMap extends Type<2> {
-    type: ReadonlyMap<this[0], this[1]>
+    type: ReadonlyMap<this[0], this[1]>;
 }
-
 interface $WeakMap extends Type<[object, unknown]> {
-    type: WeakMap<this[0] extends object ? this[0] : object, this[1]>
+    type: WeakMap<this[0] extends object ? this[0] : object, this[1]>;
 }
-
 interface $Function extends Type<[any[], unknown]> {
-    type: (...args: this[0] extends any[] ? this[0] : any[]) => this[1]
+    type: (...args: this[0] extends any[] ? this[0] : any[]) => this[1];
 }
-
 interface $UnaryFunction extends Type<2> {
-    type: (a: unknown extends this[0] ? any : this[0]) => this[1]
+    type: (a: unknown extends this[0] ? any : this[0]) => this[1];
 }
-
 interface $Promise extends Type<1> {
-    type: Promise<this[0]>
-}
+    type: Promise<this[0]>;
+}

package/dist/free-types.js

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

package/dist/helpers.d.ts

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

package/dist/helpers.js

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

package/dist/hkt.d.ts

@@ -0,0 +1,13 @@
+import { Type } from "./Type";
+export { HKT, Contra };
+/** Interfaces extending this type are able to use `hkt` internally. */
+type HKT = {
+    HKT: [any, ...any[]];
+};
+/** Expect a free type with contravariant arguments */
+type Contra<$T extends Type, $U extends Type> = $U['constraints'] extends $T['constraints'] ? $T['type'] extends $U['type'] ? Type : Type<$T['constraints'], $U['type']> : {
+    'Contravariance issue': {
+        'the input': $U['constraints'];
+        'is not assignable to': $T['constraints'];
+    };
+};

package/dist/hkt.js

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

package/{index.ts → dist/index.d.ts}

@@ -9,4 +9,4 @@ export * from './unwrap';
 export * from './Replace';
 export * from './hkt';
 export * as free from './free-types';
-export { Slice, ToTuple, Head, Tail, Last, Init, IsUnknown, IsOptional } from './utils'
+export { Slice, ToTuple, Head, Tail, Last, Init, IsUnknown, IsOptional } from './utils';

package/dist/index.js

@@ -0,0 +1,11 @@
+export * from './apply';
+export * from './partial';
+export * from './Remaining';
+export * from './Type';
+export * from './Const';
+export * from './helpers';
+export * from './inferArgs';
+export * from './unwrap';
+export * from './Replace';
+export * from './hkt';
+export * as free from './free-types';

package/dist/inferArgs.d.ts

@@ -0,0 +1,29 @@
+import { Type } from './Type';
+import { apply } from './apply';
+export { inferArgs };
+type inferArgs<T, $T extends Type> = T extends apply<$T, [
+    infer A,
+    infer B,
+    infer C,
+    infer D,
+    infer E,
+    infer F,
+    infer G,
+    infer H,
+    infer I,
+    infer J
+]> ? Extract<[A, B, C, D, E, F, G, H, I, J]>[$T['constraints']['length']] : never;
+interface Extract<T extends unknown[]> {
+    [k: number]: unknown[];
+    0: [];
+    1: [T[0]];
+    2: [T[0], T[1]];
+    3: [T[0], T[1], T[2]];
+    4: [T[0], T[1], T[2], T[3]];
+    5: [T[0], T[1], T[2], T[3], T[4]];
+    6: [T[0], T[1], T[2], T[3], T[4], T[5]];
+    7: [T[0], T[1], T[2], T[3], T[4], T[5], T[6]];
+    8: [T[0], T[1], T[2], T[3], T[4], T[5], T[6], T[7]];
+    9: [T[0], T[1], T[2], T[3], T[4], T[5], T[6], T[7], T[8]];
+    10: [T[0], T[1], T[2], T[3], T[4], T[5], T[6], T[7], T[8], T[9]];
+}

package/dist/inferArgs.js

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

package/dist/partial.d.ts

@@ -0,0 +1,19 @@
+import { Type } from './Type';
+import { apply } from './apply';
+import { Slice, Subtract, ToTuple } from './utils';
+export { partial, partialRight, PartialRight, $partial };
+/** Return a new type based upon `$T`, with `Args` already applied, expecting the remaining 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> {
+    type: _partial<$T, [this['arguments'][0]]>;
+}
+type _partial<$T extends Type, Args extends unknown[]> = PartialType<$T, Args, Slice<$T['constraints'], Args['length'], Required<$T['constraints']>['length']>, 'left'>;
+/** Return a new type based upon `$T`, with `Args` already applied to the rightmost parameters of `$T`, and expecting the remaining arguments */
+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;
+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]>;
+    constraints: Constraints;
+    arguments: unknown[];
+}

package/dist/partial.js

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

package/dist/unwrap.d.ts

@@ -0,0 +1,34 @@
+import { ArrayKeys, Eq } from './utils';
+import { Type } from './Type';
+import { inferArgs } from './inferArgs';
+import { Generic, apply } from './apply';
+import { TypesMap } from './TypesMap';
+import { Tuple, ReadonlyTuple, Array, ReadonlyArray } from './free-types';
+type Search = Type | SearchList;
+type SearchList = Type[] | Record<string, Type> | Interface;
+type Interface = {
+    [k: string]: any;
+} & {
+    [Symbol.toStringTag]?: never;
+};
+export { unwrap, Unwrapped, Search };
+/** Decompose a type into its constituents */
+type unwrap<T, From extends Search = TypesMap> = T extends readonly unknown[] ? unwrapLists<T> : _unwrap<T, From extends Type ? [From] : From>;
+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]]>;
+type Mutable<T> = {
+    -readonly [K in keyof T]: K extends ArrayKeys ? T[K] : T[K];
+};
+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;
+}
+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` */
+type Unwrapped<URI extends string = string, T extends Type = Type, A = unknown[]> = {
+    URI: URI;
+    type: T;
+    args: A;
+};

package/dist/unwrap.js

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

package/dist/utils.d.ts

@@ -0,0 +1,29 @@
+export { Natural, Prev, Next, Subtract };
+export { ArrayKeys, Slice, ToTuple, Tuple, Head, Tail, Last, Init };
+export { Extends, Eq, IsUnknown, IsAny, IsOptional };
+type Natural = [0, ..._Next];
+type Prev<I extends number> = number extends I ? number : number & _Prev[I];
+type _Prev = [never, ...Natural];
+type Next<I extends number> = number extends I ? number : number & _Next[I];
+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];
+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>;
+type ArrayKeys = Exclude<keyof [], never>;
+type Slice<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]]>;
+type IsOptional<T extends unknown[], I extends number> = [
+    {
+        [K in T['length'] as K]: K extends I ? never : unknown;
+    }[I]
+] extends [never] ? true : false;
+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]]>;
+type Tuple<L extends number, T = unknown, R extends unknown[] = []> = number extends L ? T[] : L extends R['length'] ? R : Tuple<L, T, [T, ...R]>;
+type Head<T extends [unknown, ...unknown[]]> = T[0];
+type Tail<T extends [unknown, ...unknown[]]> = T extends [unknown, ...infer R] ? R : never;
+type Last<T extends unknown[]> = T[Prev<T['length']>];
+type Init<T extends [unknown, ...unknown[]]> = T extends [...infer R, unknown] ? R : never;
+type IsUnknown<T> = unknown extends T ? IsAny<T> extends false ? true : false : false;
+type IsAny<T> = Extends<T | anything, T & anything>;
+type Extends<A, B> = [A] extends [B] ? true : false;
+type Eq<A, B> = [A] extends [B] ? [B] extends [A] ? true : false : false;
+declare const thing: unique symbol;
+type anything = typeof thing;

package/dist/utils.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "free-types-core",
-    "version": "0.4.0",
+    "version": "0.4.2",
     "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",
@@ -9,10 +9,14 @@
     ],
     "exports": {
         ".": {
-            "import": "./index.ts"
+            "import": "./dist/index.js"
         }
     },
-    "types": "./index.ts",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "files": [
+        "dist/*"
+    ],
     "author": "Geoffrey Gourdet",
     "repository": {
         "type": "git",

package/.vscode/settings.json

@@ -1,3 +0,0 @@
-{
-    "typescript.tsdk": "node_modules\\typescript\\lib"
-}

package/Const.ts

@@ -1,27 +0,0 @@
-import { Type } from './Type'
-
-export { Const, $Const };
-
-/**
- * Turn a type `T` into a constant `Type<❋, T>`, totally ignoring arity and type constraints on its input.
-*/
-type Const<T> = {
-    type: T
-    constraints: any
-    arguments: any[] & { length: any },
-    0: any
-    1: any
-    2: any
-    3: any
-    4: any
-    5: any
-    6: any
-    7: any
-    8: any
-    9: any
-}
-
-/**
- * Turn the input into a constant `Type<❋, T>`, totally ignoring arity and type constraints on its input.
-*/
-interface $Const extends Type<1> { type: Const<this[0]> }

package/Remaining.ts

@@ -1,15 +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 */
-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']
->;

package/Replace.ts

@@ -1,17 +0,0 @@
-import { unwrap, Unwrapped, Search } from './unwrap'
-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
- */
-type Replace<
-    T,
-    Args extends U['type']['constraints'],
-    From extends Search = TypesMap,
-    U extends Unwrapped = unwrap<T, From>
-> = apply<U['type'], Args>

package/Type.ts

@@ -1,42 +0,0 @@
-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.*/
-
-type Type<Input extends number | unknown[] = unknown[], Output = unknown> =
-    CreateType<{
-        type: Output
-        constraints: Constraints<Input, Slots<Input>>
-        arguments: unknown[]
-    }>
-
-interface CreateType<T extends { type: unknown, constraints: unknown[] }> {
-    type: T['type']
-    constraints: T['constraints']
-    arguments: unknown[]
-    0: unknown
-    1: unknown
-    2: unknown
-    3: unknown
-    4: unknown
-    5: unknown
-    6: unknown
-    7: unknown
-    8: unknown
-    9: unknown
-}
-
-type Slots<T> = T extends Precomputable
-    ? PrecomputedSlots[T & Precomputable]
-    : Tuple<T extends unknown[] ? T['length'] : T extends number ? T : number>;
-
-type Constraints<Input, Slots> =
-    number extends Input ? unknown[]
-    : unknown[] extends Input ? unknown[]
-    : Input extends unknown[] ? Input
-    : Slots
-
-type PrecomputedSlots = { [I in Precomputable]: Tuple<Seq10[I]> }
-type Precomputable = Seq10[number];
-type Seq10 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

package/TypesMap.ts

@@ -1,19 +0,0 @@
-import * as free from './free-types';
-
-/** A mapping of everyday free types which you can extend with module augmentation. */
-export interface TypesMap {
-    Record: free.Record,
-    Array: free.Array,
-    Tuple: free.Tuple,
-    ReadonlyTuple: free.ReadonlyTuple,
-    ReadonlyArray: free.ReadonlyArray,
-    Set: free.Set,
-    ReadonlySet: free.ReadonlySet,
-    WeakSet: free.WeakSet,
-    Map: free.Map,
-    ReadonlyMap: free.ReadonlyMap,
-    WeakMap: free.WeakMap,
-    Function: free.Function,
-    // UnaryFunction is missing on purpose
-    Promise: free.Promise
-}

package/apply.ts

@@ -1,32 +0,0 @@
-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 */
-type apply<$T extends Type, Args extends $T['constraints'] = []> =
-    applyUnsafe<$T, Args>;
-
-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. */
-type Generic<$T extends Type> = _apply<$T, $T['constraints']>;
-
-type applyUnsafe<
-    $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']>>;
-
-type _apply<T extends { type: unknown }, Args> = 
-    (T & Omit<Args, ArrayKeys> & { arguments: Args })['type'];
-
-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]]>

package/helpers.ts

@@ -1,102 +0,0 @@
-import { Next, IsUnknown, Prev } from './utils'
-
-export { At, Checked, Lossy, Optional, A, B, C, D, E }
-
-// Fake `Type` for user friendly error messages
-type Type<N extends number> = {
-    constraints: { [K in Prev<N>]: unknown; }
-    arguments: unknown[]
-}
-
-type Type_ <N extends number> = {
-    constraints: { [K in Prev<N>]?: unknown; }
-    arguments: unknown[]
-}
-type Default = {
-    constraints: [0,1,2,3,4]
-    arguments: unknown[]
-}
-
-/** - safely index `this`
- * - optionally take a fallback
-*/
-type At<
-    N extends number,
-    This extends Type<Next<N>>,
-    Fallback = unknown
-> = IsUnknown<This['arguments'][N]> extends true ? Fallback
-    : This['arguments'][N]
-
-/** - safely index `this`
- * - defuse the corresponding type constraint with an inline conditional
- * - optionally take a fallback
- */
-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;
-    
-/** - safely index `this`
- * - works on optional parameters
- * - defuse the corresponding type constraint with an inline conditional
- * - optionally take a fallback
- */
- 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;
-
-/** - safely index `this`
- * - intersect the corresponding type constraint
- */
-type Lossy<
-    N extends number,
-    This extends Type<Next<N>>
-> =  N extends keyof This['constraints']
-    ? This['arguments'][N] & This['constraints'][N]
-    : never;
-
-/** - safely index `this`
- * - intersect the corresponding type constraint
- * - equals `0` When no argument is supplied
-*/
-type A<This extends Type<1> = Default> =
-    This['arguments'][0] & This['constraints'][0];
-
-/** - safely index `this`
- * - intersect the corresponding type constraint
- * - equals `1` When no argument is supplied
-*/
-type B<This extends Type<2> = Default> =
-    This['arguments'][1] & This['constraints'][1];
-
-/** - safely index `this`
- * - intersect the corresponding type constraint
- * - equals `2` When no argument is supplied
-*/
-type C<This extends Type<3> = Default> =
-    This['arguments'][2] & This['constraints'][2];
-
-/** - safely index `this`
- * - intersect the corresponding type constraint
- * - equals `3` When no argument is supplied
-*/
-type D<This extends Type<4> = Default> =
-    This['arguments'][3] & This['constraints'][3];
-
-/** - safely index `this`
- * - intersect the corresponding type constraint
- * - equals `4` When no argument is supplied
-*/
-type E<This extends Type<5> = Default> =
-    This['arguments'][4] & This['constraints'][4];

package/hkt.ts

@@ -1,18 +0,0 @@
-import { Type } from "./Type";
-
-export { HKT, Contra }
-
-/** Interfaces extending this type are able to use `hkt` internally. */
-type HKT = { HKT: [any, ...any[]] };
-
-/** Expect a free type with contravariant arguments */
-type Contra<$T extends Type, $U extends Type> =
-    $U['constraints'] extends $T['constraints']
-    ? $T['type'] extends $U['type']
-        ? Type
-        : Type<$T['constraints'], $U['type']>
-    :  {
-        'Contravariance issue': {
-            'the input': $U['constraints'], 'is not assignable to': $T['constraints']
-        }
-};

package/inferArgs.ts

@@ -1,26 +0,0 @@
-import { Type } from './Type';
-import { apply } from './apply';
-
-export { inferArgs };
-
-type inferArgs<T, $T extends Type> =
-    T extends apply<$T, [
-        infer A, infer B, infer C, infer D, infer E,
-        infer F, infer G, infer H, infer I, infer J
-    ]> ? Extract<[A, B, C, D, E, F, G, H, I, J]>[$T['constraints']['length']] 
-    : never
-
-interface Extract<T extends unknown[]> {
-    [k: number]: unknown[]
-    0: []
-    1: [T[0]]
-    2: [T[0], T[1]]
-    3: [T[0], T[1], T[2]]
-    4: [T[0], T[1], T[2], T[3]]
-    5: [T[0], T[1], T[2], T[3], T[4]]
-    6: [T[0], T[1], T[2], T[3], T[4], T[5]]
-    7: [T[0], T[1], T[2], T[3], T[4], T[5], T[6]]
-    8: [T[0], T[1], T[2], T[3], T[4], T[5], T[6], T[7]]
-    9: [T[0], T[1], T[2], T[3], T[4], T[5], T[6], T[7], T[8]]
-    10: [T[0], T[1], T[2], T[3], T[4], T[5], T[6], T[7], T[8], T[9]]
-}

package/partial.ts

@@ -1,60 +0,0 @@
-import { Type } from './Type';
-import { apply } from './apply';
-import { Slice, Subtract, ToTuple } from './utils';
-
-export { partial, partialRight, PartialRight, $partial }
-
-/** Return a new type based upon `$T`, with `Args` already applied, expecting the remaining 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> {
-    type: _partial<$T, [this['arguments'][0]]>
-}
-
-type _partial <$T extends Type, Args extends unknown[]> =
-    PartialType<
-        $T,
-        Args,
-        Slice<$T['constraints'],
-        Args['length'],
-        Required<$T['constraints']>['length']>,
-        'left'
-    >
-
-/** Return a new type based upon `$T`, with `Args` already applied to the rightmost parameters of `$T`, and expecting the remaining arguments */
-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
-
-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]
-    >
-    constraints: Constraints
-    arguments: unknown[]
-}

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-    "compilerOptions": {
-        "rootDir": "./",
-        "noEmit": true,
-        "noErrorTruncation": true,
-        "moduleResolution": "node",
-        "module": "ES2020",
-        "target": "ES2020",
-        "strictFunctionTypes": true,
-        "noImplicitAny": true,
-        "strict": true
-    },
-    "include": [
-        "./index.ts"
-    ]
-}

package/unwrap.ts

@@ -1,55 +0,0 @@
-import { ArrayKeys, Eq } from './utils'
-import { Type } from './Type';
-import { inferArgs} from './inferArgs';
-import { Generic, apply } from './apply';
-import { TypesMap } from './TypesMap';
-import { Tuple, ReadonlyTuple, Array, ReadonlyArray } from './free-types';
-
-type Search = Type | SearchList;
-type SearchList = Type[] | Record<string, Type> | Interface;
-type Interface = {[k: string]: any} & { [Symbol.toStringTag]?: never }
-
-export { unwrap, Unwrapped, Search }
-
-/** Decompose a type into its constituents */
-
-type unwrap<T, From extends Search = TypesMap> =
-    T extends readonly unknown[] ? unwrapLists<T>
-    : _unwrap<T, From extends Type ? [From] : From>
-
-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]]>
-
-type Mutable<T> = {
-    -readonly[K in keyof T]: K extends ArrayKeys ? T[K] : T[K]
-}; 
-
-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
-}
-
-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` */
-type Unwrapped<
-    URI extends string = string,
-    T extends Type = Type,
-    A = unknown[]
-> = { URI: URI, type: T, args: A };

package/utils.ts

@@ -1,87 +0,0 @@
-export { Natural, Prev, Next, Subtract }
-
-export { ArrayKeys, Slice, ToTuple, Tuple, Head, Tail, Last, Init }
-
-export { Extends, Eq, IsUnknown, IsAny, IsOptional }
-
-// Numbers
-
-type Natural = [0, ..._Next];
-
-type Prev<I extends number> =
-    number extends I ? number
-    : number & _Prev[I];
-    
-type _Prev = [never, ...Natural];
-
-type Next<I extends number> =
-    number extends I ? number
-    : number & _Next[I];
-
-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]
-
-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>;
-
-// Tuples
-
-type ArrayKeys = Exclude<keyof [], never>;
-
-type Slice<
-    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]]
-    >
-
-type IsOptional<T extends unknown[], I extends number> = [{
-    [K in T['length'] as K]: K extends I ? never : unknown
-}[I]] extends [never] ? true : false;
-
-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]]>;
-
-type Tuple <L extends number, T = unknown, R extends unknown[] = []> =
-    number extends L ? T[]
-    : L extends R['length'] ? R
-    : Tuple<L, T, [T, ...R]>;
-
-type Head<T extends [unknown, ...unknown[]]> = T[0];
-
-type Tail<T extends [unknown, ...unknown[]]> =
-    T extends [unknown, ...infer R] ? R : never;
-
-type Last<T extends unknown[]> = T[Prev<T['length']>]
-
-type Init<T extends [unknown, ...unknown[]]> =
-    T extends [...infer R, unknown] ? R : never;
-
-
-// Logic
-
-type IsUnknown<T> = unknown extends T ? IsAny<T> extends false ? true : false : false;
-
-type IsAny<T> = Extends<T | anything, T & anything>
-
-type Extends<A, B> = [A] extends [B] ? true : false;
-type Eq<A, B> = [A] extends [B] ? [B] extends [A] ? true : false : false;
-
-declare const thing: unique symbol;
-type anything = typeof thing;