feat[isTupleOf]: add overload to leading rest elements

Author: Milly

is/__snapshots__/tuple_of_test.ts.snap

@@ -44,6 +44,28 @@ snapshot[`isTupleOf<T, R> > returns properly named predicate function 3`] = `
 ])"
 `;
 
+snapshot[`isTupleOf<R, T> > returns properly named predicate function 1`] = `
+"isTupleOf(isArray, [
+  isNumber,
+  isString,
+  isBoolean
+])"
+`;
+
+snapshot[`isTupleOf<R, T> > returns properly named predicate function 2`] = `"isTupleOf(isArrayOf(isString), [(anonymous)])"`;
+
+snapshot[`isTupleOf<R, T> > returns properly named predicate function 3`] = `
+"isTupleOf([
+  isTupleOf(isArray, [
+    isTupleOf(isArray, [
+      isNumber,
+      isString,
+      isBoolean
+    ])
+  ])
+])"
+`;
+
 snapshot[`isTupleOf<T, R, L> > returns properly named predicate function 1`] = `
 "isTupleOf([
   isNumber,

is/tuple_of.ts

@@ -19,7 +19,7 @@ import { isArray } from "./array.ts";
  * }
  * ```
  *
- * With `predRest` to represent rest elements:
+ * With `predRest` to represent rest elements or leading rest elements:
  *
  * ```ts
  * import { is } from "@core/unknownutil";
@@ -32,6 +32,14 @@ import { isArray } from "./array.ts";
  * if (isMyType(a)) {
  *   const _: [number, string, boolean, ...number[]] = a;
  * }
+ *
+ * const isMyTypeLeadingRest = is.TupleOf(
+ *   is.ArrayOf(is.Number),
+ *   [is.Number, is.String, is.Boolean],
+ * );
+ * if (isMyTypeLeadingRest(a)) {
+ *   const _: [...number[], number, string, boolean] = a;
+ * }
  * ```
  *
  * With `predRest` and `predTrail` to represent middle rest elements:
@@ -78,6 +86,14 @@ export function isTupleOf<
   predRest: R,
 ): Predicate<[...TupleOf<T>, ...PredicateType<R>]>;
 
+export function isTupleOf<
+  R extends Predicate<unknown[]>,
+  T extends readonly [Predicate<unknown>, ...Predicate<unknown>[]],
+>(
+  predRest: R,
+  predTup: T,
+): Predicate<[...PredicateType<R>, ...TupleOf<T>]>;
+
 export function isTupleOf<
   T extends readonly [Predicate<unknown>, ...Predicate<unknown>[]],
   R extends Predicate<unknown[]>,
@@ -93,14 +109,34 @@ export function isTupleOf<
   R extends Predicate<unknown[]>,
   L extends readonly [Predicate<unknown>, ...Predicate<unknown>[]],
 >(
-  predTup: T,
-  predRest?: R,
+  predTupOrRest: T | R,
+  predRestOrTup?: R | T,
   predTrail?: L,
 ): Predicate<
   | TupleOf<T>
   | [...TupleOf<T>, ...PredicateType<R>]
+  | [...PredicateType<R>, ...TupleOf<T>]
   | [...TupleOf<T>, ...PredicateType<R>, ...TupleOf<T>]
 > {
+  if (typeof predTupOrRest === "function") {
+    const predRest = predTupOrRest as R;
+    const predTup = predRestOrTup as T;
+    return rewriteName(
+      (x: unknown): x is [...PredicateType<R>, ...TupleOf<T>] => {
+        if (!isArray(x) || x.length < predTup.length) {
+          return false;
+        }
+        const rest = x.slice(0, -predTup.length);
+        const trail = x.slice(-predTup.length);
+        return predTup.every((pred, i) => pred(trail[i])) && predRest(rest);
+      },
+      "isTupleOf",
+      predRest,
+      predTup,
+    );
+  }
+  const predTup = predTupOrRest as T;
+  const predRest = predRestOrTup as R;
   if (!predRest) {
     return rewriteName(
       (x: unknown): x is TupleOf<T> => {

is/tuple_of_test.ts

@@ -115,6 +115,78 @@ Deno.test("isTupleOf<T, R>", async (t) => {
   });
 });
 
+Deno.test("isTupleOf<R, T>", async (t) => {
+  await t.step("returns properly named predicate function", async (t) => {
+    await assertSnapshot(
+      t,
+      isTupleOf(is.Array, [is.Number, is.String, is.Boolean]).name,
+    );
+    await assertSnapshot(
+      t,
+      isTupleOf(is.ArrayOf(is.String), [(_x): _x is string => false])
+        .name,
+    );
+    await assertSnapshot(
+      t,
+      isTupleOf([
+        isTupleOf(
+          is.Array,
+          [isTupleOf(is.Array, [is.Number, is.String, is.Boolean])],
+        ),
+      ]).name,
+    );
+  });
+
+  await t.step("returns true on T tuple", () => {
+    const predRest = is.ArrayOf(is.Number);
+    const predTup = [is.Number, is.String, is.Boolean] as const;
+    assertEquals(isTupleOf(predRest, predTup)([0, "a", true]), true);
+    assertEquals(isTupleOf(predRest, predTup)([0, 1, 2, 0, "a", true]), true);
+  });
+
+  await t.step("returns false on non T tuple", () => {
+    const predRest = is.ArrayOf(is.String);
+    const predTup = [is.Number, is.String, is.Boolean] as const;
+    assertEquals(isTupleOf(predRest, predTup)("a"), false, "Not an array");
+    assertEquals(
+      isTupleOf(predRest, predTup)([0, "a"]),
+      false,
+      "Less than `predTup.length`",
+    );
+    assertEquals(
+      isTupleOf(predRest, predTup)([0, 1, 2]),
+      false,
+      "Not match `predTup` and no rest elements",
+    );
+    assertEquals(
+      isTupleOf(predRest, predTup)([0, 1, 2, 0, 1, 2]),
+      false,
+      "Not match `predTup` and `predRest`",
+    );
+    assertEquals(
+      isTupleOf(predRest, predTup)([0, 1, 2, 0, "a", true]),
+      false,
+      "Match `predTup` but not match `predRest`",
+    );
+    assertEquals(
+      isTupleOf(predRest, predTup)(["a", "b", "c", 0, "a", "b"]),
+      false,
+      "Match `predRest` but not match `predTup`",
+    );
+  });
+
+  await t.step("predicated type is correct", () => {
+    const predRest = is.ArrayOf(is.Number);
+    const predTup = [is.Number, is.String, is.Boolean] as const;
+    const a: unknown = [0, 1, 2, 0, "a", true];
+    if (isTupleOf(predRest, predTup)(a)) {
+      assertType<Equal<typeof a, [...number[], number, string, boolean]>>(
+        true,
+      );
+    }
+  });
+});
+
 Deno.test("isTupleOf<T, R, L>", async (t) => {
   await t.step("returns properly named predicate function", async (t) => {
     await assertSnapshot(