├── .gitignore
├── README.md
├── package-lock.json
├── package.json
├── src
    ├── Bool.ts
    ├── Nat.ts
    ├── Vector.ts
    └── index.ts
└── tsconfig.json


/.gitignore:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/atennapel/ts-typelevel-computation/1615daeb20f8e03c69e44c91ad613fe4c312f47e/.gitignore


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # ts-typelevel-computation
 2 | 
 3 | ```typescript
 4 | // perform computations on the type level
 5 | // includes:
 6 | // Boolean: not, and, or, if
 7 | // Nat: +, -, *, /, %, sqrt, log2, gcd and comparisons
 8 | // Vector: mapping and appending
 9 | 
10 | type Test = Sqrt<_10>; // Test === 3
11 | 
12 | const vec = cons(1, cons(2, cons(3, nil()))); // length is inferred to be 3
13 | const mapped = vec.map(x => x + 1); // length stays 3
14 | 
15 | const vecDoubled = vec.append(vec); // length is 6
16 | ```
17 | 


--------------------------------------------------------------------------------
/package-lock.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "ts-typelevel-computation",
 3 |   "version": "1.0.0",
 4 |   "lockfileVersion": 1,
 5 |   "requires": true,
 6 |   "dependencies": {
 7 |     "@types/node": {
 8 |       "version": "10.12.2",
 9 |       "resolved": "https://registry.npmjs.org/@types/node/-/node-10.12.2.tgz",
10 |       "integrity": "sha512-53ElVDSnZeFUUFIYzI8WLQ25IhWzb6vbddNp8UHlXQyU0ET2RhV5zg0NfubzU7iNMh5bBXb0htCzfvrSVNgzaQ==",
11 |       "dev": true
12 |     },
13 |     "typescript": {
14 |       "version": "3.1.6",
15 |       "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.1.6.tgz",
16 |       "integrity": "sha512-tDMYfVtvpb96msS1lDX9MEdHrW4yOuZ4Kdc4Him9oU796XldPYF/t2+uKoX0BBa0hXXwDlqYQbXY5Rzjzc5hBA==",
17 |       "dev": true
18 |     }
19 |   }
20 | }
21 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "ts-typelevel-computation",
 3 |   "version": "1.0.0",
 4 |   "description": "",
 5 |   "main": "index.js",
 6 |   "scripts": {
 7 |     "build": "tsc",
 8 |     "index": "node build/src/index.js",
 9 |     "buildindex": "npm run build && npm run index"
10 |   },
11 |   "author": "",
12 |   "license": "ISC",
13 |   "devDependencies": {
14 |     "@types/node": "^10.12.2",
15 |     "typescript": "^3.1.5"
16 |   }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Bool.ts:
--------------------------------------------------------------------------------
 1 | export type Not<B> =
 2 |   B extends true ? false :
 3 |   B extends false ? true :
 4 |   never;
 5 | 
 6 | export type And<A, B> =
 7 |   A extends false ? false :
 8 |   A extends true ? B :
 9 |   never;
10 | 
11 | export type Or<A, B> =
12 |   A extends true ? true :
13 |   A extends false ? B :
14 |   never;
15 | 
16 | export type If<C, A, B> =
17 |   C extends true ? A :
18 |   C extends false ? B :
19 |   never;
20 | 


