👍 Add isInstanceOf<T>

Author: lambdalisue

is.ts

@@ -157,6 +157,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`.
  */
@@ -213,6 +233,7 @@ export default {
   RecordOf: isRecordOf,
   ObjectOf: isObjectOf,
   Function: isFunction,
+  InstanceOf: isInstanceOf,
   Null: isNull,
   Undefined: isUndefined,
   Nullish: isNullish,

is_test.ts

@@ -7,6 +7,7 @@ import is, {
   isArrayOf,
   isBoolean,
   isFunction,
+  isInstanceOf,
   isNull,
   isNullish,
   isNumber,
@@ -180,6 +181,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"]);
 });