From 40f5c8aa558020010f2778b08d58d746b24f45c8 Mon Sep 17 00:00:00 2001
From: Alisue <lambdalisue@gmail.com>
Date: Tue, 13 Feb 2024 00:17:38 +0900
Subject: [PATCH] :+1: Add `isReadonlyOf` and deprecate
 `isReadonlyTupleOf/isReadonlyUniformTupleOf`

---
 is/__snapshots__/annotation_test.ts.snap |  18 +++
 is/__snapshots__/factory_test.ts.snap    | 176 +++++++++++------------
 is/__snapshots__/utility_test.ts.snap    |  36 ++---
 is/annotation.ts                         |  69 +++++++++
 is/annotation_test.ts                    |  36 ++++-
 is/factory.ts                            |  73 ++++------
 6 files changed, 258 insertions(+), 150 deletions(-)

diff --git a/is/__snapshots__/annotation_test.ts.snap b/is/__snapshots__/annotation_test.ts.snap
index f9401a0..b1b23e9 100644
--- a/is/__snapshots__/annotation_test.ts.snap
+++ b/is/__snapshots__/annotation_test.ts.snap
@@ -1,5 +1,23 @@
 export const snapshot = {};
 
+snapshot[`isReadonlyOf<T> > returns properly named function 1`] = `
+"isReadonlyOf(isTupleOf([
+  isString,
+  isNumber,
+  isBoolean
+]))"
+`;
+
+snapshot[`isReadonlyOf<T> > returns properly named function 2`] = `"isReadonlyOf(isUniformTupleOf(3, isString))"`;
+
+snapshot[`isReadonlyOf<T> > returns properly named function 3`] = `
+"isReadonlyOf(isObjectOf({
+  a: isString,
+  b: isNumber,
+  c: isBoolean
+}))"
+`;
+
 snapshot[`isOptionalOf<T> > returns properly named function 1`] = `"isOptionalOf(isNumber)"`;
 
 snapshot[`isOptionalOf<T> > returns properly named function 2`] = `"isOptionalOf(isNumber)"`;
diff --git a/is/__snapshots__/factory_test.ts.snap b/is/__snapshots__/factory_test.ts.snap
index 4fff689..4c5b70c 100644
--- a/is/__snapshots__/factory_test.ts.snap
+++ b/is/__snapshots__/factory_test.ts.snap
@@ -1,16 +1,8 @@
 export const snapshot = {};
 
-snapshot[`isSetOf<T> > returns properly named function 1`] = `"isSetOf(isNumber)"`;
-
-snapshot[`isSetOf<T> > returns properly named function 2`] = `"isSetOf((anonymous))"`;
-
-snapshot[`isInstanceOf<T> > returns properly named function 1`] = `"isInstanceOf(Date)"`;
-
-snapshot[`isInstanceOf<T> > returns properly named function 2`] = `"isInstanceOf((anonymous))"`;
-
-snapshot[`isMapOf<T> > returns properly named function 1`] = `"isMapOf(isNumber, undefined)"`;
+snapshot[`isRecordOf<T> > returns properly named function 1`] = `"isRecordOf(isNumber, undefined)"`;
 
