inferred-types 0.33.4 → 0.34.2

package/src/runtime/combinators/or.ts

@@ -1,15 +1,5 @@
-import { LogicFunction } from "src/types/functions";
+import { Or } from "src/types/boolean-logic/Or";
 
-/**
- * Groups a number of "logic functions" together by combining their results using
- * the logical **OR** operator.
- *
- * **Note:** a "logic function" is any function which returns a boolean
- */
-export const or = <T extends any[]>(...ops: LogicFunction<T>[]): LogicFunction<T> => {
-  const fn: LogicFunction<T> = (...args: T) => {
-    return [...ops].some((i) => i(...args));
-  };
-
-  return fn;
-};
+export function or<O extends readonly boolean[]>(...conditions: O) {
+  return (conditions.some((v) => v === true) ? true : false) as Or<O>;
+}

package/src/runtime/type-checks/isArray.ts

@@ -1,5 +1,34 @@
-export type IsArray<T> = T extends any[] ? true : false;
+import { IsArray, IfArray } from "src/types/boolean-logic/array";
+import { Narrowable } from "src/types/Narrowable";
 
 export function isArray<T>(i: T) {
   return (Array.isArray(i) === true) as IsArray<T>;
 }
+
+/**
+ * **ifArray**(T, IF, ELSE)
+ *
+ * A utility which evaluates a type `T` for whether it is an array and then
+ */
+export function ifArray<
+  // value which is possibly an array
+  T extends Narrowable,
+  // functions which return a known type
+  IF extends Narrowable,
+  ELSE extends Narrowable
+>(
+  val: T,
+  isAnArray: <N extends T & readonly any[]>(arr: N) => IF,
+  isNotAnArray: <N extends Exclude<T, any[]>>(nonArr: N) => ELSE
+) {
+  return (isArray(val) ? isAnArray(val as any) : isNotAnArray(val as any)) as IfArray<T, IF, ELSE>;
+}
+
+export function ifArrayPartial<T extends Narrowable>() {
+  return <IF extends Narrowable, ELSE extends Narrowable>(
+    isAnArray: <N extends T & readonly any[]>(arr: N) => IF,
+    isNotAnArray: <N extends Exclude<T, any[]>>(nonArr: N) => ELSE
+  ) => {
+    return <V extends T>(val: V) => ifArray(val, isAnArray, isNotAnArray);
+  };
+}

package/src/runtime/type-checks/isBoolean.ts

@@ -1,4 +1,4 @@
-export type IsBoolean<T> = T extends boolean ? true : false;
+import { IsBoolean } from "src/types/boolean-logic";
 
 /**
  * Runtime and type checks whether a variable is a boolean value.

package/src/runtime/type-checks/isFalse.ts

@@ -1,17 +1,29 @@
+import { IfFalse, IsFalse } from "src/types/boolean-logic/boolean";
 import { Narrowable } from "src/types/Narrowable";
-import { IsBoolean } from "./isBoolean";
-
-export type IsFalse<T extends Narrowable> = IsBoolean<T> extends true
-  ? // is a boolean
-    T extends false
-    ? true
-    : true extends T
-    ? false
-    : // is of boolean type; therefore narrow type is unknown
-      unknown
-  : // not a boolean
-    false;
 
 export function isFalse<T>(i: T) {
   return (typeof i === "boolean" && !i) as IsFalse<T>;
 }
+
+/**
+ * **ifTrue**
+ *
+ * Strongly type-aware conditional statement which checks whether a value is
+ * a _true_ and returns one of two values (strongly typed) based on the evaluation
+ * of this criteria.
+ *
+ * @param val the value being tested
+ * @param ifVal the value (strongly typed) returned if val is _true_ value
+ * @param elseVal the value (strongly typed) returned if val is NOT a _true_ value
+ *
+ * Note: at runtime there's no way to distinguish if the value was widely or loosely
+ * typed so unlike the type utility there is no "MAYBE" state but if a wide type if
+ * encountered the _type_ will the union of `IF` and `ELSE`.
+ */
+export function ifFalse<T extends boolean, IF extends Narrowable, ELSE extends Narrowable>(
+  val: T,
+  ifVal: IF,
+  elseVal: ELSE
+) {
+  return (isFalse(val) ? ifVal : elseVal) as IfFalse<T, IF, ELSE, IF | ELSE>;
+}

package/src/runtime/type-checks/isObject.ts

