👍 Add isTupleOf<T>

Author: lambdalisue

is.ts

@@ -42,6 +42,35 @@ export function isArrayOf<T>(
   return (x: unknown): x is T[] => isArray(x) && x.every(pred);
 }
 
+export type TupleOf<T extends readonly Predicate<unknown>[]> = {
+  -readonly [P in keyof T]: T[P] extends Predicate<infer U> ? U : never;
+};
+
+/**
+ * Return a type predicate function that returns `true` if the type of `x` is `TupleOf<T>`.
+ *
+ * ```ts
+ * import is from "./is.ts";
+ *
+ * const predTup = [is.Number, is.String, is.Boolean] as const;
+ * const a: unknown = [0, "a", true];
+ * if (is.TupleOf(predTup)(a)) {
+ *  // a is narrowed to [number, string, boolean]
+ *  const _: [number, string, boolean] = a;
+ * }
+ * ```
+ */
+export function isTupleOf<T extends readonly Predicate<unknown>[]>(
+  predTup: T,
+): Predicate<TupleOf<T>> {
+  return (x: unknown): x is TupleOf<T> => {
+    if (!isArray(x) || x.length !== predTup.length) {
+      return false;
+    }
+    return predTup.every((pred, i) => pred(x[i]));
+  };
+}
+
 /**
  * Synonym of `Record<string | number | symbol, T>`
  */
@@ -103,6 +132,7 @@ export default {
   Boolean: isBoolean,
   Array: isArray,
   ArrayOf: isArrayOf,
+  TupleOf: isTupleOf,
   Record: isRecord,
   RecordOf: isRecordOf,
   Function: isFunction,

is_test.ts

@@ -13,6 +13,7 @@ import is, {
   isRecord,
   isRecordOf,
   isString,
+  isTupleOf,
   isUndefined,
 } from "./is.ts";
 
@@ -22,6 +23,7 @@ Deno.test("is defines aliases of functions", () => {
   assertStrictEquals(is.Boolean, isBoolean);
   assertStrictEquals(is.Array, isArray);
   assertStrictEquals(is.ArrayOf, isArrayOf);
+  assertStrictEquals(is.TupleOf, isTupleOf);
   assertStrictEquals(is.Record, isRecord);
   assertStrictEquals(is.RecordOf, isRecordOf);
   assertStrictEquals(is.Function, isFunction);
@@ -112,6 +114,26 @@ Deno.test("isArrayOf<T>", async (t) => {
   });
 });
 
+Deno.test("isTupleOf<T>", async (t) => {
+  await t.step("returns true on T tuple", () => {
+    const predTup = [isNumber, isString, isBoolean] as const;
+    assertEquals(isTupleOf(predTup)([0, "a", true]), true);
+  });
+  await t.step("returns false on non T tuple", () => {
+    const predTup = [isNumber, isString, isBoolean] as const;
+    assertEquals(isTupleOf(predTup)([0, 1, 2]), false);
+    assertEquals(isTupleOf(predTup)([0, "a"]), false);
+    assertEquals(isTupleOf(predTup)([0, "a", true, 0]), false);
+  });
+  await t.step("returns proper type predicate", () => {
+    const predTup = [isNumber, isString, isBoolean] as const;
+    const a: unknown = [0, "a", true];
+    if (isTupleOf(predTup)(a)) {
+      const _: [number, string, boolean] = a;
+    }
+  });
+});
+
 Deno.test("isRecord", async (t) => {
   await t.step("returns true on record", () => {
     assertEquals(isRecord({}), true);