free-types-core 0.2.0

package/.vscode/settings.json

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

package/Const.ts

@@ -0,0 +1,27 @@
+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/Licence

@@ -0,0 +1,5 @@
+Copyright 2022 Geoffrey Gourdet
+
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# free-types-core
+
+See [free-types](https://github.com/geoffreytools/free-types)

package/Remaining.ts

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,25 @@
+import { Type } from './Type';
+import { ArrayKeys, Slice } 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, Slice<Args, 0, $T['constraints']['length']>>;
+
+type _apply<T extends { type: unknown }, Args> = 
+    (T & Omit<Args, ArrayKeys> & { arguments: Args })['type'];

package/free-types.ts

@@ -0,0 +1,82 @@
+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 Key = string | number | symbol;
+
+interface $Record extends Type<[Key, unknown]> {
+    type: Record<this[0] & Key, this[1]>
+}
+
+interface $Array extends Type<1> {
+    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]>
+}
+
+interface $Set extends Type<1> {
+    type: Set<this[0]>
+}
+
+interface $ReadonlySet extends Type<1> {
+    type: ReadonlySet<this[0]>
+}
+
+interface $WeakSet extends Type<[object]> {
+    type: WeakSet<this[0] extends object ? this[0] : object>
+}
+
+interface $Map extends Type<2> {
+    type: Map<this[0], this[1]>
+}
+
+interface $ReadonlyMap extends Type<2> {
+    type: ReadonlyMap<this[0], this[1]>
+}
+
+interface $WeakMap extends Type<[object, unknown]> {
+    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]
+}
+
+interface $UnaryFunction extends Type<2> {
+    type: (a: unknown extends this[0] ? any : this[0]) => this[1]
+}
+
+interface $Promise extends Type<1> {
+    type: Promise<this[0]>
+}

package/helpers.ts

@@ -0,0 +1,74 @@
+import { Next, IsUnknown, Prev } from './utils'
+
+export { At, Checked, Lossy, 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 Default = {
+    constraints: [0,1,2,3,4]
+    arguments: unknown[]
+}
+
+/** safely index `this`
+*/
+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` and defuse the corresponding type constraint with an inline conditional
+ */
+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` and 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` and 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` and 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` and 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` and 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` and 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

@@ -0,0 +1,18 @@
+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/index.ts

@@ -0,0 +1,12 @@
+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';
+export { Slice, ToTuple, Head, Tail, Last, Init, IsUnknown } from './utils'

package/inferArgs.ts

@@ -0,0 +1,26 @@
+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/package.json

@@ -0,0 +1,30 @@
+{
+    "name": "free-types-core",
+    "version": "0.2.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",
+        "type constructor",
+        "typescript"
+    ],
+    "exports": {
+        ".": {
+            "import": "./index.ts"
+        }
+    },
+    "types": "./index.ts",
+    "author": "Geoffrey Gourdet",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/geoffreytools/free-types-core"
+    },
+    "license": "ICS",
+    "devDependencies": {
+        "typescript": "^4.7.2"
+    },
+    "scripts": {
+        "build": "tsc",
+        "watch": "tsc --watch",
+        "trace": "tsc --generateTrace traceDir"
+    }
+}

package/partial.ts

@@ -0,0 +1,60 @@
+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'],
+        $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<$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

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

package/unwrap.ts

@@ -0,0 +1,55 @@
+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

@@ -0,0 +1,79 @@
+export { Natural, Prev, Next, Subtract }
+
+export { ArrayKeys, Slice, ToTuple, Tuple, Head, Tail, Last, Init }
+
+export { Extends, Eq, IsUnknown, IsAny }
+
+// 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 = T['length'],
+    I extends number = From,
+    R extends unknown[] = [],
+> =
+    I extends To ? R
+    : Slice<T, From, To, Next<I>, [...R, T[I]]>;
+
+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;