👍 Add name attribute to predicate function

Now assert/ensure/maybe error message shows the definition of the
predicate function

Author: lambdalisue

__snapshots__/is_test.ts.snap

@@ -0,0 +1,92 @@
+export const snapshot = {};
+
+snapshot[`isArrayOf<T> > returns properly named function 1`] = `"isArrayOf(isNumber)"`;
+
+snapshot[`isArrayOf<T> > returns properly named function 2`] = `"isArrayOf((anonymous))"`;
+
+snapshot[`isTupleOf<T> > returns properly named function 1`] = `
+"isTupleOf([
+  isNumber,
+  isString,
+  isBoolean
+])"
+`;
+
+snapshot[`isTupleOf<T> > returns properly named function 2`] = `"isTupleOf([(anonymous)])"`;
+
+snapshot[`isTupleOf<T> > returns properly named function 3`] = `
+"isTupleOf([
+  isTupleOf([
+    isTupleOf([
+      isNumber,
+      isString,
+      isBoolean
+    ])
+  ])
+])"
+`;
+
+snapshot[`isUniformTupleOf<T> > returns properly named function 1`] = `"isUniformTupleOf(3, isAny)"`;
+
+snapshot[`isUniformTupleOf<T> > returns properly named function 2`] = `"isUniformTupleOf(3, isNumber)"`;
+
+snapshot[`isUniformTupleOf<T> > returns properly named function 3`] = `"isUniformTupleOf(3, (anonymous))"`;
+
+snapshot[`isRecordOf<T> > returns properly named function 1`] = `"isRecordOf(isNumber)"`;
+
+snapshot[`isRecordOf<T> > returns properly named function 2`] = `"isRecordOf((anonymous))"`;
+
+snapshot[`isObjectOf<T> > returns properly named function 1`] = `
+"isObjectOf({
+  a: isNumber,
+  b: isString,
+  c: isBoolean
+})"
+`;
+
+snapshot[`isObjectOf<T> > returns properly named function 2`] = `"isObjectOf({a: a})"`;
+
+snapshot[`isObjectOf<T> > returns properly named function 3`] = `
+"isObjectOf({
+  a: isObjectOf({
+    b: isObjectOf({c: isBoolean})
+  })
+})"
+`;
+
+snapshot[`isInstanceOf<T> > returns properly named function 1`] = `"isInstanceOf(Date)"`;
+
+snapshot[`isInstanceOf<T> > returns properly named function 2`] = `"isInstanceOf((anonymous))"`;
+
+snapshot[`isLiteralOf<T> > returns properly named function 1`] = `'isLiteralOf("hello")'`;
+
+snapshot[`isLiteralOf<T> > returns properly named function 2`] = `"isLiteralOf(100)"`;
+
+snapshot[`isLiteralOf<T> > returns properly named function 3`] = `"isLiteralOf(100n)"`;
+
+snapshot[`isLiteralOf<T> > returns properly named function 4`] = `"isLiteralOf(true)"`;
+
+snapshot[`isLiteralOf<T> > returns properly named function 5`] = `"isLiteralOf(null)"`;
+
+snapshot[`isLiteralOf<T> > returns properly named function 6`] = `"isLiteralOf(undefined)"`;
+
+snapshot[`isLiteralOf<T> > returns properly named function 7`] = `"isLiteralOf(Symbol(asdf))"`;
+
+snapshot[`isLiteralOneOf<T> > returns properly named function 1`] = `'isLiteralOneOf(["hello", "world"])'`;
+
+snapshot[`isOneOf<T> > returns properly named function 1`] = `
+"isOneOf([
+  isNumber,
+  isString,
+  isBoolean
+])"
+`;
+
+snapshot[`isAllOf<T> > returns properly named function 1`] = `
+"isAllOf([
+  isObjectOf({a: isNumber}),
+  isObjectOf({b: isString})
+])"
+`;
+
+snapshot[`isOptionalOf<T> > returns properly named function 1`] = `"isOptionalOf(isNumber)"`;

inspect.ts

@@ -54,6 +54,6 @@ function inspectRecord(
 }
 
 function indent(level: number, text: string): string {
-  const prefix = "  ".repeat(level);
+  const prefix = " ".repeat(level);
   return text.split("\n").map((line) => `${prefix}${line}`).join("\n");
 }

is.ts

@@ -1,3 +1,5 @@
+import { inspect } from "./inspect.ts";
+
 /**
  * A type predicate function
  */
@@ -59,7 +61,14 @@ export function isArray(
 export function isArrayOf<T>(
   pred: Predicate<T>,
 ): Predicate<T[]> {
-  return (x: unknown): x is T[] => isArray(x) && x.every(pred);
+  return Object.defineProperties(
+    (x: unknown): x is T[] => isArray(x) && x.every(pred),
+    {
+      name: {
+        get: () => `isArrayOf(${inspect(pred)})`,
+      },
+    },
+  );
 }
 
 export type TupleOf<T extends readonly Predicate<unknown>[]> = {
@@ -87,12 +96,19 @@ export type TupleOf<T extends readonly Predicate<unknown>[]> = {
 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]));
-  };
+  return Object.defineProperties(
+    (x: unknown): x is TupleOf<T> => {
+      if (!isArray(x) || x.length !== predTup.length) {
+        return false;
+      }
+      return predTup.every((pred, i) => pred(x[i]));
+    },
+    {
+      name: {
+        get: () => `isTupleOf(${inspect(predTup)})`,
+      },
+    },
+  );
 }
 
 // https://stackoverflow.com/a/71700658/1273406