@@ -1,5 +1,5 @@
 import { FunctionType, Narrowable, Not } from "src/types";
-import { IsObject } from "src/types/type-checks";
+import { IsObject } from "src/types/boolean-logic";
 
 export type ObjectType = Not<Record<string, Narrowable>, FunctionType>;
 

package/src/runtime/type-checks/isString.ts

@@ -1,5 +1,5 @@
 import { Narrowable } from "src/types/Narrowable";
-import { IfString, IsString } from "src/types/type-checks/string";
+import { IfString, IsString } from "src/types/boolean-logic/string";
 
 /**
  * **isString**

package/src/runtime/type-checks/isTrue.ts

@@ -1,28 +1,5 @@
-import { Narrowable } from "src/types";
-import type { IsBoolean } from "./isBoolean";
-
-/**
- * Type utility which returns `true` or `false` based on
- * whether the type holds the narrow "true" type.
- * ```ts
- * // true
- * type T = IsTrue<true>;
- * // unknown
- * type U = IsTrue<boolean>;
- * // false
- * type F = IsTrue<false>;
- * type F2 = IsTrue<"false">;
- * ```
- */
-export type IsTrue<T> = IsBoolean<T> extends true
-  ? // is a boolean
-    T extends true
-    ? true
-    : T extends false
-    ? false
-    : unknown
-  : // not a boolean
-    false;
+import { IfTrue, IsTrue } from "src/types/boolean-logic";
+import { Narrowable } from "src/types/Narrowable";
 
 /**
  * Run-time and type checking of whether a variable is `true`.
@@ -35,13 +12,20 @@ export function isTrue<T extends Narrowable>(i: T) {
  * **ifTrue**
  *
  * Strongly type-aware conditional statement which checks whether a value is
- * a _true_ and returns one of two values (strongly typed) based on the evaluation
- * of this criteria.
+ * _true_.
  *
  * @param val the value being tested
  * @param ifVal the value (strongly typed) returned if val is _true_ value
  * @param elseVal the value (strongly typed) returned if val is NOT a _true_ value
+ *
+ * Note: at runtime there's no way to distinguish if the value was widely or loosely
+ * typed so unlike the type utility there is no "MAYBE" state but if a wide type if
+ * encountered the _type_ will the union of `IF` and `ELSE`.
  */
