Initial commit 🚀

Author: gvergnaud

.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+node_modules
+npm-debug.log
+lib
+notes.md

.prettierrc

@@ -0,0 +1,3 @@
+{
+    "singleQuote": true
+}

README.md

@@ -0,0 +1 @@
+# Match

jest.config.js

@@ -0,0 +1,4 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+};

package-lock.json

@@ -0,0 +1,40 @@
+{
+  "name": "@gvergnaud/match",
+  "version": "0.0.1",
+  "description": "Typescript pattern matching library",
+  "main": "lib/index.js",
+  "scripts": {
+    "clean": "rimraf lib",
+    "build": "tsc -d",
+    "prepare": "npm run clean && npm run build",
+    "test": "jest"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://[email protected]/gvergnaud/match.git"
+  },
+  "keywords": [
+    "pattern",
+    "matching",
+    "pattern-matching",
+    "typescript",
+    "match-with",
+    "match",
+    "switch",
+    "adt"
+  ],
+  "author": "Gabriel Vergnaud",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/gvergnaud/match/issues"
+  },
+  "homepage": "https://github.com/gvergnaud/match#readme",
+  "devDependencies": {
+    "@types/jest": "^25.2.3",
+    "jest": "^26.0.1",
+    "prettier": "^2.0.5",
+    "rimraf": "^3.0.2",
+    "ts-jest": "^26.0.0",
+    "typescript": "^3.9.3"
+  }
+}

package.json

@@ -0,0 +1,48 @@
+/**
+ * # Pattern matching
+ **/
+/**
+ * ## Catch All Type
+ * `__` refers to a wildcard pattern matching any value
+ */
+declare type __ = '__CATCH_ALL__';
+export declare const __: __;
+/**
+ * ## Pattern
+ * Patterns can be any (nested) javascript value.
+ * They can also be "wildcards", using type constructors
+ */
+export declare type Pattern<a> = a extends number ? a | NumberConstructor | __ : a extends string ? a | StringConstructor | __ : a extends boolean ? a | BooleanConstructor | __ : a extends [infer b, infer c, infer d, infer e, infer f] ? [Pattern<b>, Pattern<c>, Pattern<d>, Pattern<e>, Pattern<f>] | __ : a extends [infer b, infer c, infer d, infer e] ? [Pattern<b>, Pattern<c>, Pattern<d>, Pattern<e>] | __ : a extends [infer b, infer c, infer d] ? [Pattern<b>, Pattern<c>, Pattern<d>] | __ : a extends [infer b, infer c] ? [Pattern<b>, Pattern<c>] | __ : a extends (infer b)[] ? Pattern<b>[] | __ : a extends Map<infer k, infer v> ? Map<k, Pattern<v>> | __ : a extends Set<infer v> ? Set<Pattern<v>> | __ : {
+    [k in keyof a]?: Pattern<a[k]>;
+} | __;
+/**
+ * ## Invert Pattern
+ * Since patterns have special wildcard values, we need a way
+ * to transform a pattern into the type of value it represents
+ */
+export declare type InvertPattern<p> = p extends NumberConstructor ? number : p extends StringConstructor ? string : p extends BooleanConstructor ? boolean : p extends [infer pb, infer pc, infer pd, infer pe, infer pf] ? [InvertPattern<pb>, InvertPattern<pc>, InvertPattern<pd>, InvertPattern<pe>, InvertPattern<pf>] : p extends [infer pb, infer pc, infer pd, infer pe] ? [InvertPattern<pb>, InvertPattern<pc>, InvertPattern<pd>, InvertPattern<pe>] : p extends [infer pb, infer pc, infer pd] ? [InvertPattern<pb>, InvertPattern<pc>, InvertPattern<pd>] : p extends [infer pb, infer pc] ? [InvertPattern<pb>, InvertPattern<pc>] : p extends (infer pp)[] ? InvertPattern<pp>[] : p extends Map<infer pk, infer pv> ? Map<pk, InvertPattern<pv>> : p extends Set<infer pv> ? Set<InvertPattern<pv>> : p extends __ ? __ : {
+    [k in keyof p]: InvertPattern<p[k]>;
+};
+declare type Fun<a, b> = (value: a) => b;
+/**
+ * ## LeastUpperBound
+ * An interesting one. A type taking two imbricated sets and returning the
+ * smallest one.
+ * We need that because sometimes the pattern's infered type holds more
+ * information than the value on which we are matching (if the value is any
+ * or unknown for instance).
+ */
+declare type LeastUpperBound<a, b> = [a, b] extends [[infer aa, infer ab, infer ac, infer ad, infer ae], [infer ba, infer bb, infer bc, infer bd, infer be]] ? [LeastUpperBound<aa, ba>, LeastUpperBound<ab, bb>, LeastUpperBound<ac, bc>, LeastUpperBound<ad, bd>, LeastUpperBound<ae, be>] : [a, b] extends [[infer aa, infer ab, infer ac, infer ad], [infer ba, infer bb, infer bc, infer bd]] ? [LeastUpperBound<aa, ba>, LeastUpperBound<ab, bb>, LeastUpperBound<ac, bc>, LeastUpperBound<ad, bd>] : [a, b] extends [[infer aa, infer ab, infer ac], [infer ba, infer bb, infer bc]] ? [LeastUpperBound<aa, ba>, LeastUpperBound<ab, bb>, LeastUpperBound<ac, bc>] : [a, b] extends [[infer aa, infer ab], [infer ba, infer bb]] ? [LeastUpperBound<aa, ba>, LeastUpperBound<ab, bb>] : [a, b] extends [(infer aa)[], (infer ba)[]] ? LeastUpperBound<aa, ba>[] : [a, b] extends [Map<infer ak, infer av>, Map<infer bk, infer bv>] ? Map<LeastUpperBound<ak, bk>, LeastUpperBound<av, bv>> : [a, b] extends [Set<infer av>, Set<infer bv>] ? Set<LeastUpperBound<av, bv>> : b extends __ ? a : a extends __ ? b : b extends a ? b : a extends b ? a : never;
+/**
+ * ## match
+ * Entry point to create pattern matching code branches. It returns an
+ * empty builder
+ */
+export declare const match: <a, b>(value: a) => {
+    with: <p extends Pattern<a>>(pattern: p, f: Fun<LeastUpperBound<a, InvertPattern<p>>, b>) => any;
+    when: (predicate: Fun<a, unknown>, f: Fun<a, b>) => any;
+    withWhen: <p_1 extends Pattern<a>>(pattern: p_1, predicate: Fun<LeastUpperBound<a, InvertPattern<p_1>>, unknown>, f: Fun<LeastUpperBound<a, InvertPattern<p_1>>, b>) => any;
+    otherwise: (f: () => b) => any;
+    run: () => b;
+};
+export {};