@@ -122,10 +138,17 @@ export type UniformTupleOf<
  */
 export function isUniformTupleOf<T, N extends number>(
   n: N,
-  pred: Predicate<T> = (_x: unknown): _x is T => true,
+  pred: Predicate<T> = isAny,
 ): Predicate<UniformTupleOf<T, N>> {
-  const predTup = Array(n).fill(pred);
-  return isTupleOf(predTup) as Predicate<UniformTupleOf<T, N>>;
+  const predInner = isTupleOf(Array(n).fill(pred));
+  return Object.defineProperties(
+    (x: unknown): x is UniformTupleOf<T, N> => predInner(x),
+    {
+      name: {
+        get: () => `isUniformTupleOf(${n}, ${inspect(pred)})`,
+      },
+    },
+  );
 }
 
 /**
@@ -151,13 +174,20 @@ export function isRecord(
 export function isRecordOf<T>(
   pred: Predicate<T>,
 ): Predicate<RecordOf<T>> {
-  return (x: unknown): x is RecordOf<T> => {
-    if (!isRecord(x)) return false;
-    for (const k in x) {
-      if (!pred(x[k])) return false;
-    }
-    return true;
-  };
+  return Object.defineProperties(
+    (x: unknown): x is RecordOf<T> => {
+      if (!isRecord(x)) return false;
+      for (const k in x) {
+        if (!pred(x[k])) return false;
+      }
+      return true;
+    },
+    {
+      name: {
+        get: () => `isRecordOf(${inspect(pred)})`,
+      },
+    },
+  );
 }
 
 type FlatType<T> = T extends RecordOf<unknown>
@@ -204,9 +234,16 @@ export function isObjectOf<
   T extends RecordOf<Predicate<unknown>>,
 >(
   predObj: T,
-  options: { strict?: boolean } = {},
+  { strict }: { strict?: boolean } = {},
 ): Predicate<ObjectOf<T>> {
-  return options.strict ? isObjectOfStrict(predObj) : isObjectOfLoose(predObj);
+  return Object.defineProperties(
+    strict ? isObjectOfStrict(predObj) : isObjectOfLoose(predObj),
+    {
+      name: {
+        get: () => `isObjectOf(${inspect(predObj)})`,
+      },
+    },
+  );
 }
 
 function isObjectOfLoose<
@@ -261,7 +298,14 @@ export function isFunction(x: unknown): x is (...args: unknown[]) => unknown {
 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 Object.defineProperties(
+    (x: unknown): x is InstanceType<T> => x instanceof ctor,
+    {
+      name: {
+        get: () => `isInstanceOf(${inspect(ctor)})`,
+      },
+    },
+  );
 }
 
 /**
@@ -312,8 +356,15 @@ export function isPrimitive(x: unknown): x is Primitive {
 /**
  * Return a type predicate function that returns `true` if the type of `x` is a literal type of `pred`.
  */
-export function isLiteralOf<T extends Primitive>(pred: T): Predicate<T> {
-  return (x: unknown): x is T => x === pred;
+export function isLiteralOf<T extends Primitive>(literal: T): Predicate<T> {
+  return Object.defineProperties(
+    (x: unknown): x is T => x === literal,
+    {
+      name: {
+        get: () => `isLiteralOf(${inspect(literal)})`,
+      },
+    },
+  );
 }
 
 /**
@@ -329,10 +380,17 @@ export function isLiteralOf<T extends Primitive>(pred: T): Predicate<T> {
  * ```
  */
 export function isLiteralOneOf<T extends readonly Primitive[]>(
-  preds: T,
+  literals: T,
 ): Predicate<T[number]> {
-  return (x: unknown): x is T[number] =>
-    preds.includes(x as unknown as T[number]);
+  return Object.defineProperties(
+    (x: unknown): x is T[number] =>
+      literals.includes(x as unknown as T[number]),
+    {
+      name: {
+        get: () => `isLiteralOneOf(${inspect(literals)})`,
+      },
+    },
+  );
 }
 
 export type OneOf<T> = T extends Predicate<infer U>[] ? U : never;
@@ -354,7 +412,14 @@ export type OneOf<T> = T extends Predicate<infer U>[] ? U : never;
 export function isOneOf<T extends readonly Predicate<unknown>[]>(
   preds: T,
 ): Predicate<OneOf<T>> {
-  return (x: unknown): x is OneOf<T> => preds.some((pred) => pred(x));
+  return Object.defineProperties(
+    (x: unknown): x is OneOf<T> => preds.some((pred) => pred(x)),
+    {
+      name: {
+        get: () => `isOneOf(${inspect(preds)})`,
+      },
+    },
+  );
 }
 
 type UnionToIntersection<U> =
@@ -380,7 +445,14 @@ export type AllOf<T> = UnionToIntersection<OneOf<T>>;
 export function isAllOf<T extends readonly Predicate<unknown>[]>(
   preds: T,
 ): Predicate<AllOf<T>> {
-  return (x: unknown): x is AllOf<T> => preds.every((pred) => pred(x));
+  return Object.defineProperties(
+    (x: unknown): x is AllOf<T> => preds.every((pred) => pred(x)),
+    {
+      name: {
+        get: () => `isAllOf(${inspect(preds)})`,
+      },
+    },
+  );
 }
 
 export type OptionalPredicate<T> = Predicate<T | undefined> & {
@@ -403,10 +475,15 @@ export type OptionalPredicate<T> = Predicate<T | undefined> & {
 export function isOptionalOf<T>(
   pred: Predicate<T>,
 ): OptionalPredicate<T> {
-  return Object.assign(
+  return Object.defineProperties(
     (x: unknown): x is Predicate<T | undefined> => isUndefined(x) || pred(x),
     {
-      optional: true as const,
+      optional: {
+        value: true as const,
+      },
+      name: {
+        get: () => `isOptionalOf(${inspect(pred)})`,
+      },
     },
   ) as OptionalPredicate<T>;
 }