💪 Individually define utility functions

Author: lambdalisue

util.ts assert.ts

@@ -92,49 +92,3 @@ export function assert<T>(
     );
   }
 }
-
-/**
- * Ensures that the given value satisfies the provided predicate.
- *
- * ```ts
- * import { ensure, is } from "@core/unknownutil";
- *
- * const a: unknown = "hello";
- * const _: string = ensure(a, is.String);
- * ```
- *
- * @param x The value to be ensured.
- * @param pred The predicate function to test the value against.
- * @param options Optional configuration for the assertion.
- * @returns The input value `x`.
- * @throws {AssertError} If the value does not satisfy the predicate.
- */
-export function ensure<T>(
-  x: unknown,
-  pred: Predicate<T>,
-  options: { message?: string; name?: string } = {},
-): T {
-  assert(x, pred, options);
-  return x;
-}
-
-/**
- * Returns the input value if it satisfies the provided predicate, or `undefined` otherwise.
- *
- * ```ts
- * import { is, maybe } from "@core/unknownutil";
- *
- * const a: unknown = "hello";
- * const _: string = maybe(a, is.String) ?? "default value";
- * ```
- *
- * @param x The value to be tested.
- * @param pred The predicate function to test the value against.
- * @returns The input value `x` if it satisfies the predicate, or `undefined` otherwise.
- */
-export function maybe<T>(
-  x: unknown,
-  pred: Predicate<T>,
-): T | undefined {
-  return pred(x) ? x : undefined;
-}

assert_test.ts

@@ -0,0 +1,67 @@
+import { assertThrows } from "@std/assert";
+import {
+  assert,
+  AssertError,
+  defaultAssertMessageFactory,
+  setAssertMessageFactory,
+} from "./assert.ts";
+
+const x: unknown = Symbol("x");
+
+function truePredicate(_x: unknown): _x is string {
+  return true;
+}
+
+function falsePredicate(_x: unknown): _x is string {
+  return false;
+}
+
+Deno.test("assert", async (t) => {
+  await t.step("does nothing on true predicate", () => {
+    assert(x, truePredicate);
+  });
+
+  await t.step("throws an `AssertError` on false predicate", () => {
+    assertThrows(
+      () => assert(x, falsePredicate),
+      AssertError,
+      `Expected a value that satisfies the predicate falsePredicate, got symbol: undefined`,
+    );
+  });
+
+  await t.step(
+    "throws an `AssertError` on false predicate with a custom name",
+    () => {
+      assertThrows(
+        () => assert(x, falsePredicate, { name: "hello world" }),
+        AssertError,
+        `Expected hello world that satisfies the predicate falsePredicate, got symbol: undefined`,
+      );
+    },
+  );
+
+  await t.step(
+    "throws an `AssertError` with a custom message on false predicate",
+    () => {
+      assertThrows(
+        () => assert(x, falsePredicate, { message: "Hello" }),
+        AssertError,
+        "Hello",
+      );
+    },
+  );
+});
+
+Deno.test("setAssertMessageFactory", async (t) => {
+  setAssertMessageFactory((x, pred) => `Hello ${typeof x} ${pred.name}`);
+
+  await t.step("change `AssertError` message on `assert` failure", () => {
+    assertThrows(
+      () => assert(x, falsePredicate),
+      AssertError,
+      "Hello symbol falsePredicate",
+    );
+  });
+
+  setAssertMessageFactory(defaultAssertMessageFactory);
+});

ensure.ts

@@ -0,0 +1,27 @@
+import type { Predicate } from "./type.ts";
+import { assert } from "./assert.ts";
+
+/**
+ * Ensures that the given value satisfies the provided predicate.
+ *
+ * ```ts
+ * import { ensure, is } from "@core/unknownutil";
+ *
+ * const a: unknown = "hello";
+ * const _: string = ensure(a, is.String);
+ * ```
+ *
+ * @param x The value to be ensured.
+ * @param pred The predicate function to test the value against.
+ * @param options Optional configuration for the assertion.
+ * @returns The input value `x`.
+ * @throws {AssertError} If the value does not satisfy the predicate.
+ */
+export function ensure<T>(
+  x: unknown,
+  pred: Predicate<T>,
+  options: { message?: string; name?: string } = {},
+): T {
+  assert(x, pred, options);
+  return x;
+}

util_test.ts ensure_test.ts

