함수형 유틸리티 라이브러리 사용

// 예시 함수들 (모두 순수 함수여야 합니다!)
const toUpperCase = (str: string): string => str.toUpperCase();
const addExclamation = (str: string): string => str + '!';
const splitBySpace = (str: string): string[] => str.split(' ');
const joinWithDash = (arr: string[]): string => arr.join('-');
const truncate = (length: number) => (str: string): string =>
  str.length > length ? str.substring(0, length) + '...' : str;

// compose 함수 구현
// T1 -> T2 -> T3 -> ... -> TN
// compose(f, g, h) => f(g(h(x)))
function compose<TArgs extends any[], TResult1, TResult2, TResult3>(
  f: (a: TResult2) => TResult1,
  g: (a: TResult3) => TResult2,
  h: (...args: TArgs) => TResult3
): (...args: TArgs) => TResult1;
function compose<TArgs extends any[], TResult1, TResult2>(
  f: (a: TResult2) => TResult1,
  g: (...args: TArgs) => TResult2
): (...args: TArgs) => TResult1;
function compose(...fns: Function[]): Function {
  return (...args: any[]) =>
    fns.reduceRight((res, fn) => (Array.isArray(res) ? fn(...res) : fn(res)), args);
}

// pipe 함수 구현
// T1 -> T2 -> T3 -> ... -> TN
// pipe(f, g, h) => h(g(f(x)))
function pipe<TArgs extends any[], TResult1, TResult2, TResult3>(
  f: (...args: TArgs) => TResult1,
  g: (a: TResult1) => TResult2,
  h: (a: TResult2) => TResult3
): (...args: TArgs) => TResult3;
function pipe(...fns: Function[]): Function {
  return (...args: any[]) =>
    fns.reduce((res, fn) => (Array.isArray(res) ? fn(...res) : fn(res)), args);
}

// 사용 예시: compose
const transformAndFormatCompose = compose(
  joinWithDash,      // 4. 배열을 대시로 연결
  splitBySpace,      // 3. 공백으로 분리
  addExclamation,    // 2. 느낌표 추가
  toUpperCase        // 1. 대문자로 변환
);

const resultCompose = transformAndFormatCompose("hello functional programming");
console.log("Compose Result:", resultCompose); // 앞 호출의 오버로드·배열 전달 오류로 이 결과에 도달하지 못함

// 사용 예시: pipe
const transformAndFormatPipe = pipe(
  toUpperCase,       // 1. 대문자로 변환
  addExclamation,    // 2. 느낌표 추가
  splitBySpace,      // 3. 공백으로 분리
  joinWithDash       // 4. 배열을 대시로 연결
);

const resultPipe = transformAndFormatPipe("hello functional programming");
console.log("Pipe Result:", resultPipe); // 의도한 합성이지만 현재 오버로드·배열 전달 구현 보완 필요

// 커링된 함수와 조합
const truncatedUpperCase = pipe(
    toUpperCase,
    truncate(10) // truncate는 커링된 함수
);
console.log("Truncated UpperCase:", truncatedUpperCase("super long string example")); // 2함수 오버로드 추가 후 의도한 결과: SUPER LONG...

function pipe2<A, B, C>(
  f: (value: A) => B,
  g: (value: B) => C
): (value: A) => C {
  return value => g(f(value));
}

function pipe4<A, B, C, D, E>(
  f: (value: A) => B,
  g: (value: B) => C,
  h: (value: C) => D,
  k: (value: D) => E
): (value: A) => E {
  return value => k(h(g(f(value))));
}

function compose4<A, B, C, D, E>(
  k: (value: D) => E,
  h: (value: C) => D,
  g: (value: B) => C,
  f: (value: A) => B
): (value: A) => E {
  return pipe4(f, g, h, k);
}

const safePipe = pipe4(toUpperCase, addExclamation, splitBySpace, joinWithDash);
const safeCompose = compose4(joinWithDash, splitBySpace, addExclamation, toUpperCase);
console.log(safePipe("hello functional programming"));
console.log(safeCompose("hello functional programming"));
console.log(pipe2(toUpperCase, truncate(10))("super long string example"));

interface Product {
  id: number;
  name: string;
  price: number;
  category: string;
}

const products: Product[] = [
  { id: 1, name: 'Laptop', price: 1200, category: 'Electronics' },
  { id: 2, name: 'Keyboard', price: 75, category: 'Electronics' },
  { id: 3, name: 'Book', price: 20, category: 'Books' },
  { id: 4, name: 'Mouse', price: 30, category: 'Electronics' },
  { id: 5, name: 'Pen', price: 5, category: 'Stationery' },
];

