No, really, though...

src/guards/guards.ts

@@ -0,0 +1,11 @@
+import { ValueTypeGuard } from "../types";
+
+const isTypeof = <T>(type: T): ValueTypeGuard<T> => (x: T): x is T => typeof x === typeof type;
+
+const isString = isTypeof(String());
+const isNumber = isTypeof(Number());
+const isBoolean = isTypeof(Boolean());
+
+const isArray = <T>(xs: T[]): xs is T[] => Array.isArray(xs);
+
+export { isString, isNumber, isBoolean, isArray, isTypeof };

src/operators/operators.ts

@@ -0,0 +1,32 @@
+import { TypedTest, Erratic } from "../types";
+
+const isNull = <T>(x: Erratic<T>): x is null => x === null;
+const isUndefined = <T>(x: Erratic<T>): x is undefined => x === undefined;
+
+const isErratic = <T>(x: Erratic<T>): x is null | undefined =>
+  isNull(x) || isUndefined(x);
+
+const and = <T>(...tests: TypedTest<T>[]) => (x: Erratic<T>): x is T =>
+  isErratic(x) ? false : tests.every(test => test(x));
+
+const or = <T>(...tests: TypedTest<T>[]) => (x: Erratic<T>): x is T =>
+  isErratic(x) ? false : tests.some(test => test(x));
+
+const optional = <T>(test: TypedTest<T>) => (x: Erratic<T>): x is T =>
+  isNull(x) ? false : isUndefined(x) ? true : test(x);
+
+const nullable = <T>(test: TypedTest<T>) => (x: Erratic<T>): x is T =>
+  isNull(x) ? true : isUndefined(x) ? false : test(x);
+
+const erratic = <T>(test: TypedTest<T>) => (x: Erratic<T>): x is T =>
+  isErratic(x) ? true : test(x);
+
+const compose = and;
+
+const customTest = <T>(test: TypedTest<T>) => (x: Erratic<T>): x is T =>
+  isErratic(x) ? false : test(x);
+
+const unsafeTest = <T>(test: TypedTest<Erratic<T>>) => (x: Erratic<T>): x is T =>
+  test(x);
+
+export { compose, and, or, optional, nullable, erratic, customTest, unsafeTest };