@@ -1,12 +1,10 @@
 import { assertStrictEquals, assertThrows } from "@std/assert";
 import {
-  assert,
   AssertError,
   defaultAssertMessageFactory,
-  ensure,
-  maybe,
   setAssertMessageFactory,
-} from "./util.ts";
+} from "./assert.ts";
+import { ensure } from "./ensure.ts";
 
 const x: unknown = Symbol("x");
 
@@ -18,42 +16,6 @@ function falsePredicate(_x: unknown): _x is string {
   return false;
 }
 
-Deno.test("assert", async (t) => {
-  await t.step("does nothing on true predicate", () => {
-    assert(x, truePredicate);
-  });
-
-  await t.step("throws an `AssertError` on false predicate", () => {
-    assertThrows(
-      () => assert(x, falsePredicate),
-      AssertError,
-      `Expected a value that satisfies the predicate falsePredicate, got symbol: undefined`,
-    );
-  });
-
-  await t.step(
-    "throws an `AssertError` on false predicate with a custom name",
-    () => {
-      assertThrows(
-        () => assert(x, falsePredicate, { name: "hello world" }),
-        AssertError,
-        `Expected hello world that satisfies the predicate falsePredicate, got symbol: undefined`,
-      );
-    },
-  );
-
-  await t.step(
-    "throws an `AssertError` with a custom message on false predicate",
-    () => {
-      assertThrows(
-        () => assert(x, falsePredicate, { message: "Hello" }),
-        AssertError,
-        "Hello",
-      );
-    },
-  );
-});
-
 Deno.test("ensure", async (t) => {
   await t.step("returns `x` as-is on true predicate", () => {
     assertStrictEquals(ensure(x, truePredicate), x);
@@ -90,27 +52,9 @@ Deno.test("ensure", async (t) => {
   );
 });
 
-Deno.test("maybe", async (t) => {
-  await t.step("returns `x` as-is on true predicate", () => {
-    assertStrictEquals(maybe(x, truePredicate), x);
-  });
-
-  await t.step("returns `undefined` on false predicate", () => {
-    assertStrictEquals(maybe(x, falsePredicate), undefined);
-  });
-});
-
 Deno.test("setAssertMessageFactory", async (t) => {
   setAssertMessageFactory((x, pred) => `Hello ${typeof x} ${pred.name}`);
 
-  await t.step("change `AssertError` message on `assert` failure", () => {
-    assertThrows(
-      () => assert(x, falsePredicate),
-      AssertError,
-      "Hello symbol falsePredicate",
-    );
-  });
-
   await t.step("change `AssertError` message on `ensure` failure", () => {
     assertThrows(
       () => ensure(x, falsePredicate),

maybe.ts

@@ -0,0 +1,22 @@
+import type { Predicate } from "./type.ts";
+
+/**
+ * Returns the input value if it satisfies the provided predicate, or `undefined` otherwise.
+ *
+ * ```ts
+ * import { is, maybe } from "@core/unknownutil";
+ *
+ * const a: unknown = "hello";
+ * const _: string = maybe(a, is.String) ?? "default value";
+ * ```
+ *
+ * @param x The value to be tested.
+ * @param pred The predicate function to test the value against.
+ * @returns The input value `x` if it satisfies the predicate, or `undefined` otherwise.
+ */
+export function maybe<T>(
+  x: unknown,
+  pred: Predicate<T>,
+): T | undefined {
+  return pred(x) ? x : undefined;
+}

maybe_test.ts

@@ -0,0 +1,22 @@
+import { assertStrictEquals } from "@std/assert";
+import { maybe } from "./maybe.ts";
+
+const x: unknown = Symbol("x");
+
+function truePredicate(_x: unknown): _x is string {
+  return true;
+}
+
+function falsePredicate(_x: unknown): _x is string {
+  return false;
+}
+
+Deno.test("maybe", async (t) => {
+  await t.step("returns `x` as-is on true predicate", () => {
+    assertStrictEquals(maybe(x, truePredicate), x);
+  });
+
+  await t.step("returns `undefined` on false predicate", () => {
+    assertStrictEquals(maybe(x, falsePredicate), undefined);
+  });
+});

mod.ts

@@ -241,6 +241,10 @@
  */
 
 export type * from "./type.ts";
+
 export * from "./as/mod.ts";
 export * from "./is/mod.ts";
-export * from "./util.ts";
+
+export * from "./assert.ts";
+export * from "./ensure.ts";
+export * from "./maybe.ts";