-snapshot[`isMapOf<T> > returns properly named function 2`] = `"isMapOf((anonymous), undefined)"`;
+snapshot[`isRecordOf<T> > returns properly named function 2`] = `"isRecordOf((anonymous), undefined)"`;
 
 snapshot[`isTupleOf<T> > returns properly named function 1`] = `
 "isTupleOf([
@@ -34,36 +26,14 @@ snapshot[`isTupleOf<T> > returns properly named function 3`] = `
 ])"
 `;
 
-snapshot[`isMapOf<T, K> > returns properly named function 1`] = `"isMapOf(isNumber, isString)"`;
-
-snapshot[`isMapOf<T, K> > returns properly named function 2`] = `"isMapOf((anonymous), isString)"`;
-
-snapshot[`isTupleOf<T, E> > returns properly named function 1`] = `
-"isTupleOf([
-  isNumber,
-  isString,
-  isBoolean
-], isArray)"
-`;
-
-snapshot[`isTupleOf<T, E> > returns properly named function 2`] = `"isTupleOf([(anonymous)], isArrayOf(isString))"`;
-
-snapshot[`isTupleOf<T, E> > returns properly named function 3`] = `
-"isTupleOf([
-  isTupleOf([
-    isTupleOf([
-      isNumber,
-      isString,
-      isBoolean
-    ], isArray)
-  ], isArray)
-])"
-`;
-
 snapshot[`isArrayOf<T> > returns properly named function 1`] = `"isArrayOf(isNumber)"`;
 
 snapshot[`isArrayOf<T> > returns properly named function 2`] = `"isArrayOf((anonymous))"`;
 
+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)"`;
@@ -78,8 +48,58 @@ snapshot[`isLiteralOf<T> > returns properly named function 6`] = `"isLiteralOf(u
 
 snapshot[`isLiteralOf<T> > returns properly named function 7`] = `"isLiteralOf(Symbol(asdf))"`;
 
+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[`isReadonlyTupleOf<T> > returns properly named function 1`] = `
+"isReadonlyOf(isTupleOf([
+  isNumber,
+  isString,
+  isBoolean
+]))"
+`;
+
+snapshot[`isReadonlyTupleOf<T> > returns properly named function 2`] = `"isReadonlyOf(isTupleOf([(anonymous)]))"`;
+
+snapshot[`isReadonlyTupleOf<T> > returns properly named function 3`] = `
+"isReadonlyOf(isTupleOf([
+  isReadonlyOf(isTupleOf([
+    isReadonlyOf(isTupleOf([
+      isNumber,
+      isString,
+      isBoolean
+    ]))
+  ]))
+]))"
+`;
+
+snapshot[`isSetOf<T> > returns properly named function 1`] = `"isSetOf(isNumber)"`;
+
+snapshot[`isSetOf<T> > returns properly named function 2`] = `"isSetOf((anonymous))"`;
+
 snapshot[`isLiteralOneOf<T> > returns properly named function 1`] = `'isLiteralOneOf(["hello", "world"])'`;
 
+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[`isStrictOf<T> > returns properly named function 1`] = `
 "isStrictOf(isObjectOf({
   a: isNumber,
@@ -98,84 +118,64 @@ snapshot[`isStrictOf<T> > returns properly named function 3`] = `
 }))"
 `;
 
+snapshot[`isMapOf<T, K> > returns properly named function 1`] = `"isMapOf(isNumber, isString)"`;
+
+snapshot[`isMapOf<T, K> > returns properly named function 2`] = `"isMapOf((anonymous), isString)"`;
+
+snapshot[`isRecordOf<T, K> > returns properly named function 1`] = `"isRecordOf(isNumber, isString)"`;
+
+snapshot[`isRecordOf<T, K> > returns properly named function 2`] = `"isRecordOf((anonymous), isString)"`;
+
 snapshot[`isReadonlyTupleOf<T, E> > returns properly named function 1`] = `
-"isReadonlyTupleOf([
+"isReadonlyOf(isTupleOf([
   isNumber,
   isString,
   isBoolean
-], isArray)"
+], isArray))"
 `;
 
-snapshot[`isReadonlyTupleOf<T, E> > returns properly named function 2`] = `"isReadonlyTupleOf([(anonymous)], isArrayOf(isString))"`;
+snapshot[`isReadonlyTupleOf<T, E> > returns properly named function 2`] = `"isReadonlyOf(isTupleOf([(anonymous)], isArrayOf(isString)))"`;
 
 snapshot[`isReadonlyTupleOf<T, E> > returns properly named function 3`] = `
-"isReadonlyTupleOf([
-  isReadonlyTupleOf([
-    isReadonlyTupleOf([
+"isReadonlyOf(isTupleOf([
+  isReadonlyOf(isTupleOf([
+    isReadonlyOf(isTupleOf([
       isNumber,
       isString,
       isBoolean
-    ], isArray)
-  ], isArray)
-], isArray)"
+    ], isArray))
+  ], isArray))
+], isArray))"
 `;
 
