Merge pull request #24 from lambdalisue/add-is-instanceof

👍 Add `isInstanceOf<T>`, `isBigInt`, and `isSymbol` functions

Author: lambdalisue

is.ts

@@ -17,6 +17,13 @@ export function isNumber(x: unknown): x is number {
   return typeof x === "number";
 }
 
+/**
+ * Return `true` if the type of `x` is `bigint`.
+ */
+export function isBigInt(x: unknown): x is bigint {
+  return typeof x === "bigint";
+}
+
 /**
  * Return `true` if the type of `x` is `boolean`.
  */
@@ -161,6 +168,26 @@ export function isFunction(x: unknown): x is (...args: unknown[]) => unknown {
   return Object.prototype.toString.call(x) === "[object Function]";
 }
 
+/**
+ * Return `true` if the type of `x` is instance of `ctor`.
+ *
+ * ```ts
+ * import is from "./is.ts";
+ *
+ * const a: unknown = new Date();
+ * if (is.InstanceOf(Date)(a)) {
+ *   // a is narrowed to Date
+ *   const _: Date = a;
+ * }
+ * ```
+ */
+// deno-lint-ignore no-explicit-any
+export function isInstanceOf<T extends new (...args: any) => unknown>(
+  ctor: T,
+): Predicate<InstanceType<T>> {
+  return (x: unknown): x is InstanceType<T> => x instanceof ctor;
+}
+
 /**
  * Return `true` if the type of `x` is `null`.
  */
@@ -182,6 +209,13 @@ export function isNullish(x: unknown): x is null | undefined {
   return x == null;
 }
 
+/**
+ * Return `true` if the type of `x` is `symbol`.
+ */
+export function isSymbol(x: unknown): x is symbol {
+  return typeof x === "symbol";
+}
+
 export type OneOf<T> = T extends (infer U)[]
   ? T extends Predicate<infer U>[] ? U : T
   : T;
@@ -209,6 +243,7 @@ export function isOneOf<T extends readonly Predicate<unknown>[]>(
 export default {
   String: isString,
   Number: isNumber,
+  BigInt: isBigInt,
   Boolean: isBoolean,
   Array: isArray,
   ArrayOf: isArrayOf,
@@ -217,8 +252,10 @@ export default {
   RecordOf: isRecordOf,
   ObjectOf: isObjectOf,
   Function: isFunction,
+  InstanceOf: isInstanceOf,
   Null: isNull,
   Undefined: isUndefined,
   Nullish: isNullish,
+  Symbol: isSymbol,
   OneOf: isOneOf,
 };

is_test.ts

@@ -5,8 +5,10 @@ import {
 import is, {
   isArray,
   isArrayOf,
+  isBigInt,
   isBoolean,
   isFunction,
+  isInstanceOf,
   isNull,
   isNullish,
   isNumber,
@@ -15,6 +17,7 @@ import is, {
   isRecord,
   isRecordOf,
   isString,
+  isSymbol,
   isTupleOf,
   isUndefined,
   Predicate,
@@ -23,16 +26,19 @@ import is, {
 const examples = {
   string: ["", "Hello world"],
   number: [0, 1234567890],
+  bigint: [0n, 1234567890n],
   boolean: [true, false],
   array: [[], [0, 1, 2], ["a", "b", "c"], [0, "a", true]],
   record: [{}, { a: 0, b: 1, c: 2 }, { a: "a", b: "b", c: "c" }],
   function: [function () {}],
   null: [null],
   undefined: [undefined],
+  symbol: [Symbol("a"), Symbol("b"), Symbol("c")],
 };
 
 function stringify(x: unknown): string {
   if (typeof x === "function") return x.toString();
+  if (typeof x === "bigint") return `${x}n`;
   return JSON.stringify(x);
 }
 
@@ -62,6 +68,10 @@ Deno.test("isNumber", async (t) => {
   await testWithExamples(t, isNumber, ["number"]);
 });
 
+Deno.test("isBigInt", async (t) => {
+  await testWithExamples(t, isBigInt, ["bigint"]);
+});
+
 Deno.test("isBoolean", async (t) => {
   await testWithExamples(t, isBoolean, ["boolean"]);
 });
@@ -180,6 +190,46 @@ Deno.test("isFunction", async (t) => {
   await testWithExamples(t, isFunction, ["function"]);
 });
 
+Deno.test("isInstanceOf<T>", async (t) => {
+  await t.step("returns true on T instance", () => {
+    class Cls {}
+    assertEquals(isInstanceOf(Cls)(new Cls()), true);
+    assertEquals(isInstanceOf(Date)(new Date()), true);
+    assertEquals(isInstanceOf(Promise<string>)(new Promise(() => {})), true);
+  });
+  await t.step("returns false on non function", () => {
+    class Cls {}
+    assertEquals(isInstanceOf(Cls)(new Date()), false);
+    assertEquals(isInstanceOf(Cls)(new Promise(() => {})), false);
+    assertEquals(isInstanceOf(Cls)(""), false);
+    assertEquals(isInstanceOf(Cls)(0), false);
+    assertEquals(isInstanceOf(Cls)(true), false);
+    assertEquals(isInstanceOf(Cls)(false), false);
+    assertEquals(isInstanceOf(Cls)([]), false);
+    assertEquals(isInstanceOf(Cls)({}), false);
+    assertEquals(isInstanceOf(Cls)(function () {}), false);
+    assertEquals(isInstanceOf(Cls)(null), false);
+    assertEquals(isInstanceOf(Cls)(undefined), false);
+  });
+  await t.step("returns proper type predicate", () => {
+    class Cls {}
+    const a: unknown = new Cls();
+    if (isInstanceOf(Cls)(a)) {
+      const _: Cls = a;
+    }
+
+    const b: unknown = new Date();
+    if (isInstanceOf(Date)(b)) {
+      const _: Date = b;
+    }
+
+    const c: unknown = new Promise(() => {});
+    if (isInstanceOf(Promise)(c)) {
+      const _: Promise<unknown> = c;
+    }
+  });
+});
+
 Deno.test("isNull", async (t) => {
   await testWithExamples(t, isNull, ["null"]);
 });
@@ -192,6 +242,10 @@ Deno.test("isNullish", async (t) => {
   await testWithExamples(t, isNullish, ["null", "undefined"]);
 });
 
+Deno.test("isSymbol", async (t) => {
+  await testWithExamples(t, isSymbol, ["symbol"]);
+});
+
 Deno.test("isOneOf<T>", async (t) => {
   await t.step("returns proper type predicate", () => {
     const preds = [isNumber, isString, isBoolean];