// 맵핑 (map): 각 요소를 변환하여 새 배열 생성
const productNames = products.map(product => product.name);
console.log("Product Names:", productNames); // ['Laptop', 'Keyboard', 'Book', 'Mouse', 'Pen']

// 필터링 (filter): 특정 조건에 맞는 요소만 포함하는 새 배열 생성
const electronicsProducts = products.filter(product => product.category === 'Electronics');
console.log("Electronics Products:", electronicsProducts);
/*
[
  { id: 1, name: 'Laptop', price: 1200, category: 'Electronics' },
  { id: 2, name: 'Keyboard', price: 75, category: 'Electronics' },
  { id: 4, name: 'Mouse', price: 30, category: 'Electronics' }
]
*/

// 조합된 예시: 전자제품 중 가격이 50을 초과하는 제품의 이름만 추출
const expensiveElectronicsNames = products
  .filter(product => product.category === 'Electronics') // 먼저 필터링
  .filter(product => product.price > 50)                 // 다시 필터링
  .map(product => product.name);                          // 이름만 맵핑
console.log("Expensive Electronics Names:", expensiveElectronicsNames); // ['Laptop', 'Keyboard']

const numbers = [1, 2, 3, 4, 5];

// 모든 숫자의 합 계산
const sum = numbers.reduce((acc, current) => acc + current, 0); // 초기값 0
console.log("Sum:", sum); // 15

// 배열의 모든 요소를 곱하기
const product = numbers.reduce((acc, current) => acc * current, 1); // 초기값 1
console.log("Product:", product); // 120

// 객체 배열을 Map으로 변환
interface User {
  id: number;
  name: string;
}

const users: User[] = [
  { id: 1, name: "Alice" },
  { id: 2, name: "Bob" },
  { id: 3, name: "Charlie" },
];

const usersMap = users.reduce((map, user) => {
  map.set(user.id, user); // 이번 reduce에서 만든 Map 누산기를 직접 갱신
  return map;
}, new Map<number, User>()); // 초기값으로 빈 Map 생성

console.log("Users Map:", usersMap.get(2)); // { id: 2, name: 'Bob' }

// 불변성을 더 강력하게 지키려면
const usersMapImmutable = users.reduce((map, user) => {
  return new Map(map).set(user.id, user); // 매번 새로운 Map 생성 (성능 오버헤드 주의)
}, new Map<number, User>());

// 커링된 divide 함수
const divide = (a: number) => (b: number) => a / b;

// 부분 적용: 10을 나누는 함수 생성
const divideBy10 = divide(10);
console.log("10 / 2:", divideBy10(2)); // 5
console.log("10 / 5:", divideBy10(5)); // 2

// 또 다른 부분 적용: 분자를 2로 고정한 함수
const half = divide(2); // Ramda 같은 라이브러리에서는 (__, 2) 같은 플레이스홀더 사용
console.log("6 / 2:", half(6)); // 실제 식은 2 / 6; 값은 약 0.3333333333333333 (출력 라벨은 원문)

// 간단한 메모이제이션 함수 유틸리티
function memoize<T extends Function>(fn: T): T {
  const cache: { [key: string]: any } = {};

  return ((...args: any[]) => {
    const key = JSON.stringify(args); // 인자를 문자열 키로 사용 (복잡한 객체는 주의)
    if (cache[key]) {
      console.log(`Getting from cache for key: ${key}`);
      return cache[key];
    } else {
      console.log(`Calculating for key: ${key}`);
      const result = fn(...args);
      cache[key] = result;
      return result;
    }
  }) as any as T; // 타입 캐스팅
}

// 예시: 피보나치 수열 (재귀 호출이 많아 최적화에 유리)
const fibonacci = memoize(function(n: number): number {
  if (n <= 1) return n;
  return fibonacci(n - 1) + fibonacci(n - 2);
});

console.log(fibonacci(10)); // 계산 -> 캐시
console.log(fibonacci(10)); // 캐시에서 가져옴
console.log(fibonacci(15)); // 계산 -> 캐시
console.log(fibonacci(10)); // 캐시에서 가져옴
console.log(fibonacci(15)); // 캐시에서 가져옴

function memoizeNumber(fn: (value: number) => number): (value: number) => number {
  const cache = new Map<number, number>();
  return value => {
    if (!Number.isSafeInteger(value) || value < 0 || Object.is(value, -0)) {
      throw new Error("음수가 아닌 안전한 정수만 받습니다.");
    }
    if (cache.has(value)) return cache.get(value)!;
    const result = fn(value);
    cache.set(value, result);
    return result;
  };
}

let calculations = 0;
const identityWithCount = memoizeNumber(value => {
  calculations++; // 캐시 호출 횟수를 보기 위한 이 실습의 관찰 효과
  return value;
});
console.log(identityWithCount(0), identityWithCount(0), calculations); // 0 0 1