모나드와 옵셔널 체이닝

// Maybe 모나드 (간단한 예시 구현)
class Maybe<T> {
  private value: T | null | undefined;

  private constructor(value: T | null | undefined) {
    this.value = value;
  }

  // 값을 Maybe 컨텍스트에 넣는 팩토리 메서드
  static of<U>(value: U | null | undefined): Maybe<U> {
    return new Maybe(value);
  }

  // 핵심 연산: map (컨텍스트 안의 값을 변환)
  map<U>(fn: (value: T) => U): Maybe<U> {
    if (this.value === null || this.value === undefined) {
      return Maybe.of(null); // 값이 없으면 null 컨텍스트 유지
    }
    return Maybe.of(fn(this.value)); // 값이 있으면 함수 적용 후 새 Maybe 생성
  }

  // flatMap (또는 bind): 컨텍스트 안의 값을 다른 Maybe 컨텍스트로 변환
  flatMap<U>(fn: (value: T) => Maybe<U>): Maybe<U> {
    if (this.value === null || this.value === undefined) {
      return Maybe.of(null);
    }
    return fn(this.value); // 함수 적용 결과가 이미 Maybe이므로 바로 반환
  }

  // 최종 값을 추출 (안전하지 않으므로 주의)
  getOrElse(defaultValue: T): T {
    return this.value === null || this.value === undefined ? defaultValue : this.value;
  }
}

// 사용 예시
interface User {
  id: number;
  name?: string;
  address?: {
    street?: string;
    city?: string;
  };
}

const user1: User = { id: 1, name: "Alice", address: { street: "123 Main St", city: "Anytown" } };
const user2: User = { id: 2, name: "Bob" };
const user3: User = { id: 3, address: { city: "Othertown" } }; // name 없음

// Maybe 모나드를 사용하여 안전하게 속성 접근
const userName1 = Maybe.of(user1)
  .flatMap(u => Maybe.of(u.name)) // name이 Maybe<string>을 반환
  .map(name => name.toUpperCase()) // name이 있으면 대문자로 변환
  .getOrElse("UNKNOWN");
console.log("User 1 name:", userName1); // ALICE

const userName2 = Maybe.of(user2)
  .flatMap(u => Maybe.of(u.name)) // u.name이 undefined이므로 Maybe.of(null) 반환
  .map(name => name.toUpperCase()) // map 호출 안됨
  .getOrElse("UNKNOWN");
console.log("User 2 name:", userName2); // UNKNOWN

const userCity3 = Maybe.of(user3)
  .flatMap(u => Maybe.of(u.address)) // address가 있으면 Maybe<Address>
  .flatMap(a => Maybe.of(a.city)) // city가 있으면 Maybe<string>
  .getOrElse("Unknown City");
console.log("User 3 city:", userCity3); // Othertown

interface UserData {
  id: number;
  name?: string;
  contact?: {
    email?: string;
    phone?: string;
  };
  getProfile?(): string; // 메서드도 옵셔널
  roles?: string[]; // 배열도 옵셔널
}

const user1: UserData = {
  id: 1,
  name: "Charlie",
  contact: {
    email: "charlie@example.com",
    phone: "111-222-3333"
  },
  getProfile: () => "Charlie's Profile"
};

const user2: UserData = {
  id: 2,
  name: "David"
  // contact 속성 없음
};

const user3: UserData = {
  id: 3,
  roles: ['admin', 'editor']
};

// 1. 옵셔널 속성 접근
const email1 = user1.contact?.email;
console.log("User 1 email:", email1); // charlie@example.com

const email2 = user2.contact?.email; // user2.contact가 undefined이므로 전체 표현식은 undefined
console.log("User 2 email:", email2); // undefined

const email3 = user3.contact?.email;
console.log("User 3 email:", email3); // undefined

// 2. 옵셔널 메서드 호출
const profile1 = user1.getProfile?.(); // user1.getProfile이 존재하면 호출
console.log("User 1 profile:", profile1); // Charlie's Profile

const profile2 = user2.getProfile?.(); // user2.getProfile이 undefined이므로 호출되지 않음
console.log("User 2 profile:", profile2); // undefined

// 3. 옵셔널 배열 인덱싱
const firstRole = user3.roles?.[0]; // user3.roles가 존재하고 첫 번째 요소가 있으면 반환
console.log("User 3 first role:", firstRole); // admin

const fourthRole = user3.roles?.[3]; // user3.roles는 존재하지만 네 번째 요소는 없으므로 undefined
console.log("User 3 fourth role:", fourthRole); // undefined

const noRolesUser: UserData = { id: 4 };
const firstRoleNoUser = noRolesUser.roles?.[0]; // noRolesUser.roles가 undefined이므로 전체 표현식은 undefined
console.log("No Roles User first role:", firstRoleNoUser); // undefined

// 4. 병합 연산자 (Nullish Coalescing)와 함께 사용
// ?? 연산자는 null 또는 undefined일 때만 기본값을 제공합니다.
const userNameMaybe = user2.name ?? "Guest";
console.log("User 2 name (with default):", userNameMaybe); // David (name이 존재하므로)

const userContactEmail = user2.contact?.email ?? "no-email@example.com";
console.log("User 2 contact email (with default):", userContactEmail); // no-email@example.com