함수형 프로그래밍 — 순수 함수, 커링, 합성, 모나드 맛보기

// 순수 함수
function add(a, b) {
  return a + b;
}

function getFullName(firstName, lastName) {
  return `${firstName} ${lastName}`;
}

// 비순수 함수 — 외부 상태에 의존
let count = 0;
function increment() {
  count++; // 외부 변수 변경 (사이드 이펙트)
  return count;
}

// 비순수 함수 — 매번 다른 결과
function getRandom() {
  return Math.random(); // 같은 입력인데 다른 출력
}

// 비순수 → 순수로 변환
function addToArray(arr, item) {
  return [...arr, item]; // 원본 변경 없이 새 배열 반환
}

// 일반 함수
function multiply(a, b) {
  return a * b;
}

// 커링된 함수
function curriedMultiply(a) {
  return function (b) {
    return a * b;
  };
}

// 화살표 함수로 더 간결하게
const curriedMultiply2 = (a) => (b) => a * b;

const double = curriedMultiply2(2);
const triple = curriedMultiply2(3);

console.log(double(5));  // 10
console.log(triple(5));  // 15

function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn(...args);
    }
    return (...moreArgs) => curried(...args, ...moreArgs);
  };
}

const add = curry((a, b, c) => a + b + c);
add(1)(2)(3);    // 6
add(1, 2)(3);    // 6
add(1)(2, 3);    // 6
add(1, 2, 3);    // 6

// 로그 함수 커링
const log = curry((level, prefix, message) => {
  console.log(`[${level}] ${prefix}: ${message}`);
});

const errorLog = log("ERROR");
const apiError = errorLog("API");
apiError("요청 실패"); // "[ERROR] API: 요청 실패"

// 이벤트 핸들러
const handleEvent = curry((type, handler, event) => {
  if (event.type === type) handler(event);
});

const handleClick = handleEvent("click");

// compose — 오른쪽에서 왼쪽으로 실행
const compose = (...fns) => (x) =>
  fns.reduceRight((acc, fn) => fn(acc), x);

// pipe — 왼쪽에서 오른쪽으로 실행 (더 직관적)
const pipe = (...fns) => (x) =>
  fns.reduce((acc, fn) => fn(acc), x);

// 사용
const trim = (str) => str.trim();
const toLowerCase = (str) => str.toLowerCase();
const split = (sep) => (str) => str.split(sep);

const processInput = pipe(trim, toLowerCase, split(" "));
processInput("  Hello World  "); // ["hello", "world"]

// 데이터 변환 파이프라인
const processUsers = pipe(
  (users) => users.filter((u) => u.active),
  (users) => users.map((u) => u.name),
  (names) => names.sort()
);

// 함수를 반환
function withLogging(fn) {
  return function (...args) {
    console.log(`호출: ${fn.name}(${args.join(", ")})`);
    const result = fn(...args);
    console.log(`결과: ${result}`);
    return result;
  };
}

const loggedAdd = withLogging((a, b) => a + b);
loggedAdd(2, 3);
// 호출: (2, 3)
// 결과: 5

// 메모이제이션
function memoize(fn) {
  const cache = new Map();
  return function (...args) {
    const key = JSON.stringify(args);
    if (cache.has(key)) return cache.get(key);
    const result = fn(...args);
    cache.set(key, result);
    return result;
  };
}

const fibonacci = memoize((n) => {
  if (n <= 1) return n;
  return fibonacci(n - 1) + fibonacci(n - 2);
});

class Maybe {
  constructor(value) {
    this.value = value;
  }

  static of(value) {
    return new Maybe(value);
  }

  map(fn) {
    return this.value == null ? this : Maybe.of(fn(this.value));
  }

  flatMap(fn) {
    return this.value == null ? this : fn(this.value);
  }

  getOrElse(defaultValue) {
    return this.value ?? defaultValue;
  }
}

// null 안전한 체이닝
const userName = Maybe.of(user)
  .map((u) => u.profile)
  .map((p) => p.name)
  .map((n) => n.toUpperCase())
  .getOrElse("익명");
// user가 null이어도 에러 없이 "익명" 반환

// 명령형 — HOW를 기술
function getAdultNames(users) {
  const result = [];
  for (let i = 0; i < users.length; i++) {
    if (users[i].age >= 18) {
      result.push(users[i].name.toUpperCase());
    }
  }
  return result;
}

// 함수형 — WHAT을 기술
const getAdultNames = (users) =>
  users
    .filter((u) => u.age >= 18)
    .map((u) => u.name.toUpperCase());