--------------------------------------------------------------------------------
/src/Nat.ts:
--------------------------------------------------------------------------------
  1 | import { Not } from './Bool';
  2 | 
  3 | // natural numbers
  4 | export interface Z { tag: 'Z' }
  5 | export interface S<N> { tag: 'S'; val: N }
  6 | 
  7 | export type Inc<N> = S<N>;
  8 | export type Dec<N> = N extends Z ? Z : N extends S<infer M> ? M : never;
  9 | 
 10 | // equality and comparison
 11 | type Eq$<A, B> =
 12 |   A extends Z ? (B extends Z ? { val: true } : { val: false }) :
 13 |   A extends S<infer N> ? (B extends S<infer M> ? { val: Eq<N, M> } : { val: false }) :
 14 |   never;
 15 | export type Eq<A, B> = Eq$<A, B>['val'];
 16 | 
 17 | type Leq$<A, B> =
 18 |   A extends Z ? { val: true } :
 19 |   B extends Z ? { val: false } :
 20 |   A extends S<infer N> ?
 21 |     (B extends S<infer M> ? { val: Leq<N, M> } : never) :
 22 |   never;
 23 | export type Leq<A, B> = Leq$<A, B>['val'];
 24 | 
 25 | export type Lt<A, B> = Leq<S<A>, B>;
 26 | export type Geq<A, B> = Not<Lt<A, B>>;
 27 | export type Gt<A, B> = Not<Leq<A, B>>;
 28 | 
 29 | type Compare$<A, B> =
 30 |   A extends Z ?
 31 |     (B extends Z ? { val: 0 } :
 32 |       B extends S<infer _> ? { val: -1 } : never) :
 33 |   A extends S<infer N> ?
 34 |     (B extends Z ? { val: 1 } :
 35 |       B extends S<infer M> ? { val: Compare<N, M> } : never) :
 36 |   never;
 37 | export type Compare<A, B> = Compare$<A, B>['val'];
 38 | 
 39 | // max and min
 40 | type Max$<A, B> =
 41 |   A extends Z ? { val: B } :
 42 |   A extends S<infer N> ?
 43 |       (B extends Z ? { val: A } :
 44 |         B extends S<infer M> ? { val: S<Max<N, M>> }: never) :
 45 |   never;
 46 | export type Max<A, B> = Max$<A, B>['val'];
 47 | 
 48 | type Min$<A, B> =
 49 |   A extends Z ? { val: Z } :
 50 |   A extends S<infer N> ?
 51 |       (B extends Z ? { val: Z } :
 52 |         B extends S<infer M> ? { val: S<Min<N, M>> }: never) :
 53 |   never;
 54 | export type Min<A, B> = Min$<A, B>['val'];
 55 | 
 56 | // even and odd
 57 | type Even$<N> =
 58 |   N extends Z ? { val: true } :
 59 |   N extends S<infer M> ?
 60 |     (M extends Z ? { val: false} :
 61 |       M extends S<infer K> ? { val: Even<K> }:
 62 |       { val: never }) :
 63 |   never;
 64 | export type Even<N> = Even$<N>['val'];
 65 | 
 66 | export type Odd<N> = Not<Even<N>>;
 67 | 
 68 | // addition and subtraction
 69 | type Add$<A, B> =
 70 |   A extends Z ? { val: B } :
 71 |   A extends S<infer N> ? { val: S<Add<N, B>> } :
 72 |   never;
 73 | export type Add<A, B> = Add$<A, B>['val'];
 74 | 
 75 | type Sub$<A, B> =
 76 |   B extends Z ? { val: A } :
 77 |   { val: Sub<Dec<A>, Dec<B>> };
 78 | export type Sub<A, B> = Sub$<A, B>['val'];
 79 | 
 80 | // multiplication, power, division and mod
 81 | type Mul$<A, B> =
 82 |   A extends Z ? { val: Z } :
 83 |   A extends S<infer N> ? { val: Add<B, Mul<N, B>> } :
 84 |   never;
 85 | export type Mul<A, B> = Mul$<A, B>['val'];
 86 | 
 87 | type Pow$<A, B> =
 88 |   B extends Z ? { val: S<Z> } :
 89 |   B extends S<infer N> ? { val: Mul<A, Pow<A, N>> } :
 90 |   never;
 91 | export type Pow<A, B> = Pow$<A, B>['val'];
 92 | 
 93 | type DivMod$<X, Y, Q, U> =
 94 |   X extends Z ? { val: [Q, U] } :
 95 |   X extends S<infer N> ?
 96 |     (U extends Z ? { val: DivMod<N, Y, S<Q>, Y> } :
 97 |       U extends S<infer M> ? { val: DivMod<N, Y, Q, M> } :
 98 |       never) :
 99 |   never;
100 | export type DivMod<X, Y, Q, U> = DivMod$<X, Y, Q, U>['val'];
101 | 
102 | export type Div<X, Y> =
103 |   Y extends Z ? Z :
104 |   Y extends S<infer N> ? DivMod<X, N, Z, N>[0] :
105 |   never;
106 | 
107 | export type Mod<X, Y> =
108 |   Y extends Z ? Z :
109 |   Y extends S<infer N> ? Sub<N, DivMod<X, N, Z, N>[1]> :
110 |   never;
111 | 
112 | // double, half
113 | export type Double<N> = Mul<N, S<S<Z>>>;
114 | export type Half<N> = Div<N, S<S<Z>>>;
115 | 
116 | // square and gcd
117 | export type Square<N> = Mul<N, N>;
118 | 
119 | type GCD$<A, B> =
120 |   A extends Z ? { val: B } :
121 |   A extends S<infer N> ? { val: GCD<Mod<B, A>, A> } :
122 |   never;
123 | export type GCD<A, B> = GCD$<A, B>['val'];
124 | 
125 | // square root
126 | type SqrtIter$<K, P, Q, R> =
127 |   K extends Z ? { val : P } :
128 |   K extends S<infer K$> ?
129 |     (R extends Z ? { val: SqrtIter<K$, S<P>, S<S<Q>>, S<S<Q>>> } :
130 |       R extends S<infer R$> ? { val: SqrtIter<K$, P, Q, R$> } :
131 |       { val: never }) :
132 |   never;
133 | type SqrtIter<K, P, Q, R> = SqrtIter$<K, P, Q, R>['val'];
134 | 
135 | export type Sqrt<N> = SqrtIter<N, Z, Z, Z>;
136 | 
137 | // log2
138 | type Log2Iter$<K, P, Q, R> =
139 |   K extends Z ? { val : P } :
140 |   K extends S<infer K$> ?
141 |     (R extends Z ? { val: Log2Iter<K$, S<P>, S<Q>, Q> } :
142 |       R extends S<infer R$> ? { val: Log2Iter<K$, P, S<Q>, R$> } :
143 |       { val: never }) :
144 |   never;
145 | type Log2Iter<K, P, Q, R> = Log2Iter$<K, P, Q, R>['val'];
146 | 
147 | export type Log2<N> = Log2Iter<Dec<N>, Z, S<Z>, Z>;
148 | 
149 | // some numbers
150 | export type _0 = Z;
151 | export type _1 = S<_0>;
152 | export type _2 = S<_1>;
153 | export type _3 = S<_2>;
154 | export type _4 = S<_3>;
155 | export type _5 = S<_4>;
156 | export type _6 = S<_5>;
157 | export type _7 = S<_6>;
158 | export type _8 = S<_7>;
159 | export type _9 = S<_8>;
160 | export type _10 = S<_9>;
161 | 


