👍 Add isIncludeIn

[Milly]

A convenience function that defines a union type enum.

[lambdalisue]

Blocked by #33

[lambdalisue]

What is the advantage of this isIncludeIn function over isOneOf? It seems the function is useless for object or array while it compoare values with SameValueZero algorithm?

[Milly]

The purpose of this function is to check the type of the Union type Enum that consists mainly of strings.

import is, { type Predicate } from "./is.ts";

export type Enum = "foo" | "bar" | "baz";

// Implement as `IncludeIn`
export const isEnum: Predicate<Enum> = is.IncludeIn(
  ["foo", "bar", "baz"] as const,
);

const value: unknown = "foo";
if (isEnum(value)) {
  const _: Enum = value;
}

// Same thing as `OneOf`
export const isEnumByOneOf: Predicate<Enum> = is.OneOf([
  (x: unknown): x is "foo" => x === "foo",
  (x: unknown): x is "bar" => x === "bar",
  (x: unknown): x is "baz" => x === "baz",
]);

// Same thing without library
export const isEnumByJS: Predicate<Enum> = (x: unknown): x is Enum =>
  ["foo", "bar", "baz"].includes(x as string);

[lambdalisue]

The purpose of this function is to check the type of the Union type Enum that consists mainly of strings.

The following are some of the disadvantages of isIncludeIn.

1. It ends with "In" instead of "Of" even though it is a Predicate factory function and that's not consistent with existing functions
2. It does not behave as expected even though it is possible to specify an Object or Array to items.

Therefore, if you are assuming a Union type Enum, one of the following would be better

1. Create a function for literal judgment like isLiteralOf<T extends string>(literal: T): Predicate<T> and use it with isOneOf (I personally think this is more consistent with the usage of existing functions)
2. Create a isString derived Union type Enum function like isStringOf<T extends string[]>(items: T): Predicate<T[number]>.

What do you think?

[Milly]

I want it to be a function that takes an array of literal values.
How about the following?

type Primitive =
  | null
  | undefined
  | string
  | number
  | boolean
  | symbol
  | bigint;

function isLiteralOf<T extends readonly Primitive[]>(literals: T): Predicate<T[number]>;

[lambdalisue]

Does TypeScript support a literal type of null, undefined, symbol, or bigint? If not, T must not contain those I think.

[Milly]

Typescript (and JavaScript, of course) treats null, undefined, symbol, or bigint as primitives.
Unfortunately the standard library does not define a union type like Primitive.

[lambdalisue]

Typescript (and JavaScript, of course) treats null, undefined, symbol, or bigint as primitives.

Yes but my wondering is a bit different. I'm wondering that what about "literal types" in TypeScript.

https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types

As long as we define isLiteralOf or whatever, we'd like to follow TypeScript convension.

[Milly]

How about naming it isPrimitiveOf()?

[lambdalisue]

How about naming it isPrimitiveOf()?

It makes sense but does it useful? What that function is for? (I'm asking because I want to keep a function responsibilities as small as possible.)

[lambdalisue]

I prefer isLiteralOf over isPrimitiveOf because I think "string" or 100 is literal type but primitive type.

But I'm not sure if we should call null and undefined is "literal type"...

[lambdalisue]

Close due to #35