👍 Add isOneOf<T>

Author: lambdalisue

is.ts

@@ -178,6 +178,30 @@ export function isNullish(x: unknown): x is null | undefined {
   return x == null;
 }
 
+export type OneOf<T> = T extends (infer U)[]
+  ? T extends Predicate<infer U>[] ? U : T
+  : T;
+
+/**
+ * Return a type predicate function that returns `true` if the type of `x` is `OneOf<T>`.
+ *
+ * ```ts
+ * import is from "./is.ts";
+ *
+ * const preds = [is.Number, is.String, is.Boolean];
+ * const a: unknown = { a: 0, b: "a", c: true };
+ * if (is.OneOf(preds)(a)) {
+ *  // a is narrowed to number | string | boolean;
+ *  const _: number | string | boolean = a;
+ * }
+ * ```
+ */
+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));
+}
+
 export default {
   String: isString,
   Number: isNumber,
@@ -192,4 +216,5 @@ export default {
   Null: isNull,
   Undefined: isUndefined,
   Nullish: isNullish,
+  OneOf: isOneOf,
 };

is_test.ts

@@ -11,6 +11,7 @@ import is, {
   isNullish,
   isNumber,
   isObjectOf,
+  isOneOf,
   isRecord,
   isRecordOf,
   isString,
@@ -32,6 +33,7 @@ Deno.test("is defines aliases of functions", () => {
   assertStrictEquals(is.Null, isNull);
   assertStrictEquals(is.Undefined, isUndefined);
   assertStrictEquals(is.Nullish, isNullish);
+  assertStrictEquals(is.OneOf, isOneOf);
 });
 
 Deno.test("isString", async (t) => {
@@ -277,3 +279,27 @@ Deno.test("isNullish", async (t) => {
     assertEquals(isNullish(function () {}), false);
   });
 });
+
+Deno.test("isOneOf<T>", async (t) => {
+  await t.step("returns true on one of T", () => {
+    const preds = [isNumber, isString, isBoolean];
+    assertEquals(isOneOf(preds)(0), true);
+    assertEquals(isOneOf(preds)("a"), true);
+    assertEquals(isOneOf(preds)(true), true);
+  });
+  await t.step("returns false on non of T", () => {
+    const preds = [isNumber, isString, isBoolean];
+    assertEquals(isOneOf(preds)([]), false);
+    assertEquals(isOneOf(preds)({}), false);
+    assertEquals(isOneOf(preds)(function () {}), false);
+    assertEquals(isOneOf(preds)(null), false);
+    assertEquals(isOneOf(preds)(undefined), false);
+  });
+  await t.step("returns proper type predicate", () => {
+    const preds = [isNumber, isString, isBoolean];
+    const a: unknown = [0, "a", true];
+    if (isOneOf(preds)(a)) {
+      const _: number | string | boolean = a;
+    }
+  });
+});