-snapshot[`isReadonlyUniformTupleOf<T> > returns properly named function 1`] = `"isReadonlyUniformTupleOf(3, isAny)"`;
+snapshot[`isReadonlyUniformTupleOf<T> > returns properly named function 1`] = `"isReadonlyOf(isUniformTupleOf(3, isAny))"`;
 
-snapshot[`isReadonlyUniformTupleOf<T> > returns properly named function 2`] = `"isReadonlyUniformTupleOf(3, isNumber)"`;
+snapshot[`isReadonlyUniformTupleOf<T> > returns properly named function 2`] = `"isReadonlyOf(isUniformTupleOf(3, isNumber))"`;
 
-snapshot[`isReadonlyUniformTupleOf<T> > returns properly named function 3`] = `"isReadonlyUniformTupleOf(3, (anonymous))"`;
+snapshot[`isReadonlyUniformTupleOf<T> > returns properly named function 3`] = `"isReadonlyOf(isUniformTupleOf(3, (anonymous)))"`;
 
-snapshot[`isRecordOf<T, K> > returns properly named function 1`] = `"isRecordOf(isNumber, isString)"`;
+snapshot[`isMapOf<T> > returns properly named function 1`] = `"isMapOf(isNumber, undefined)"`;
 
-snapshot[`isRecordOf<T, K> > returns properly named function 2`] = `"isRecordOf((anonymous), isString)"`;
+snapshot[`isMapOf<T> > returns properly named function 2`] = `"isMapOf((anonymous), undefined)"`;
 
-snapshot[`isReadonlyTupleOf<T> > returns properly named function 1`] = `
-"isReadonlyTupleOf([
+snapshot[`isTupleOf<T, E> > returns properly named function 1`] = `
+"isTupleOf([
   isNumber,
   isString,
   isBoolean