-export function ifTrue<T extends Narrowable, IF, ELSE>(val: T, ifVal: IF, elseVal: ELSE) {
-  return (isTrue(val) ? ifVal : elseVal) as IsTrue<T> extends true ? IF : ELSE;
+export function ifTrue<T extends boolean, IF extends Narrowable, ELSE extends Narrowable>(
+  val: T,
+  ifVal: IF,
+  elseVal: ELSE
+) {
+  return (isTrue(val) ? ifVal : elseVal) as IfTrue<T, IF, ELSE, IF | ELSE>;
 }

package/src/runtime/type-checks/isUndefined.ts

@@ -1,5 +1,5 @@
 import { Narrowable } from "src/types";
-import { IsUndefined } from "src/types/type-checks/IsUndefined";
+import { IsUndefined } from "src/types/boolean-logic/IsUndefined";
 
 export function isUndefined<T extends Narrowable>(i: T) {
   return (typeof i === "undefined") as undefined extends T ? true : false;

package/src/runtime/type-checks/startsWith.ts

@@ -1,5 +1,6 @@
-import { IfStartsWith, StartsWith } from "src/types/type-checks";
-import { IfUndefined } from "src/types/type-checks/IsUndefined";
+import { Narrowable } from "src/types";
+import { IfStartsWith, StartsWith } from "src/types/boolean-logic";
+import { IfUndefined } from "src/types/boolean-logic/IsUndefined";
 import { createFnWithProps } from "../createFnWithProps";
 import { box, Box } from "../literals";
 import { ifTrue } from "./isTrue";
@@ -88,22 +89,19 @@ export type StringLiteralFn<S extends string = string> = <T extends S>(input: T)
  * returns is able to
  */
 export const ifStartsWith =
-  <
-    TStartsWith extends string,
-    TIf extends <T extends string>(input: T) => any,
-    TElse extends <T extends string>(input: T) => any
-  >(
+  <TStartsWith extends string, TIf extends Narrowable, TElse extends Narrowable>(
     /** the string literal _start value_ which a string must begin with */
     start: TStartsWith,
     /** a mutation function when a value _does_ start with `TStartsWith` */
-    isTrue: TIf,
+    isTrue: <T extends string>(input: T) => TIf,
     /** an optional mutation function */
-    isFalse: TElse
+    isFalse: <T extends string>(input: T) => TElse
   ) =>
-  <I extends string>(input: I) =>
+  <TTextValue extends string>(input: TTextValue) =>
     ifTrue(
       // condition
       startsWith(start)(input),
+      // handlers
       isTrue(input),
       isFalse(input)
-    ) as IfStartsWith<I, TStartsWith, ReturnType<TIf>, ReturnType<TElse>>;
+    );

package/src/types/Mutable.ts

@@ -1,4 +1,4 @@
-import { IsObject } from "./type-checks";
+import { IsObject } from "./boolean-logic";
 
 /**
  * Makes a readonly structure mutable

package/src/types/Narrowable.ts

@@ -2,5 +2,4 @@
  * A union of types used in conjunction with the `literalValues()` function
  * to produce a _narrow_ type definition of a passed in dictionary object.
  */
-export type Narrowable =
-  string | number | boolean | symbol | object | undefined | void | null | {};
+export type Narrowable = string | number | boolean | symbol | object | undefined | void | null | {};

package/src/types/boolean-logic/EndsWith.ts

@@ -0,0 +1,40 @@
+import { IsStringLiteral } from "src/types/boolean-logic";
+import { Narrowable } from "../Narrowable";
+
+/**
+ * **EndsWith**<T,U>
+ *
+ * A type utility which checks whether `T` _ends with_ the string literal `U`.
+ *
+ * If both `T` and `U` are string literals then the type system will resolve
+ * to a literal `true` or `false` but if either is not a literal that it will
+ * just resolve to `boolean` as the value can not be known at design time..
+ */
+export type EndsWith<
+  TValue extends string,
+  TEndsWith extends string
+> = IsStringLiteral<TEndsWith> extends true
+  ? IsStringLiteral<TValue> extends true // both literals
+    ? TValue extends `${string}${TEndsWith}`
+      ? true
+      : false
+    : boolean
+  : boolean;
+
+/**
+ * **IfEndsWith**<TValue, TEndsWith, IF, ELSE, MAYBE>
+ *
+ * Type utility which converts type to `IF` type _if_ `TValue` _ends with_ `TEndsWith` but
+ * otherwise converts type to `ELSE`. If there are wide types in the mix then the type will
+ * result in the union of IF and ELSE.
+ */
+export type IfEndsWith<
+  TValue extends string,
+  TEndsWith extends string,
+  IF extends Narrowable,
+  ELSE extends Narrowable
+> = EndsWith<TValue, TEndsWith> extends true
+  ? IF
+  : EndsWith<TValue, TEndsWith> extends false
+  ? ELSE
+  : IF | ELSE;

package/src/types/boolean-logic/Extends.ts

@@ -0,0 +1,22 @@
+import { Narrowable } from "../Narrowable";
+
+/**
+ * **Extends**`<T, EXTENDS>`
+ *
+ * Boolean type utility which returns `true` if `T` _extends_ `EXTENDS`.
+ */
+export type Extends<T extends Narrowable, EXTENDS extends Narrowable> = T extends EXTENDS
+  ? true
+  : false;
+/**
+ * **IfExtends**
+ *
+ * Branching type utility which returns type `IF` when `E` _extends_ `T`; otherwise
+ * it will return the type `ELSE`.
+ */
+export type IfExtends<
+  T extends Narrowable,
+  EXTENDS extends Narrowable,
+  IF extends Narrowable,
+  ELSE extends Narrowable
+> = Extends<T, EXTENDS> extends true ? IF : ELSE;

package/src/types/{type-checks → boolean-logic}/Includes.ts

@@ -1,9 +1,8 @@
 import { TupleToUnion } from "../type-conversion";
-import { IsLiteral } from "./IsLiteral";
-import { IsStringLiteral } from "./IsStringLiteral";
+import { IsLiteral, IsStringLiteral } from "./IsLiteral";
 
 /**
- * **Includes<TSource, TValue>**
+ * **Includes**`<TSource, TValue>`
  *
  * Type utility which returns `true` or `false` based on whether `TValue` is found
  * in `TSource`. Where `TSource` can be a string literal or an array of string literals.
@@ -13,7 +12,7 @@ import { IsStringLiteral } from "./IsStringLiteral";
  * a type of `boolean`.
  */
 export type Includes<
-  TSource extends string | string[],
+  TSource extends string | readonly string[],
   TValue extends string
 > = TSource extends string[]
   ? IsStringLiteral<TupleToUnion<TSource>> extends true

package/src/types/{type-checks → boolean-logic}/IsLiteral.ts

@@ -1,6 +1,47 @@
-import { IsBooleanLiteral } from "./IsBooleanLiteral";
-import { IsStringLiteral } from "./IsStringLiteral";
-import { IsNumericLiteral } from "./IsNumericLiteral";
+import { Narrowable } from "../Narrowable";
+import { IsBooleanLiteral } from "./boolean";
+
+/**
+ * **IsStringLiteral**
+ *
+ * Type utility which returns true/false if the string a _string literal_ versus
+ * just the _string_ type.
+ */
+export type IsStringLiteral<T extends Narrowable> = [T] extends [string]
+  ? string extends T
+    ? false
+    : true
+  : false;
+
+/**
+ * **IfStringLiteral**
+ *
+ * Branch utility which returns `IF` type when `T` is a string literal and `ELSE` otherwise
+ */
+export type IfStringLiteral<T extends string, IF extends Narrowable, ELSE extends Narrowable> = [
+  IsStringLiteral<T>
+] extends [true]
+  ? IF
+  : ELSE;
+
+/**
+ * **IsNumericLiteral**
+ *
+ * Type utility which returns true/false if the numeric value a _numeric literal_ versus
+ * just the _number_ type.
+ */
+export type IsNumericLiteral<T extends number> = number extends T ? false : true;
+
+/**
+ * **IfNumericLiteral**
+ *
+ * Branch utility which returns `IF` type when `T` is a numeric literal and `ELSE` otherwise
+ */
+export type IfNumericLiteral<
+  T extends number,
+  IF extends Narrowable,
+  ELSE extends Narrowable
+> = IsNumericLiteral<T> extends true ? IF : ELSE;
 
 // [note on handling of boolean](https://stackoverflow.com/questions/74213646/detecting-type-literals-works-in-isolation-but-not-when-combined-with-other-lite/74213713#74213713)
 
@@ -43,7 +84,9 @@ export type IsOptionalLiteral<T> = [Exclude<T, undefined>] extends [string]
  *
  * Branch type utility with return `IF` when `T` is a _literal_ value and `ELSE` otherwise
  */
-export type IfLiteral<T, IF, ELSE> = IsLiteral<T> extends true ? IF : ELSE;
+export type IfLiteral<T, IF extends Narrowable, ELSE extends Narrowable> = IsLiteral<T> extends true
+  ? IF
+  : ELSE;
 
 /**
  * **IfOptionalLiteral**
@@ -51,4 +94,8 @@ export type IfLiteral<T, IF, ELSE> = IsLiteral<T> extends true ? IF : ELSE;
  * Branch type utility with return `IF` when `T` is a _literal_ value (with possibly
  * the inclusion of _undefined_); otherwise returns the type `ELSE`
  */
-export type IfOptionalLiteral<T, IF, ELSE> = IsOptionalLiteral<T> extends true ? IF : ELSE;
+export type IfOptionalLiteral<
+  T,
+  IF extends Narrowable,
+  ELSE extends Narrowable
+> = IsOptionalLiteral<T> extends true ? IF : ELSE;

package/src/types/boolean-logic/IsScalar.ts

@@ -0,0 +1,20 @@
+import { Narrowable } from "../Narrowable";
+
+export type IsScalar<T extends Narrowable> = [T] extends [string]
+  ? true
+  : [T] extends [number]
+  ? true
+  : [T] extends [boolean]
+  ? true
+  : false;
+
+/**
+ * **IfScalar**`<T, IF, ELSE>`
+ *
+ * Branch type utility which returns `IF` when `T` is a scalar value (aka, string, number, or boolean) and `ELSE` otherwise
+ */
+export type IfScalar<
+  T extends Narrowable,
+  IF extends Narrowable,
+  ELSE extends Narrowable
+> = IsScalar<T> extends true ? IF : ELSE;

package/src/types/{type-checks → boolean-logic}/IsUndefined.ts

@@ -13,4 +13,8 @@ export type IsUndefined<T extends Narrowable> = T extends undefined ? true : fal
  * Type utility which returns `IF` type when `T` is an _undefined_
  * otherwise returns `ELSE` type.
  */
-export type IfUndefined<T, IF, ELSE> = IsUndefined<T> extends true ? IF : ELSE;
+export type IfUndefined<
+  T,
+  IF extends Narrowable,
+  ELSE extends Narrowable
+> = IsUndefined<T> extends true ? IF : ELSE;

package/src/types/boolean-logic/Or.ts

@@ -0,0 +1,12 @@
+import { NarrowlyContains } from "./array";
+
+/**
+ * **Or**`<T>`
+ *
+ * Takes an array of boolean values and produces a boolean OR across these values
+ */
+export type Or<T extends readonly boolean[]> = NarrowlyContains<true, T> extends true
+  ? true
+  : NarrowlyContains<boolean, T> extends true
+  ? boolean
+  : false;

package/src/types/{type-checks → boolean-logic}/StartsWith.ts

@@ -1,4 +1,4 @@
-import { IfStringLiteral } from "src/types/type-checks";
+import { IsStringLiteral } from "src/types/boolean-logic";
 import { Narrowable } from "../Narrowable";
 /**
  * **StartsWith**<TValue, TStartsWith>
@@ -9,17 +9,16 @@ import { Narrowable } from "../Narrowable";
  * to a literal `true` or `false` but if either is not a literal that it will
  * just resolve to `boolean` as the value can not be known at design time..
  */
-export type StartsWith<TValue extends unknown, TStartsWith extends unknown> = TValue extends string
-  ? TStartsWith extends string
+export type StartsWith<
+  TValue extends string,
+  TStartsWith extends string
+> = IsStringLiteral<TStartsWith> extends true
+  ? IsStringLiteral<TValue> extends true // both literals
     ? TValue extends `${TStartsWith}${string}`
-      ? IfStringLiteral<
-          TValue, //
-          IfStringLiteral<TStartsWith, true, boolean>,
-          boolean
-        >
-      : IfStringLiteral<TValue, false, boolean>
-    : false
-  : false;
+      ? true
+      : false
+    : boolean
+  : boolean;
 
 /**
  * **IfStartsWith**<TValue, TStartsWith, IF, ELSE, MAYBE>
@@ -32,8 +31,8 @@ export type StartsWith<TValue extends unknown, TStartsWith extends unknown> = TV
  * type and therefore the type is unknown at design time.
  */
 export type IfStartsWith<
-  TValue extends unknown,
-  TStartsWith extends unknown,
+  TValue extends string,
+  TStartsWith extends string,
   IF extends Narrowable,
   ELSE extends Narrowable
 > = StartsWith<TValue, TStartsWith> extends true

package/src/types/{type-checks → boolean-logic}/TypeDefault.ts

@@ -1,4 +1,4 @@
-import { IsObject } from "src/types/type-checks";
+import { IsObject } from "src/types/boolean-logic";
 import { SimplifyObject } from "../SimplifyObject";
 import { IfExtends } from "./Extends";
 import { IfOptionalLiteral } from "./IsLiteral";

package/src/types/boolean-logic/array.ts

@@ -0,0 +1,57 @@
+import { Equal } from "./equivalency";
+import { AfterFirst, First } from "../lists";
+import { Narrowable } from "../Narrowable";
+
+export type IsArray<T> = [T] extends [any[]] ? true : [T] extends [readonly any[]] ? true : false;
+export type IsReadonlyArray<T> = T extends readonly any[] ? true : false;
+
+/**
+ * **IfArray**`<T, IF, ELSE>`
+ *
+ * Type utility which convert to type `IF` or `ELSE` based on whether `T` is an array
+ */
+export type IfArray<
+  T extends Narrowable,
+  IF extends Narrowable,
+  ELSE extends Narrowable
+> = IsArray<T> extends true ? IF : ELSE;
+
+/**
+ * **IfArray**`<T, IF, ELSE>`
+ *
+ * Type utility which convert to type `IF` or `ELSE` based on whether `T` is a readonly array
+ */
+export type IfReadonlyArray<
+  T extends Narrowable,
+  IF extends Narrowable,
+  ELSE extends Narrowable
+> = IsReadonlyArray<T> extends true ? IF : ELSE;
+
+/**
+ * **Contains**`<T, A>`
+ *
+ * Type utility which checks whether a type `T` exists within an array `A`. Result is
+ * `true` if `T` _extends_ any element in `A` making it match widely against `A`. If you
+ * prefer a narrower match you can use `NarrowlyContains<T,A>` instead.
+ */
+export type Contains<T extends Narrowable, A extends readonly any[]> = First<A> extends T
+  ? true
+  : [] extends AfterFirst<A>
+  ? false
+  : Contains<T, AfterFirst<A>>;
+
+/**
+ * **NarrowlyContains**`<T, A>`
+ *
+ * Type utility which checks whether a type `T` exists within an array `A`. Result is
+ * `true` if `T` _extends_ any element in `A` making it match widely against `A`. If you
+ * prefer a wider match you can use `Contains<T,A>` instead.
+ */
+export type NarrowlyContains<T extends Narrowable, A extends readonly any[]> = Equal<
+  First<A>,
+  T
+> extends true
+  ? true
+  : [] extends AfterFirst<A>
+  ? false
+  : NarrowlyContains<T, AfterFirst<A>>;

package/src/types/boolean-logic/boolean.ts

@@ -0,0 +1,84 @@
+import { Narrowable } from "../Narrowable";
+
+export type IsBoolean<T> = T extends boolean ? true : false;
+
+/**
+ * Type utility which returns `true` or `false` based on
+ * whether the type holds the narrow "true" type.
+ * ```ts
+ * // true
+ * type T = IsTrue<true>;
+ * // boolean
+ * type U = IsTrue<boolean>;
+ * // false
+ * type F = IsTrue<false>;
+ * type F2 = IsTrue<"false">;
+ * ```
+ */
+export type IsTrue<T extends Narrowable> = IsBoolean<T> extends true
+  ? // is a boolean
+    T extends true
+    ? true
+    : T extends false
+    ? false
+    : unknown
+  : // not a boolean
+    false;
+
+export type IsFalse<T extends Narrowable> = IsBoolean<T> extends true
+  ? // is a boolean
+    T extends false
+    ? true
+    : true extends T
+    ? false
+    : // is of boolean type; therefore narrow type is unknown
+      unknown
+  : // not a boolean
+    false;
+
+/**
+ * Type utility which checks for literal `true` value and then switches type
+ * to the IF, ELSE, or MAYBE generic types passed in where _maybe_ is when T
+ * is the wide type of `boolean`
+ */
+export type IfTrue<
+  T extends boolean,
+  IF extends Narrowable,
+  ELSE extends Narrowable,
+  MAYBE extends Narrowable
+> = IsTrue<T> extends true ? IF : IsTrue<T> extends false ? ELSE : MAYBE;
+
+/**
+ * Type utility which checks for literal `false` value and then switches type
+ * to the IF, ELSE, or MAYBE generic types passed in where _maybe_ is when T
+ * is the wide type of `boolean`
+ */
+export type IfFalse<
+  T extends Narrowable,
+  IF extends Narrowable,
+  ELSE extends Narrowable,
+  MAYBE extends Narrowable
+> = IsFalse<T> extends true ? IF : IsTrue<T> extends false ? ELSE : MAYBE;
+
+/**
+ * **IsBooleanLiteral**
+ *
+ * Type utility which returns true/false if the boolean value is a _boolean literal_ versus
+ * just the wider _boolean_ type.
+ */
+export type IsBooleanLiteral<T extends Narrowable> = IsTrue<T> extends true
+  ? true
+  : IsFalse<T> extends true
+  ? true
+  : false;
+
+/**
+ * **IfBooleanLiteral**
+ *
+ * Branch utility which returns `IF` type when `T` is a boolean literal and `ELSE` otherwise
+ */
+export type IfBooleanLiteral<
+  T extends boolean,
+  IF extends Narrowable,
+  ELSE extends Narrowable
+> = IsBooleanLiteral<T> extends true ? IF : ELSE;

package/src/types/boolean-logic/equivalency.ts

@@ -0,0 +1,15 @@
+/**
+ * **Equal**`<X,Y>`
+ *
+ * Type utility which tests whether two types -- `X` and `Y` -- are exactly the same type
+ */
+export type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2
+  ? true
+  : false;
+
+/**
+ * **NotEqual**`<X,Y>`
+ *
+ * Type utility which tests whether two types -- `X` and `Y` -- are _not_ exactly the same type
+ */
+export type NotEqual<X, Y> = true extends Equal<X, Y> ? false : true;