/**
 * @example Basic Conditional Type: Check if a type extends another.
 * Determines if T is assignable to string. If true, results in 'yes'; otherwise 'no'.
 */
type IsString<T> = T extends string ? 'yes' : 'no';

// Activating IsString with different types
type Check1 = IsString<string>; // Expect: 'yes'
type Check2 = IsString<number>; // Expect: 'no'
type Check3 = IsString<any>;    // Expect: 'yes' (due to 'any' assignability)

/**
 * @example Practical Application: The built-in Exclude utility type.
 * Constructs a type by excluding from UnionType those types that are assignable to ExcludedMembers.
 */
type MyExclude<UnionType, ExcludedMembers> = UnionType extends ExcludedMembers ? never : UnionType;

// Demonstrating MyExclude
type AllColors = 'red' | 'green' | 'blue' | 'yellow';
type PrimaryColors = MyExclude<AllColors, 'green' | 'yellow'>; // Expect: 'red' | 'blue'

/**
 * @example Practical Application: The built-in Extract utility type.
 * Constructs a type by extracting from UnionType those types that are assignable to ContainedIn.
 */
type MyExtract<UnionType, ContainedIn> = UnionType extends ContainedIn ? UnionType : never;

// Demonstrating MyExtract
type Fruits = 'apple' | 'banana' | 'orange';
type Citrus = MyExtract<Fruits, 'orange' | 'lemon'>; // Expect: 'orange'

/**
 * @example Basic use of 'infer': Extract the element type of an array.
 * If T is an array, 'infer ElementType' captures the type of its elements.
 */
type ArrayElementType<T> = T extends (infer ElementType)[] ? ElementType : T;

// Applying ArrayElementType
type StringArrayElement = ArrayElementType<string[]>; // Expect: string
type NumberArrayElement = ArrayElementType<number[]>; // Expect: number
type NotAnArray = ArrayElementType<boolean>;     // Expect: boolean (falls to false branch)

/**
 * @example Built-in ReturnType: Extract the return type of a function.
 * Uses 'infer R' to capture the function's return type.
 */
type MyReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : never;

// Applying MyReturnType
type Func1Return = MyReturnType<() => string>;       // Expect: string
type Func2Return = MyReturnType<(a: number) => number[]>; // Expect: number[]

/**
 * @example Built-in Parameters: Extract the parameter types of a function.
 * Uses 'infer P' to capture the function's parameter types as a tuple.
 */
type MyParameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never;

// Applying MyParameters
type Func1Params = MyParameters<(a: string, b: number) => void>; // Expect: [a: string, b: number]
type Func2Params = MyParameters<() => boolean>;                // Expect: []

/**
 * @example UnwrapPromise: Recursively extracts the resolved type of a Promise.
 * Handles nested Promises, demonstrating recursive conditional types with infer.
 */
type UnwrapPromise<T> = T extends Promise<infer U> ? UnwrapPromise<U> : T;

// Applying UnwrapPromise
type PromiseString = UnwrapPromise<Promise<string>>;       // Expect: string
type NestedPromise = UnwrapPromise<Promise<Promise<number>>>; // Expect: number
type NotAPromise = UnwrapPromise<boolean>;            // Expect: boolean

/**
 * @example GetProperty: Safely extracts the type of a property given an object and a key.
 * Uses keyof and infer to ensure type safety and correctness.
 */
type GetProperty<T, K extends keyof T> = T extends { [P in K]: infer V } ? V : never;

// Interface for demonstration
interface UserProfile {
  name: string;
  age: number;
  email?: string;
}

// Applying GetProperty
type UserName = GetProperty<UserProfile, 'name'>;    // Expect: string
type UserAge = GetProperty<UserProfile, 'age'>;      // Expect: number
type UserEmail = GetProperty<UserProfile, 'email'>;  // Expect: string | undefined

/**
 * @example FunctionOverloadParameters: Extracts parameter types for all overloads of a function.
 * Note: This specific implementation (inferring from T[]) correctly handles union of function types.
 * A single function type (not union) implies a single overload.
 */
type FunctionOverloadParameters<T> = T extends { (...args: infer A): any; (...args: infer B): any } ? A | B :
                                 T extends (...args: infer P) => any ? P : never;

// Example: Function with overloads
declare function sum(a: number, b: number): number;
declare function sum(a: string, b: string): string;

type SumParams = FunctionOverloadParameters<typeof sum>; // Expect: [a: number, b: number] | [a: string, b: string]

/**
 * @example Flexible Event Handler: Type-safe event dispatching based on event name.
 * Demonstrates mapping types based on a string literal, ensuring callback types are correct.
 */

// Define a map of event names to their corresponding payload types
interface EventMap {
  'userLoggedIn': { userId: string; timestamp: number; };
  'productAddedToCart': { productId: string; quantity: number; };
  'orderPlaced': { orderId: string; totalAmount: number; };
}

// Type for a generic event handler function
type EventHandler<K extends keyof EventMap> = (payload: EventMap[K]) => void;

// A dispatcher type that leverages conditional types to select the correct handler signature
class EventDispatcher {
  private handlers: { [K in keyof EventMap]?: EventHandler<K>[] } = {};

  // Method to subscribe to an event with type-safe payload
  on<K extends keyof EventMap>(eventName: K, handler: EventHandler<K>): void {
    if (!this.handlers[eventName]) {
      this.handlers[eventName] = [];
    }
    this.handlers[eventName]!.push(handler as any); // Type assertion for internal array push
  }

  // Method to dispatch an event with type-safe payload
  dispatch<K extends keyof EventMap>(eventName: K, payload: EventMap[K]): void {
    const eventHandlers = this.handlers[eventName];
    if (eventHandlers) {
      eventHandlers.forEach(handler => handler(payload));
    }
  }
}

// --- Usage Example ---
const dispatcher = new EventDispatcher();

// Subscribe to 'userLoggedIn' event; payload type is automatically inferred and checked
dispatcher.on('userLoggedIn', (event) => {
  console.log(`User ${event.userId} logged in at ${new Date(event.timestamp).toLocaleString()}`);
  // event.productId would cause a type error here, as expected
});

// Subscribe to 'productAddedToCart' event
dispatcher.on('productAddedToCart', (event) => {
  console.log(`Product ${event.productId} added to cart. Quantity: ${event.quantity}`);
});

// Dispatch events
dispatcher.dispatch('userLoggedIn', { userId: 'abc-123', timestamp: Date.now() });
dispatcher.dispatch('productAddedToCart', { productId: 'p-456', quantity: 3 });
// dispatcher.dispatch('orderPlaced', { unknownProp: 'error' }); // Type error: 'unknownProp' not in 'orderPlaced' payload

console.log("Event system demonstration complete.");