-])"
+], isArray)"
 `;
 
-snapshot[`isReadonlyTupleOf<T> > returns properly named function 2`] = `"isReadonlyTupleOf([(anonymous)])"`;
+snapshot[`isTupleOf<T, E> > returns properly named function 2`] = `"isTupleOf([(anonymous)], isArrayOf(isString))"`;
 
-snapshot[`isReadonlyTupleOf<T> > returns properly named function 3`] = `
-"isReadonlyTupleOf([
-  isReadonlyTupleOf([
-    isReadonlyTupleOf([
+snapshot[`isTupleOf<T, E> > returns properly named function 3`] = `
+"isTupleOf([
+  isTupleOf([
+    isTupleOf([
       isNumber,
       isString,
       isBoolean
-    ])
-  ])
+    ], isArray)
+  ], isArray)
 ])"
 `;
-
-snapshot[`isRecordOf<T> > returns properly named function 1`] = `"isRecordOf(isNumber, undefined)"`;
-
-snapshot[`isRecordOf<T> > returns properly named function 2`] = `"isRecordOf((anonymous), undefined)"`;
-
-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[`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})
-  })
-})"
-`;
diff --git a/is/__snapshots__/utility_test.ts.snap b/is/__snapshots__/utility_test.ts.snap
index 40c0897..1fff46d 100644
--- a/is/__snapshots__/utility_test.ts.snap
+++ b/is/__snapshots__/utility_test.ts.snap
@@ -1,5 +1,14 @@
 export const snapshot = {};
 
+snapshot[`isOmitOf<T, K> > returns properly named function 1`] = `
+"isObjectOf({
+  a: isNumber,
+  c: isBoolean
+})"
+`;
+
+snapshot[`isOmitOf<T, K> > returns properly named function 2`] = `"isObjectOf({a: isNumber})"`;
+
 snapshot[`isUnionOf<T> > returns properly named function 1`] = `
 "isUnionOf([
   isNumber,
@@ -8,6 +17,15 @@ snapshot[`isUnionOf<T> > returns properly named function 1`] = `
 ])"
 `;
 
+snapshot[`isPickOf<T, K> > returns properly named function 1`] = `
+"isObjectOf({
+  a: isNumber,
+  c: isBoolean
+})"
+`;
+
+snapshot[`isPickOf<T, K> > returns properly named function 2`] = `"isObjectOf({a: isNumber})"`;
+
 snapshot[`isPartialOf<T> > returns properly named function 1`] = `
 "isObjectOf({
   a: isOptionalOf(isNumber),
@@ -24,27 +42,9 @@ snapshot[`isPartialOf<T> > returns properly named function 2`] = `
 })"
 `;
 
-snapshot[`isOmitOf<T, K> > returns properly named function 1`] = `
-"isObjectOf({
-  a: isNumber,
-  c: isBoolean
-})"
-`;
-
-snapshot[`isOmitOf<T, K> > returns properly named function 2`] = `"isObjectOf({a: isNumber})"`;
-
 snapshot[`isIntersectionOf<T> > returns properly named function 1`] = `
 "isObjectOf({
   a: isNumber,
   b: isString
 })"
 `;
-
-snapshot[`isPickOf<T, K> > returns properly named function 1`] = `
-"isObjectOf({
-  a: isNumber,
-  c: isBoolean
-})"
-`;
-
-snapshot[`isPickOf<T, K> > returns properly named function 2`] = `"isObjectOf({a: isNumber})"`;
diff --git a/is/annotation.ts b/is/annotation.ts
index cbc7abb..f037a4e 100644
--- a/is/annotation.ts
+++ b/is/annotation.ts
@@ -72,7 +72,76 @@ type IsOptionalOfMetadata = {
   args: Parameters<typeof isOptionalOf>;
 };
 
+/**
+ * Return `true` if the type of predicate `x` is `Readonly` predicate.
+ *
+ * ```ts
+ * import { is, type Predicate, type WithReadonly } from "https://deno.land/x/unknownutil@$MODULE_VERSION/mod.ts";
+ *
+ * const pred: Predicate<unknown> = is.ReadonlyOf(is.Unknown);
+ * if (is.Readonly(pred)) {
+ *   // a is narrowed to Predicate<unknown> & WithReadonly
+ *   const _: Predicate<unknown> & WithReadonly = pred;
+ * }
+ * ```
+ */
+export function isReadonly<P extends Predicate<unknown>>(
+  x: P,
+): x is P & WithReadonly {
+  return (x as Partial<WithReadonly>).readonly === true;
+}
+
+/**
+ * Annotate the type predicate function as `Readonly`.
+ */
+export type WithReadonly = {
+  readonly: true;
+};
+
+/**
+ * Return an `Readonly` annotated type predicate function that returns `true` if the type of `x` is `T`.
+ *
+ * Note that the predicate function returned from this factory does nothing but annotate the types.
+ *
+ * To enhance performance, users are advised to cache the return value of this function and mitigate the creation cost.
+ *
+ * ```ts
+ * import { is } from "https://deno.land/x/unknownutil@$MODULE_VERSION/mod.ts";
+ *
+ * const isMyType = is.ReadonlyOf(is.String);
+ * const a: unknown = "a";
+ * if (isMyType(a)) {
+ *   // a is narrowed to string | undefined
+ *   const _: string | undefined = a;
+ * }
+ * ```
+ */
+export function isReadonlyOf<T>(
+  pred: Predicate<T>,
+):
+  & Predicate<Readonly<T>>
+  & WithReadonly
+  & WithMetadata<IsReadonlyOfMetadata> {
+  return Object.defineProperties(
+    setPredicateFactoryMetadata(
+      (x: unknown): x is Readonly<T> => pred(x),
+      { name: "isReadonlyOf", args: [pred] },
+    ),
+    { readonly: { value: true as const } },
+  ) as
+    & Predicate<Readonly<T>>
+    & WithReadonly
+    & WithMetadata<IsReadonlyOfMetadata>;
+}
+
+type IsReadonlyOfMetadata = {
+  name: "isReadonlyOf";
+  args: Parameters<typeof isReadonlyOf>;
+};
+
 export default {
   Optional: isOptional,
   OptionalOf: isOptionalOf,
+  Readonly: isReadonly,
+  ReadonlyOf: isReadonlyOf,
 };
diff --git a/is/annotation_test.ts b/is/annotation_test.ts
index 390214c..fe427ca 100644
--- a/is/annotation_test.ts
+++ b/is/annotation_test.ts
@@ -23,7 +23,8 @@ import {
   isSyncFunction,
   isUndefined,
 } from "./core.ts";
-import is, { isOptionalOf } from "./annotation.ts";
+import { isObjectOf, isTupleOf, isUniformTupleOf } from "./factory.ts";
+import is, { isOptionalOf, isReadonlyOf } from "./annotation.ts";
 
 const examples = {
   string: ["", "Hello world"],
@@ -152,6 +153,39 @@ Deno.test("isOptionalOf<T>", async (t) => {
   });
 });
 
