fix[isTupleOf]: rename predElse to predRest

Author: Milly

is/__snapshots__/tuple_of_test.ts.snap

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

is/tuple_of.ts

@@ -3,7 +3,7 @@ import type { Predicate, PredicateType } from "../type.ts";
 import { isArray } from "./array.ts";
 
 /**
- * Return a type predicate function that returns `true` if the type of `x` is `TupleOf<T>` or `TupleOf<T, E>`.
+ * Return a type predicate function that returns `true` if the type of `x` is `TupleOf<T>` or `TupleOf<T, R>`.
  *
  * Use {@linkcode isUniformTupleOf} to check if the type of `x` is a tuple of uniform types.
  *
@@ -19,7 +19,7 @@ import { isArray } from "./array.ts";
  * }
  * ```
  *
- * With `predElse`:
+ * With `predRest` to represent rest elements:
  *
  * ```ts
  * import { is } from "@core/unknownutil";
@@ -56,20 +56,20 @@ export function isTupleOf<
 
 export function isTupleOf<
   T extends readonly [Predicate<unknown>, ...Predicate<unknown>[]],
-  E extends Predicate<unknown[]>,
+  R extends Predicate<unknown[]>,
 >(
   predTup: T,
-  predElse: E,
-): Predicate<[...TupleOf<T>, ...PredicateType<E>]>;
+  predRest: R,
+): Predicate<[...TupleOf<T>, ...PredicateType<R>]>;
 
 export function isTupleOf<
   T extends readonly [Predicate<unknown>, ...Predicate<unknown>[]],
-  E extends Predicate<unknown[]>,
+  R extends Predicate<unknown[]>,
 >(
   predTup: T,
-  predElse?: E,
-): Predicate<TupleOf<T> | [...TupleOf<T>, ...PredicateType<E>]> {
-  if (!predElse) {
+  predRest?: R,
+): Predicate<TupleOf<T> | [...TupleOf<T>, ...PredicateType<R>]> {
+  if (!predRest) {
     return rewriteName(
       (x: unknown): x is TupleOf<T> => {
         if (!isArray(x) || x.length !== predTup.length) {
@@ -82,17 +82,17 @@ export function isTupleOf<
     );
   } else {
     return rewriteName(
-      (x: unknown): x is [...TupleOf<T>, ...PredicateType<E>] => {
+      (x: unknown): x is [...TupleOf<T>, ...PredicateType<R>] => {
         if (!isArray(x) || x.length < predTup.length) {
           return false;
         }
         const head = x.slice(0, predTup.length);
         const tail = x.slice(predTup.length);
-        return predTup.every((pred, i) => pred(head[i])) && predElse(tail);
+        return predTup.every((pred, i) => pred(head[i])) && predRest(tail);
       },
       "isTupleOf",
       predTup,
-      predElse,
+      predRest,
     );
   }
 }

is/tuple_of_test.ts

@@ -43,7 +43,7 @@ Deno.test("isTupleOf<T>", async (t) => {
   });
 });
 
-Deno.test("isTupleOf<T, E>", async (t) => {
+Deno.test("isTupleOf<T, R>", async (t) => {
   await t.step("returns properly named predicate function", async (t) => {
     await assertSnapshot(
       t,
@@ -67,27 +67,27 @@ Deno.test("isTupleOf<T, E>", async (t) => {
 
   await t.step("returns true on T tuple", () => {
     const predTup = [is.Number, is.String, is.Boolean] as const;
-    const predElse = is.ArrayOf(is.Number);
-    assertEquals(isTupleOf(predTup, predElse)([0, "a", true, 0, 1, 2]), true);
+    const predRest = is.ArrayOf(is.Number);
+    assertEquals(isTupleOf(predTup, predRest)([0, "a", true, 0, 1, 2]), true);
   });
 
   await t.step("returns false on non T tuple", () => {
     const predTup = [is.Number, is.String, is.Boolean] as const;
-    const predElse = is.ArrayOf(is.String);
-    assertEquals(isTupleOf(predTup, predElse)([0, 1, 2, 0, 1, 2]), false);
-    assertEquals(isTupleOf(predTup, predElse)([0, "a", 0, 1, 2]), false);
+    const predRest = is.ArrayOf(is.String);
+    assertEquals(isTupleOf(predTup, predRest)([0, 1, 2, 0, 1, 2]), false);
+    assertEquals(isTupleOf(predTup, predRest)([0, "a", 0, 1, 2]), false);
     assertEquals(
-      isTupleOf(predTup, predElse)([0, "a", true, 0, 0, 1, 2]),
+      isTupleOf(predTup, predRest)([0, "a", true, 0, 0, 1, 2]),
       false,
     );
-    assertEquals(isTupleOf(predTup, predElse)([0, "a", true, 0, 1, 2]), false);
+    assertEquals(isTupleOf(predTup, predRest)([0, "a", true, 0, 1, 2]), false);
   });
 
   await t.step("predicated type is correct", () => {
     const predTup = [is.Number, is.String, is.Boolean] as const;
-    const predElse = is.ArrayOf(is.Number);
+    const predRest = is.ArrayOf(is.Number);
     const a: unknown = [0, "a", true, 0, 1, 2];
-    if (isTupleOf(predTup, predElse)(a)) {
+    if (isTupleOf(predTup, predRest)(a)) {
       assertType<Equal<typeof a, [number, string, boolean, ...number[]]>>(
         true,
       );