docs: add comments for some types

Author: kakasoo

src/types/Equal.ts

@@ -1,13 +1,39 @@
 /**
- * Implementation method
+ * Helper type that creates a generic function signature for type comparison.
+ * This technique leverages TypeScript's strict function type checking to determine type equality.
+ * 
+ * @internal
  */
 type Expression<X> = <T>() => T extends X ? 1 : 2;
 
 /**
  * @title Type for Checking if Two Types are Equal.
  *
  * The `Equal<X, Y>` type uses conditional types and a helper type `Expression<X>`
- * to determine if two types `X` and `Y` are the same. It returns `true` if they are
+ * to determine if two types `X` and `Y` are exactly the same. It returns `true` if they are
  * equal, and `false` otherwise.
+ * 
+ * This type performs a strict equality check that distinguishes between:
+ * - `any` vs other types
+ * - `unknown` vs other types  
+ * - Union types with different members
+ * - Branded types vs their base types
+ * 
+ * @template X - The first type to compare
+ * @template Y - The second type to compare
+ * @returns `true` if X and Y are exactly the same type, `false` otherwise
+ * 
+ * @example
+ * ```typescript
+ * type Test1 = Equal<string, string>; // true
+ * type Test2 = Equal<string, number>; // false
+ * type Test3 = Equal<string | number, string | number>; // true
+ * type Test4 = Equal<string | number, number | string>; // true (order doesn't matter)
+ * type Test5 = Equal<{ a: string }, { a: string }>; // true
+ * type Test6 = Equal<{ a: string }, { a: string; b?: string }>; // false
+ * type Test7 = Equal<any, string>; // false
+ * type Test8 = Equal<unknown, any>; // false
+ * type Test9 = Equal<string & { __brand: 'ID' }, string>; // false (branded types)
+ * ```
  */
 export type Equal<X, Y> = Expression<X> extends Expression<Y> ? true : false;

src/types/GetType.ts

@@ -4,28 +4,50 @@ import type { ElementOf } from './ElementOf';
 import type { RemoveArraySymbol } from './RemoveArraySymbol';
 
 /**
- * @title Type to infer all value types of generic T
+ * Helper type that extracts all value types from an object type.
+ * Similar to `T[keyof T]`, it returns a union of all property value types.
+ *
+ * @internal
+ * @template T - The object type to extract values from
  */
 type ValueOf<T> = T[keyof T];
 
 /**
- * @title The type that pulls out the type of a particular key on an interface.
+ * @title Type for extracting the type at a specific nested path in an object.
  *
- * This type extracts the type of a specific key from a nested object,
+ * This type extracts the type of a specific key from a nested object structure,
  * supporting arrays and deeply nested keys. It uses `DeepStrictObjectKeys`
- * to handle the extraction of keys and correctly resolves the type for the given key.
+ * to validate the key path and correctly resolves the type for the given key.
+ *
+ * Key features:
+ * - Supports dot notation for nested object access (e.g., "a.b.c")
+ * - Handles array access with `[*]` notation (e.g., "items[*].name")
+ * - Type-safe: only accepts valid key paths as defined by `DeepStrictObjectKeys`
+ * - Recursively resolves nested types through objects and arrays
  *
- * - If the key points to a primitive value, the type is returned directly.
- * - If the key points to an array, the type of the array elements is resolved.
- * - It supports nested keys using `.` notation to handle deep objects and arrays.
+ * @template T - The object type to extract from
+ * @template K - The key path string (must be a valid key from DeepStrictObjectKeys<T>)
+ * @returns The type at the specified path, or `never` if the path is invalid
  *
- * @template T The interface type.
- * @template K The key string, which can represent a nested key path.
+ * @example
+ * ```typescript
+ * type Data = {
+ *   user: {
+ *     name: string;
+ *     posts: {
+ *       title: string;
+ *       tags: string[];
+ *     }[];
+ *   };
+ * };
  *
- * Example usage:
- * ```ts
- * type Example1 = GetType<{ a: { b: { c: number } } }, "a.b">; // { c: number }
- * type Example2 = GetType<{ a: { b: { c: number } } }, "a.b.c">; // number
+ * type UserType = GetType<Data, "user">; // { name: string; posts: {...}[] }
+ * type NameType = GetType<Data, "user.name">; // string
+ * type PostsType = GetType<Data, "user.posts">; // { title: string; tags: string[] }[]
+ * type PostType = GetType<Data, "user.posts[*]">; // { title: string; tags: string[] }
+ * type TitleType = GetType<Data, "user.posts[*].title">; // string
+ * type TagsType = GetType<Data, "user.posts[*].tags">; // string[]
+ * type TagType = GetType<Data, "user.posts[*].tags[*]">; // string
  * ```
  */
 export type GetType<T extends object, K extends DeepStrictObjectKeys<T>> =

src/types/IsUnion.ts

@@ -1,25 +1,45 @@
 import type { Equal } from './Equal';
 
 /**
- * 제네릭 타입 `T`가 자기 자신의 요소와 동일한지를 검증한다.
+ * Helper type that checks if a partition of type T is the same as the entire type T.
+ * This works by distributing T through conditional types and checking if each partition
+ * equals the whole. For union types, this produces `false | true`, while for single types
+ * it produces just `false`.
+ *
+ * @internal
+ * @template T - The type to check
+ * @template P - The preserved original type (defaults to T)
  */
-type IsPartitionSameEntire<T, P = T> = T extends any // T를 각각의 요소 타입으로 분리하기 위한 조건부 타입
-  ? P extends T // 유니온 타입이면 이 조건부 타입에서 false | true가 나와야 한다.
+type IsPartitionSameEntire<T, P = T> = T extends any // Distribute T to each element for union types
+  ? P extends T // If T is a union, this conditional produces false | true
     ? false
     : true
   : never;
 
 /**
  * @title Type for checking if a type is a union type.
  *
- * This type uses the `IsPartitionSameEntire` type to check whether the provided type `T` is a union type.
- * - It works by partitioning the type `T` and checking if the type consists of multiple distinct elements.
- * - If the type `T` is a union type, the result will be `true`, otherwise `false`.
+ * This type uses the `IsPartitionSameEntire` helper type to check whether the provided type `T` is a union type.
+ * It works by partitioning the type `T` and checking if the type consists of multiple distinct elements.
+ *
+ * The detection mechanism:
+ * - For union types: produces `boolean` (which is `false | true`)
+ * - For single types: produces `false`
+ * - Then checks if the result equals `boolean` to determine if it's a union
+ *
+ * @template T - The type to check
+ * @returns `true` if T is a union type, `false` otherwise
  *
- * Example usage:
- * ```ts
+ * @example
+ * ```typescript
  * type Test1 = IsUnion<string | number>; // true
  * type Test2 = IsUnion<string>; // false
+ * type Test3 = IsUnion<'a' | 'b' | 'c'>; // true
+ * type Test4 = IsUnion<{ a: string } | { b: number }>; // true
+ * type Test5 = IsUnion<never>; // false
+ * type Test6 = IsUnion<unknown>; // false
+ * type Test7 = IsUnion<any>; // false
+ * type Test8 = IsUnion<boolean>; // true (boolean is true | false)
  * ```
  */
 export type IsUnion<T> = Equal<IsPartitionSameEntire<T>, boolean> extends true ? true : false;