src/index.d.ts

@@ -0,0 +1,109 @@
+"use strict";
+/**
+ * # Pattern matching
+ **/
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+exports.__esModule = true;
+exports.match = exports.__ = void 0;
+exports.__ = '__CATCH_ALL__';
+/**
+ * ## match
+ * Entry point to create pattern matching code branches. It returns an
+ * empty builder
+ */
+exports.match = function (value) { return builder(value, []); };
+/**
+ * ## builder
+ * This is the implementation of our pattern matching, using the
+ * builder pattern.
+ * This builder pattern is neat because we can have complexe type checking
+ * for each of the methods adding new behavior to our pattern matching.
+ */
+var builder = function (value, patterns) { return ({
+    "with": function (pattern, f) {
+        return builder(value, __spreadArrays(patterns, [[matchPattern(pattern), f]]));
+    },
+    when: function (predicate, f) {
+        return builder(value, __spreadArrays(patterns, [[predicate, f]]));
+    },
+    withWhen: function (pattern, predicate, f) {
+        var doesMatch = function (value) {
+            return Boolean(matchPattern(pattern)(value) && predicate(value));
+        };
+        return builder(value, __spreadArrays(patterns, [[doesMatch, f]]));
+    },
+    otherwise: function (f) {
+        return builder(value, __spreadArrays(patterns, [
+            [matchPattern(exports.__), f],
+        ]));
+    },
+    run: function () {
+        var tupple = patterns.find(function (_a) {
+            var predicate = _a[0];
+            return predicate(value);
+        });
+        if (!tupple) {
+            throw new Error("Pattern matching error: no pattern matches value " + value);
+        }
+        var mapper = tupple[1];
+        return mapper(value);
+    }
+}); };
+var isObject = function (value) {
+    return value && typeof value === 'object';
+};
+var wildcards = [String, Boolean, Number];
+// tells us if the value matches a given pattern.
+var matchPattern = function (pattern) { return function (value) {
+    if (pattern === exports.__)
+        return true;
+    if (pattern === String)
+        return typeof value === 'string';
+    if (pattern === Boolean)
+        return typeof value === 'boolean';
+    if (pattern === Number) {
+        return typeof value === 'number' && !Number.isNaN(value);
+    }
+    if (typeof pattern !== typeof value)
+        return false;
+    if (Array.isArray(pattern) && Array.isArray(value)) {
+        return pattern.length === 1
+            ? value.every(function (v, i) { return matchPattern(pattern[0])(v); })
+            : pattern.length === value.length
+                ? value.every(function (v, i) {
+                    return pattern[i] ? matchPattern(pattern[i])(v) : false;
+                })
+                : false;
+    }
+    if (value instanceof Map && pattern instanceof Map) {
+        return __spreadArrays(pattern.keys()).every(function (key) {
+            return matchPattern(pattern.get(key))(value.get(key));
+        });
+    }
+    if (value instanceof Set && pattern instanceof Set) {
+        var patternValues = __spreadArrays(pattern.values());
+        var allValues_1 = __spreadArrays(value.values());
+        return patternValues.length === 0
+            ? allValues_1.length === 0
+            : patternValues.length === 1
+                ? patternValues.every(function (subPattern) {
+                    return wildcards.includes(subPattern)
+                        ? matchPattern([subPattern])(allValues_1)
+                        : value.has(subPattern);
+                })
+                : patternValues.every(function (subPattern) { return value.has(subPattern); });
+    }
+    if (isObject(value) && isObject(pattern)) {
+        return Object.keys(pattern).every(function (k) {
+            // @ts-ignore
+            return matchPattern(pattern[k])(value[k]);
+        });
+    }
+    return value === pattern;
+}; };