+Deno.test("isReadonlyOf<T>", async (t) => {
+  await t.step("returns properly named function", async (t) => {
+    await assertSnapshot(
+      t,
+      isReadonlyOf(isTupleOf([isString, isNumber, isBoolean])).name,
+    );
+    await assertSnapshot(
+      t,
+      isReadonlyOf(isUniformTupleOf(3, isString)).name,
+    );
+    await assertSnapshot(
+      t,
+      isReadonlyOf(isObjectOf({ a: isString, b: isNumber, c: isBoolean })).name,
+    );
+  });
+  await t.step("returns proper type predicate", () => {
+    const a: unknown = undefined;
+    if (isReadonlyOf(isTupleOf([isString, isNumber, isBoolean]))(a)) {
+      assertType<Equal<typeof a, readonly [string, number, boolean]>>(true);
+    }
+    if (isReadonlyOf(isUniformTupleOf(3, isString))(a)) {
+      assertType<Equal<typeof a, readonly [string, string, string]>>(true);
+    }
+    if (
+      isReadonlyOf(isObjectOf({ a: isString, b: isNumber, c: isBoolean }))(a)
+    ) {
+      assertType<
+        Equal<typeof a, Readonly<{ a: string; b: number; c: boolean }>>
+      >(true);
+    }
+  });
+});
+
 Deno.test("is", async (t) => {
   const mod = await import("./annotation.ts");
   const casesOfAliasAndIsFunction = Object.entries(mod)
diff --git a/is/factory.ts b/is/factory.ts
index 42012c7..b873169 100644
--- a/is/factory.ts
+++ b/is/factory.ts
@@ -1,6 +1,11 @@
 import type { FlatType } from "../_typeutil.ts";
 import type { Predicate, PredicateType } from "./type.ts";
-import { isOptional, type WithOptional } from "./annotation.ts";
+import {
+  isOptional,
+  isReadonlyOf,
+  type WithOptional,
+  type WithReadonly,
+} from "./annotation.ts";
 import {
   isAny,
   isArray,
@@ -10,11 +15,14 @@ import {
   type Primitive,
 } from "./core.ts";
 import {
+  type GetMetadata,
   getPredicateFactoryMetadata,
   setPredicateFactoryMetadata,
   type WithMetadata,
 } from "../metadata.ts";
 
+type IsReadonlyOfMetadata = GetMetadata<ReturnType<typeof isReadonlyOf>>;
+
 /**
  * Return a type predicate function that returns `true` if the type of `x` is `T[]`.
  *
@@ -231,12 +239,17 @@ type IsTupleOfMetadata = {
  *   const _: readonly [number, string, boolean] = a;
  * }
  * ```
+ *
+ * @deprecated Use `isReadonlyOf(isTupleOf(...))` instead.
  */
 export function isReadonlyTupleOf<
   T extends readonly [Predicate<unknown>, ...Predicate<unknown>[]],
 >(
   predTup: T,
-): Predicate<ReadonlyTupleOf<T>> & WithMetadata<IsReadonlyTupleOfMetadata>;
+):
+  & Predicate<Readonly<TupleOf<T>>>
+  & WithReadonly
+  & WithMetadata<IsReadonlyOfMetadata>;
 export function isReadonlyTupleOf<
   T extends readonly [Predicate<unknown>, ...Predicate<unknown>[]],
   E extends Predicate<unknown[]>,
@@ -244,8 +257,9 @@ export function isReadonlyTupleOf<
   predTup: T,
   predElse: E,
 ):
-  & Predicate<readonly [...ReadonlyTupleOf<T>, ...PredicateType<E>]>
-  & WithMetadata<IsReadonlyTupleOfMetadata>;
+  & Predicate<Readonly<[...ReadonlyTupleOf<T>, ...PredicateType<E>]>>
+  & WithReadonly
+  & WithMetadata<IsReadonlyOfMetadata>;
 export function isReadonlyTupleOf<
   T extends readonly [Predicate<unknown>, ...Predicate<unknown>[]],
   E extends Predicate<unknown[]>,
@@ -254,36 +268,21 @@ export function isReadonlyTupleOf<
   predElse?: E,
 ):
   & Predicate<
