🐛 Fix asOptional and asReadonly for type

Author: lambdalisue

as/optional.ts

@@ -1,5 +1,5 @@
 import { rewriteName } from "../_funcutil.ts";
-import type { Predicate } from "../type.ts";
+import type { Predicate, PredicateType } from "../type.ts";
 import {
   annotate,
   hasAnnotation,
@@ -25,21 +25,30 @@ import {
  * }
  * ```
  */
-export function asOptional<T>(
-  pred: Predicate<T>,
-): Predicate<T | undefined> & WithOptional<T> {
+export function asOptional<P extends Predicate<unknown>>(
+  pred: P,
+):
+  & Extract<P, Predicate<PredicateType<P>>>
+  & Predicate<PredicateType<P> | undefined>
+  & WithOptional<PredicateType<P>> {
   if (hasAnnotation(pred, "optional")) {
-    return pred as Predicate<T | undefined> & WithOptional<T>;
+    return pred as
+      & Extract<P, Predicate<PredicateType<P>>>
+      & Predicate<PredicateType<P> | undefined>
+      & WithOptional<PredicateType<P>>;
   }
   return rewriteName(
     annotate(
-      (x: unknown): x is T | undefined => x === undefined || pred(x),
+      (x: unknown) => x === undefined || pred(x),
       "optional",
       pred,
     ),
     "asOptional",
     pred,
-  ) as Predicate<T | undefined> & WithOptional<T>;
+  ) as unknown as
+    & Extract<P, Predicate<PredicateType<P>>>
+    & Predicate<PredicateType<P> | undefined>
+    & WithOptional<PredicateType<P>>;
 }
 
 /**

as/readonly.ts

@@ -1,5 +1,5 @@
 import { rewriteName } from "../_funcutil.ts";
-import type { Predicate } from "../type.ts";
+import type { Predicate, PredicateType } from "../type.ts";
 import {
   annotate,
   hasAnnotation,
@@ -25,21 +25,21 @@ import {
  * }
  * ```
  */
-export function asReadonly<T>(
-  pred: Predicate<T>,
-): Predicate<T> & WithReadonly {
+export function asReadonly<P extends Predicate<unknown>>(
+  pred: P,
+): P & WithReadonly {
   if (hasAnnotation(pred, "readonly")) {
-    return pred as Predicate<T> & WithReadonly;
+    return pred as P & WithReadonly;
   }
   return rewriteName(
     annotate(
-      (x: unknown): x is T => pred(x),
+      (x: unknown) => pred(x),
       "readonly",
       pred,
     ),
     "asReadonly",
     pred,
-  ) as Predicate<T> & WithReadonly;
+  ) as unknown as P & WithReadonly;
 }
 
 /**

is/object_of_test.ts

@@ -3,6 +3,7 @@ import { assertSnapshot } from "@std/testing/snapshot";
 import { assertType } from "@std/testing/types";
 import { type Equal, testWithExamples } from "../_testutil.ts";
 import { is } from "./mod.ts";
+import { as } from "../as/mod.ts";
 import { isObjectOf } from "./object_of.ts";
 
 Deno.test("isObjectOf<T>", async (t) => {
@@ -82,6 +83,32 @@ Deno.test("isObjectOf<T>", async (t) => {
     };
     assertEquals(isObjectOf(predObj)(date), true, "Value is not an object");
   });
+  await t.step("with asOptional/asReadonly", () => {
+    const predObj = {
+      a: as.Readonly(as.Optional(is.String)),
+      b: as.Optional(as.Readonly(is.String)),
+      c: as.Readonly(is.String),
+      d: as.Optional(is.String),
+      e: as.Unreadonly(as.Unoptional(as.Readonly(as.Optional(is.String)))),
+      f: as.Unoptional(as.Unreadonly(as.Optional(as.Readonly(is.String)))),
+    };
+    const a: unknown = undefined;
+    if (isObjectOf(predObj)(a)) {
+      assertType<
+        Equal<
+          typeof a,
+          {
+            readonly a?: string;
+            readonly b?: string;
+            readonly c: string;
+            d?: string;
+            e: string;
+            f: string;
+          }
+        >
+      >(true);
+    }
+  });
   await testWithExamples(
     t,
     isObjectOf({ a: (_: unknown): _ is unknown => false }),