--------------------------------------------------------------------------------
/src/Vector.ts:
--------------------------------------------------------------------------------
 1 | import { Z, S, Add } from './Nat';
 2 | 
 3 | export default abstract class Vector<L, T> {
 4 | 
 5 |   abstract toString(): string;
 6 | 
 7 |   abstract map<R>(fn: (val: T) => R): Vector<L, R>;
 8 | 
 9 |   abstract append<M>(that: Vector<M, T>): Vector<Add<L, M>, T>;
10 | 
11 |   abstract toArray(): T[];
12 | 
13 | }
14 | 
15 | export class Nil<T> extends Vector<Z, T> {
16 | 
17 |   toString() {
18 |     return 'Nil';
19 |   }
20 | 
21 |   map<R>(fn: (val: T) => R): Vector<Z, R> {
22 |     return this as any;
23 |   }
24 | 
25 |   append<M>(that: Vector<M, T>): Vector<M, T> {
26 |     return that;
27 |   }
28 | 
29 |   toArray(): T[] {
30 |     return [];
31 |   }
32 | 
33 | }
34 | 
35 | export class Cons<L, T> extends Vector<S<L>, T> {
36 | 
37 |   constructor(
38 |     public readonly head: T,
39 |     public readonly tail: Vector<L, T>,
40 |   ) { super() }
41 | 
42 |   toString() {
43 |     return `Cons(${this.head}, ${this.tail})`;
44 |   }
45 | 
46 |   map<R>(fn: (val: T) => R): Vector<S<L>, R> {
47 |     return new Cons(fn(this.head), this.tail.map(fn));
48 |   }
49 | 
50 |   append<M>(that: Vector<M, T>): Vector<Add<L, M>, T> {
51 |     return new Cons(this.head, this.tail.append(that));
52 |   }
53 | 
54 |   toArray(): T[] {
55 |     return [this.head].concat(this.tail.toArray());
56 |   }
57 | 
58 | }
59 | 
60 | export const nil = <T>(): Vector<Z, T> => new Nil<T>();
61 | export const cons = <L, T>(head: T, tail: Vector<L, T>): Vector<S<L>, T> => new Cons<L, T>(head, tail);
62 | 


--------------------------------------------------------------------------------
/src/index.ts:
--------------------------------------------------------------------------------
 1 | import { _10, Sqrt } from './Nat';
 2 | import { nil, cons } from './Vector';
 3 | 
 4 | type Test = Sqrt<_10>; // Test === 3
 5 | 
 6 | const vec = cons(1, cons(2, cons(3, nil()))); // length is inferred to be 3
 7 | const mapped = vec.map(x => x + 1); // length stays 3
 8 | 
 9 | const vecDoubled = vec.append(vec); // length is 6
10 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compilerOptions": {
 3 |     "module": "commonjs",
 4 |     "target": "es2015",
 5 |     "rootDir": "./",
 6 |     "outDir": "build",
 7 |     "noImplicitAny": true,
 8 |     "noImplicitReturns": true,
 9 |     "noImplicitThis": true,
10 |     "strictNullChecks": true,
11 |     "types": ["node"],
12 |     "typeRoots": [ "node_modules/@types" ]
13 |   },
14 |   "include:": [
15 |     "src/**/*.ts"
16 |   ],
17 |   "exclude": [
18 |     "node_modules"
19 |   ]
20 | }
21 | 


--------------------------------------------------------------------------------