-    ReadonlyTupleOf<T> | readonly [...ReadonlyTupleOf<T>, ...PredicateType<E>]
+    | Readonly<TupleOf<T>>
+    | Readonly<[...ReadonlyTupleOf<T>, ...PredicateType<E>]>
   >
-  & WithMetadata<IsReadonlyTupleOfMetadata> {
+  & WithReadonly
+  & WithMetadata<IsReadonlyOfMetadata> {
   if (!predElse) {
-    return setPredicateFactoryMetadata(
-      isTupleOf(predTup) as Predicate<ReadonlyTupleOf<T>>,
-      { name: "isReadonlyTupleOf", args: [predTup] },
-    );
-  } else {
-    return setPredicateFactoryMetadata(
-      isTupleOf(predTup, predElse) as unknown as Predicate<
-        readonly [...ReadonlyTupleOf<T>, ...PredicateType<E>]
-      >,
-      { name: "isReadonlyTupleOf", args: [predTup, predElse] },
-    );
+    return isReadonlyOf(isTupleOf(predTup));
   }
+  return isReadonlyOf(isTupleOf(predTup, predElse));
 }
 
 type ReadonlyTupleOf<T> = {
   [P in keyof T]: T[P] extends Predicate<infer U> ? U : never;
 };
 
-type IsReadonlyTupleOfMetadata = {
-  name: "isReadonlyTupleOf";
-  args: [
-    Parameters<typeof isReadonlyTupleOf>[0],
-    Parameters<typeof isReadonlyTupleOf>[1]?,
-  ];
-};
-
 /**
  * Return a type predicate function that returns `true` if the type of `x` is `UniformTupleOf<T>`.
  *
@@ -368,31 +367,19 @@ type IsUniformTupleOfMetadata = {
  *   const _: readonly [number, number, number, number, number] = a;
  * }
  * ```
+ *
+ * @deprecated Use `isReadonlyOf(isUniformTupleOf(...))` instead.
  */
 export function isReadonlyUniformTupleOf<T, N extends number>(
   n: N,
   pred: Predicate<T> = isAny,
 ):
-  & Predicate<ReadonlyUniformTupleOf<T, N>>
-  & WithMetadata<IsReadonlyUniformTupleOfMetadata> {
-  return setPredicateFactoryMetadata(
-    isUniformTupleOf(n, pred) as Predicate<ReadonlyUniformTupleOf<T, N>>,
-    { name: "isReadonlyUniformTupleOf", args: [n, pred] },
-  );
+  & Predicate<Readonly<UniformTupleOf<T, N>>>
+  & WithReadonly
+  & WithMetadata<IsReadonlyOfMetadata> {
+  return isReadonlyOf(isUniformTupleOf(n, pred));
 }
 
-type ReadonlyUniformTupleOf<
-  T,
-  N extends number,
-  R extends readonly T[] = [],
-> = R["length"] extends N ? R
-  : ReadonlyUniformTupleOf<T, N, readonly [T, ...R]>;
-
-type IsReadonlyUniformTupleOfMetadata = {
-  name: "isReadonlyUniformTupleOf";
-  args: Parameters<typeof isReadonlyUniformTupleOf>;
-};
-
 /**
  * Return a type predicate function that returns `true` if the type of `x` is `Record<K, T>`.
  *