Split View: 함수형 프로그래밍 실전 가이드: 백엔드 개발자를 위한 불변성, 순수함수, 모나드의 모든 것

┌─────────────────────────────────────────────────┐
│          FP가 주류가 된 이유 (2025)              │
├─────────────────────────────────────────────────┤
│  React Hooks    → 함수형 컴포넌트 표준화        │
│  Rust           → 소유권 + 불변성 강제           │
│  TypeScript     → fp-ts, Effect 생태계 성장     │
│  Java 21+       → Record, Pattern Matching      │
│  Python 3.12+   → match 문, functools 강화      │
│  Kotlin         → 코루틴 + 함수형 기본 지원      │
└─────────────────────────────────────────────────┘

// 가변(Mutable) - 위험
const user = { name: "Alice", age: 30 };
user.age = 31; // 원본 변경 → 다른 참조에서 예기치 않은 동작

// 불변(Immutable) - 안전
const user = { name: "Alice", age: 30 };
const updatedUser = { ...user, age: 31 }; // 새 객체 생성
// user는 여전히 { name: "Alice", age: 30 }

┌──────────────────────────────────────┐
│        Mutable State의 문제          │
├──────────────────────────────────────┤
│  Thread A: user.balance = 100        │
│  Thread B: user.balance = 200        │
│  결과: ??? (Race Condition)          │
├──────────────────────────────────────┤
│      Immutable State의 해결          │
├──────────────────────────────────────┤
│  Thread A: newUser = {...user, 100}  │
│  Thread B: newUser = {...user, 200}  │
│  결과: 각각 독립적 (안전)             │
└──────────────────────────────────────┘

// readonly 키워드
interface User {
  readonly name: string;
  readonly age: number;
}

// as const
const CONFIG = {
  port: 3000,
  host: "localhost",
} as const;

// Readonly 유틸리티 타입
type ImmutableUser = Readonly<User>;

// 깊은 불변성 (DeepReadonly)
type DeepReadonly<T> = {
  readonly [P in keyof T]: T[P] extends object ? DeepReadonly<T[P]> : T[P];
};

from dataclasses import dataclass
from typing import NamedTuple

# frozen dataclass
@dataclass(frozen=True)
class User:
    name: str
    age: int

user = User(name="Alice", age=30)
# user.age = 31  # FrozenInstanceError!

# 업데이트: replace 사용
from dataclasses import replace
updated = replace(user, age=31)

# NamedTuple도 불변
class Point(NamedTuple):
    x: float
    y: float

// case class는 기본 불변
case class User(name: String, age: Int)

val user = User("Alice", 30)
val updated = user.copy(age = 31)

// 불변 컬렉션이 기본
val list = List(1, 2, 3)
val newList = 0 :: list  // List(0, 1, 2, 3) — 원본 유지

원본 트리:          수정 후 트리:
    A                   A'
   / \                 / \
  B   C               B   C'
 / \   \             / \   \
D   E   F           D   E   F'

→ B, D, E는 공유됨 (복사 불필요)
→ A→A', C→C', F→F'만 새로 생성

import { produce } from "immer";

const state = {
  users: [
    { name: "Alice", score: 100 },
    { name: "Bob", score: 200 },
  ],
};

const newState = produce(state, (draft) => {
  draft.users[0].score = 150;
});

// state.users[1] === newState.users[1]  → true (구조적 공유)

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

// 비순수 함수 - 외부 상태 의존
let counter = 0;
function increment(): number {
  return ++counter; // 부작용: 외부 변수 변경
}

// 비순수 함수 - 비결정론적
function now(): number {
  return Date.now(); // 매번 다른 결과
}

// 참조 투명
const x = add(2, 3); // 5
// add(2, 3)을 어디서든 5로 대체 가능

// 참조 불투명
const y = Math.random();
// Math.random()을 y의 값으로 대체하면 동작이 달라짐

// 나쁜 예: 비즈니스 로직에 부작용 혼재
async function processOrder(orderId: string) {
  const order = await db.findOrder(orderId);      // 부작용
  const discount = calculateDiscount(order);        // 순수
  const total = applyDiscount(order.amount, discount); // 순수
  await db.updateOrder(orderId, total);             // 부작용
  await emailService.send(order.email, total);      // 부작용
}

// 좋은 예: 순수 로직 분리
// 순수 함수들
function calculateDiscount(order: Order): number {
  if (order.items.length > 10) return 0.1;
  if (order.totalAmount > 100000) return 0.05;
  return 0;
}

function applyDiscount(amount: number, rate: number): number {
  return amount * (1 - rate);
}

function computeOrderResult(order: Order): OrderResult {
  const discount = calculateDiscount(order);
  const total = applyDiscount(order.amount, discount);
  return { orderId: order.id, total, discount };
}

// 불순한 쉘 (얇게 유지)
async function processOrder(orderId: string) {
  const order = await db.findOrder(orderId);
  const result = computeOrderResult(order);  // 순수 로직 호출
  await db.updateOrder(result.orderId, result.total);
  await emailService.send(order.email, result.total);
}

┌──────────────────────────────────────────────┐
│          Functional Core / Imperative Shell   │
├──────────────────────────────────────────────┤
│                                              │
│  ┌────────────────────────────────┐          │
│  │     Imperative Shell           │          │
│  │  (DB, Network, File I/O)       │          │
│  │  ┌────────────────────────┐    │          │
│  │  │   Functional Core      │    │          │
│  │  │  (Pure Business Logic) │    │          │
│  │  │  - 계산                 │    │          │
│  │  │  - 변환                 │    │          │
│  │  │  - 검증                 │    │          │
│  │  └────────────────────────┘    │          │
│  └────────────────────────────────┘          │
│                                              │
└──────────────────────────────────────────────┘

// 함수를 인자로 받음
function map<T, U>(arr: T[], fn: (item: T) => U): U[] {
  const result: U[] = [];
  for (const item of arr) {
    result.push(fn(item));
  }
  return result;
}

// 함수를 반환
function multiplier(factor: number): (n: number) => number {
  return (n: number) => n * factor;
}

const double = multiplier(2);
const triple = multiplier(3);
console.log(double(5));  // 10
console.log(triple(5));  // 15

const orders = [
  { id: 1, amount: 50000, status: "completed" },
  { id: 2, amount: 30000, status: "pending" },
  { id: 3, amount: 80000, status: "completed" },
  { id: 4, amount: 20000, status: "cancelled" },
];

// 명령형 접근
let total = 0;
for (const order of orders) {
  if (order.status === "completed") {
    total += order.amount;
  }
}

// 함수형 접근
const totalFP = orders
  .filter((o) => o.status === "completed")
  .map((o) => o.amount)
  .reduce((sum, amt) => sum + amt, 0);
// 130000

from functools import reduce

orders = [
    {"id": 1, "amount": 50000, "status": "completed"},
    {"id": 2, "amount": 30000, "status": "pending"},
    {"id": 3, "amount": 80000, "status": "completed"},
    {"id": 4, "amount": 20000, "status": "cancelled"},
]

total = reduce(
    lambda acc, o: acc + o["amount"],
    filter(lambda o: o["status"] == "completed", orders),
    0
)
# 130000

// 수동 합성
const compose = <A, B, C>(
  f: (b: B) => C,
  g: (a: A) => B
): ((a: A) => C) => (a: A) => f(g(a));

const pipe = <A, B, C>(
  f: (a: A) => B,
  g: (b: B) => C
): ((a: A) => C) => (a: A) => g(f(a));

// 사용 예
const trim = (s: string) => s.trim();
const toLowerCase = (s: string) => s.toLowerCase();
const split = (sep: string) => (s: string) => s.split(sep);

const tokenize = pipe(
  trim,
  pipe(toLowerCase, split(" "))
);

tokenize("  Hello World  "); // ["hello", "world"]

// 명시적 스타일
const getNames = (users: User[]) => users.map((u) => u.name);

// Point-Free 스타일
const getName = (u: User) => u.name;
const getNames = (users: User[]) => users.map(getName);

// 더 극단적인 Point-Free (fp-ts 스타일)
import { pipe } from "fp-ts/function";
import * as A from "fp-ts/Array";

const getNames = pipe(
  A.map(getName)
);

function createCounter(initial: number = 0) {
  let count = initial;
  return {
    increment: () => ++count,
    decrement: () => --count,
    getCount: () => count,
  };
}

const counter = createCounter(10);
counter.increment(); // 11
counter.increment(); // 12
counter.getCount();  // 12

function createLogger(prefix: string, level: string) {
  return (message: string) => {
    console.log(`[${prefix}] [${level}] ${message}`);
  };
}

const infoLogger = createLogger("MyApp", "INFO");
const errorLogger = createLogger("MyApp", "ERROR");

infoLogger("Server started");   // [MyApp] [INFO] Server started
errorLogger("DB connection failed"); // [MyApp] [ERROR] DB connection failed

// 일반 함수
function add(a: number, b: number): number {
  return a + b;
}

// 커링된 함수
function curriedAdd(a: number): (b: number) => number {
  return (b: number) => a + b;
}

const add5 = curriedAdd(5);
add5(3);  // 8
add5(10); // 15

// 제네릭 커링 유틸리티
function curry<A, B, C>(fn: (a: A, b: B) => C): (a: A) => (b: B) => C {
  return (a: A) => (b: B) => fn(a, b);
}

// 실전 예: API 클라이언트 팩토리
function createApiClient(baseUrl: string, headers: Record<string, string>) {
  return async function request(method: string, path: string, body?: unknown) {
    const response = await fetch(`${baseUrl}${path}`, {
      method,
      headers,
      body: body ? JSON.stringify(body) : undefined,
    });
    return response.json();
  };
}

const api = createApiClient("https://api.example.com", {
  Authorization: "Bearer token123",
  "Content-Type": "application/json",
});

// 이후 간단하게 사용
await api("GET", "/users");
await api("POST", "/orders", { item: "book", qty: 1 });

type Middleware<T> = (data: T) => T;

function compose<T>(...middlewares: Middleware<T>[]): Middleware<T> {
  return (data: T) => middlewares.reduce((acc, mw) => mw(acc), data);
}

// 요청 처리 미들웨어
const addTimestamp = (req: Request) => ({
  ...req,
  timestamp: Date.now(),
});

const addRequestId = (req: Request) => ({
  ...req,
  requestId: crypto.randomUUID(),
});

const validateAuth = (req: Request) => {
  if (!req.headers.authorization) throw new Error("Unauthorized");
  return req;
};

const pipeline = compose(addTimestamp, addRequestId, validateAuth);

// TypeScript: Discriminated Union
type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "rectangle"; width: number; height: number }
  | { kind: "triangle"; base: number; height: number };

function area(shape: Shape): number {
  switch (shape.kind) {
    case "circle":
      return Math.PI * shape.radius ** 2;
    case "rectangle":
      return shape.width * shape.height;
    case "triangle":
      return (shape.base * shape.height) / 2;
  }
}

from dataclasses import dataclass
from math import pi

@dataclass
class Circle:
    radius: float

@dataclass
class Rectangle:
    width: float
    height: float

@dataclass
class Triangle:
    base: float
    height: float

Shape = Circle | Rectangle | Triangle

def area(shape: Shape) -> float:
    match shape:
        case Circle(radius=r):
            return pi * r ** 2
        case Rectangle(width=w, height=h):
            return w * h
        case Triangle(base=b, height=h):
            return b * h / 2

enum Shape:
  case Circle(radius: Double)
  case Rectangle(width: Double, height: Double)
  case Triangle(base: Double, height: Double)

def area(shape: Shape): Double = shape match
  case Shape.Circle(r)         => Math.PI * r * r
  case Shape.Rectangle(w, h)   => w * h
  case Shape.Triangle(b, h)    => b * h / 2

// Tuple
type Coordinate = [number, number];

// Record / Interface
interface User {
  name: string;
  email: string;
  age: number;
}

// 곱 타입의 가능한 값의 수
// boolean x boolean = 2 x 2 = 4가지
type Pair = [boolean, boolean];
// [true, true], [true, false], [false, true], [false, false]

// 나쁜 예: boolean 플래그 남발
interface RequestState {
  isLoading: boolean;
  isError: boolean;
  data: Data | null;
  error: Error | null;
}
// isLoading=true, isError=true, data=something → 불가능한 상태 표현 가능

// 좋은 예: ADT로 불가능한 상태 제거
type RequestState<T> =
  | { status: "idle" }
  | { status: "loading" }
  | { status: "success"; data: T }
  | { status: "error"; error: Error };

function renderState<T>(state: RequestState<T>): string {
  switch (state.status) {
    case "idle":    return "대기 중";
    case "loading": return "로딩 중...";
    case "success": return `데이터: ${state.data}`;
    case "error":   return `에러: ${state.error.message}`;
  }
}

// Option 타입 구현
type Option<T> = { tag: "some"; value: T } | { tag: "none" };

const some = <T>(value: T): Option<T> => ({ tag: "some", value });
const none: Option<never> = { tag: "none" };

function map<T, U>(opt: Option<T>, fn: (v: T) => U): Option<U> {
  return opt.tag === "some" ? some(fn(opt.value)) : none;
}

function flatMap<T, U>(opt: Option<T>, fn: (v: T) => Option<U>): Option<U> {
  return opt.tag === "some" ? fn(opt.value) : none;
}

function getOrElse<T>(opt: Option<T>, defaultValue: T): T {
  return opt.tag === "some" ? opt.value : defaultValue;
}

// 위험한 코드
function getUserCity(userId: string): string {
  const user = db.findUser(userId);       // null 가능
  const address = user.address;            // null이면 에러!
  return address.city;                     // null이면 에러!
}

// Option으로 안전하게
function getUserCity(userId: string): Option<string> {
  return pipe(
    findUser(userId),                       // Option<User>
    flatMap((user) => getAddress(user)),     // Option<Address>
    map((address) => address.city)           // Option<string>
  );
}

// 사용
const city = getOrElse(getUserCity("u1"), "Unknown");

// Result 타입 구현
type Result<T, E> =
  | { tag: "ok"; value: T }
  | { tag: "err"; error: E };

const ok = <T>(value: T): Result<T, never> => ({ tag: "ok", value });
const err = <E>(error: E): Result<never, E> => ({ tag: "err", error });

function mapResult<T, U, E>(
  result: Result<T, E>,
  fn: (v: T) => U
): Result<U, E> {
  return result.tag === "ok" ? ok(fn(result.value)) : result;
}

function flatMapResult<T, U, E>(
  result: Result<T, E>,
  fn: (v: T) => Result<U, E>
): Result<U, E> {
  return result.tag === "ok" ? fn(result.value) : result;
}

type ValidationError =
  | { code: "EMPTY_NAME"; message: string }
  | { code: "INVALID_EMAIL"; message: string }
  | { code: "UNDERAGE"; message: string };

function validateName(name: string): Result<string, ValidationError> {
  return name.trim().length > 0
    ? ok(name.trim())
    : err({ code: "EMPTY_NAME", message: "이름은 필수입니다" });
}

function validateEmail(email: string): Result<string, ValidationError> {
  return email.includes("@")
    ? ok(email)
    : err({ code: "INVALID_EMAIL", message: "유효한 이메일이 아닙니다" });
}

function validateAge(age: number): Result<number, ValidationError> {
  return age >= 18
    ? ok(age)
    : err({ code: "UNDERAGE", message: "18세 이상이어야 합니다" });
}

// 체이닝
function validateUser(input: UserInput): Result<ValidUser, ValidationError> {
  const nameResult = validateName(input.name);
  if (nameResult.tag === "err") return nameResult;

  const emailResult = validateEmail(input.email);
  if (emailResult.tag === "err") return emailResult;

  const ageResult = validateAge(input.age);
  if (ageResult.tag === "err") return ageResult;

  return ok({
    name: nameResult.value,
    email: emailResult.value,
    age: ageResult.value,
  });
}

일반 map:     Option<T>  → (T → U)          → Option<U>
flatMap:      Option<T>  → (T → Option<U>)  → Option<U>

map은    상자 안의 값을 변환
flatMap은 상자 안의 값으로 새 상자를 만들고, 이중 상자를 풀어줌

┌─────────────────────────────────────────────────┐
│  map: 상자를 열고, 변환하고, 다시 넣음            │
│                                                  │
│  [5]  --map(x => x * 2)-->  [10]                │
│                                                  │
│  flatMap: 상자를 열고, 새 상자를 만듦              │
│                                                  │
│  [5]  --flatMap(x => [x, x+1])-->  [5, 6]       │
│  (이중 상자 [[5, 6]]이 아님!)                     │
│                                                  │
│  Option 예시:                                    │
│  Some(5) --flatMap(x => Some(x*2))--> Some(10)  │
│  None    --flatMap(x => Some(x*2))--> None      │
│  (None이면 함수 실행 자체를 건너뜀)                │
└─────────────────────────────────────────────────┘

// 1. 좌항등원 (Left Identity)
// of(a).flatMap(f) === f(a)
flatMap(some(5), double) === double(5)

// 2. 우항등원 (Right Identity)
// m.flatMap(of) === m
flatMap(some(5), some) === some(5)

// 3. 결합법칙 (Associativity)
// m.flatMap(f).flatMap(g) === m.flatMap(x => f(x).flatMap(g))

// Promise.resolve = of
const p = Promise.resolve(5);

// .then = flatMap (실제로 map과 flatMap 역할을 모두 수행)
p.then((x) => x * 2);                        // map처럼
p.then((x) => Promise.resolve(x * 2));        // flatMap처럼 (자동 flatten)

// Promise는 "거의" 모나드
// 단, 자동 flatten 때문에 엄밀한 모나드 법칙에서 약간의 차이가 있음
// Promise<Promise<T>>가 불가능 → 항상 Promise<T>로 평탄화됨

async function processUserOrder(userId: string, itemId: string) {
  return pipe(
    await findUser(userId),                    // Result<User, Error>
    flatMapResult((user) => validateCredit(user)),  // Result<User, Error>
    flatMapResult((user) =>
      pipe(
        findItem(itemId),                      // Result<Item, Error>
        mapResult((item) => ({ user, item }))
      )
    ),
    flatMapResult(({ user, item }) =>
      createOrder(user, item)                  // Result<Order, Error>
    ),
  );
}

┌───────────────────────────────────────┐
│              Monad                     │
│  flatMap: F<A> → (A → F<B>) → F<B>   │
│                                       │
│    ┌───────────────────────────────┐  │
│    │        Applicative            │  │
│    │  ap: F<A→B> → F<A> → F<B>    │  │
│    │                               │  │
│    │    ┌───────────────────────┐  │  │
│    │    │      Functor          │  │  │
│    │    │  map: F<A> → (A→B)   │  │  │
│    │    │       → F<B>         │  │  │
│    │    └───────────────────────┘  │  │
│    └───────────────────────────────┘  │
└───────────────────────────────────────┘

// Functor 인터페이스
interface Functor<F> {
  map: <A, B>(fa: F<A>, f: (a: A) => B) => F<B>;
}

// Array는 Functor
[1, 2, 3].map(x => x * 2)  // [2, 4, 6]

// Option은 Functor
map(some(5), x => x * 2)   // some(10)
map(none, x => x * 2)      // none

// Promise는 Functor
Promise.resolve(5).then(x => x * 2)  // Promise<10>

// 두 Option 값을 더하고 싶을 때
const a: Option<number> = some(3);
const b: Option<number> = some(4);

// map만으로는 부족:
// map(a, x => map(b, y => x + y)) → Option<Option<number>> 중첩!

// Applicative: 함수도 컨텍스트에 넣어서 적용
function ap<A, B>(
  ff: Option<(a: A) => B>,
  fa: Option<A>
): Option<B> {
  if (ff.tag === "none" || fa.tag === "none") return none;
  return some(ff.value(fa.value));
}

const add = (x: number) => (y: number) => x + y;
const result = ap(map(a, add), b);  // some(7)

Functor:     하나의 값을 변환  → map
Applicative: 여러 독립 값 결합 → 병렬 유효성 검증
Monad:       연쇄적 의존 연산  → 이전 결과에 따라 다음 결정

실전 예:
- Functor: 사용자 이름을 대문자로 변환
- Applicative: 이름, 이메일, 나이를 동시에 검증하여 결과 결합
- Monad: 사용자 조회 → 조회된 사용자의 주문 조회 → 주문의 결제 처리

import { pipe, flow } from "fp-ts/function";
import * as O from "fp-ts/Option";
import * as E from "fp-ts/Either";
import * as A from "fp-ts/Array";
import * as TE from "fp-ts/TaskEither";

// Option 사용
const findUser = (id: string): O.Option<User> =>
  users.has(id) ? O.some(users.get(id)!) : O.none;

const getUserEmail = (id: string): string =>
  pipe(
    findUser(id),
    O.map((u) => u.email),
    O.getOrElse(() => "unknown@example.com")
  );

// Either 사용
const parseAge = (input: string): E.Either<string, number> => {
  const age = parseInt(input, 10);
  return isNaN(age)
    ? E.left("유효하지 않은 나이")
    : age < 0
      ? E.left("나이는 음수일 수 없습니다")
      : E.right(age);
};

// pipe로 체이닝
const result = pipe(
  "25",
  parseAge,
  E.map((age) => age + 1),
  E.fold(
    (error) => `에러: ${error}`,
    (age) => `내년 나이: ${age}`
  )
);

import * as TE from "fp-ts/TaskEither";

// DB 조회를 TaskEither로 래핑
const findUserTE = (id: string): TE.TaskEither<Error, User> =>
  TE.tryCatch(
    () => db.findUser(id),
    (reason) => new Error(`User not found: ${reason}`)
  );

const findOrderTE = (userId: string): TE.TaskEither<Error, Order[]> =>
  TE.tryCatch(
    () => db.findOrders(userId),
    (reason) => new Error(`Orders not found: ${reason}`)
  );

// 파이프라인
const getUserOrders = (userId: string) =>
  pipe(
    findUserTE(userId),
    TE.chain((user) => findOrderTE(user.id)),
    TE.map((orders) => orders.filter((o) => o.status === "active")),
    TE.fold(
      (error) => async () => ({ error: error.message }),
      (orders) => async () => ({ data: orders })
    )
  );

import { Effect, pipe } from "effect";

// Effect 정의
const divide = (a: number, b: number): Effect.Effect<number, Error> =>
  b === 0
    ? Effect.fail(new Error("Division by zero"))
    : Effect.succeed(a / b);

// 파이프라인
const program = pipe(
  divide(10, 2),
  Effect.flatMap((result) => divide(result, 3)),
  Effect.map((result) => `Result: ${result}`),
  Effect.catchAll((error) =>
    Effect.succeed(`Error: ${error.message}`)
  )
);

// 실행
Effect.runPromise(program).then(console.log);

// 원시 타입에 의미 부여
type UserId = string & { readonly _brand: "UserId" };
type OrderId = string & { readonly _brand: "OrderId" };

const userId = (id: string): UserId => id as UserId;
const orderId = (id: string): OrderId => id as OrderId;

// 타입 안전: userId와 orderId를 혼동할 수 없음
function findOrder(id: OrderId): Order { /* ... */ }

// findOrder(userId("u1"))  // 타입 에러!
findOrder(orderId("o1"));    // OK

from functools import reduce, partial, lru_cache
from typing import Callable, TypeVar

T = TypeVar("T")

# partial: 부분 적용
def power(base: int, exponent: int) -> int:
    return base ** exponent

square = partial(power, exponent=2)
cube = partial(power, exponent=3)

print(square(5))  # 25
print(cube(3))    # 27

# reduce: 축적
numbers = [1, 2, 3, 4, 5]
total = reduce(lambda acc, x: acc + x, numbers, 0)  # 15
product = reduce(lambda acc, x: acc * x, numbers, 1)  # 120

# lru_cache: 메모이제이션 (순수 함수에 최적)
@lru_cache(maxsize=128)
def fibonacci(n: int) -> int:
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

from itertools import chain, groupby, islice, starmap, accumulate

# chain: 이터러블 연결
combined = list(chain([1, 2], [3, 4], [5, 6]))  # [1, 2, 3, 4, 5, 6]

# groupby: 그룹화
data = [
    {"dept": "eng", "name": "Alice"},
    {"dept": "eng", "name": "Bob"},
    {"dept": "sales", "name": "Charlie"},
]
sorted_data = sorted(data, key=lambda x: x["dept"])
for key, group in groupby(sorted_data, key=lambda x: x["dept"]):
    print(f"{key}: {[g['name'] for g in group]}")

# accumulate: 누적 합
running_total = list(accumulate([1, 2, 3, 4, 5]))  # [1, 3, 6, 10, 15]

from returns.result import Result, Success, Failure
from returns.maybe import Maybe, Some, Nothing
from returns.pipeline import flow
from returns.pointfree import bind

# Maybe 사용
def find_user(user_id: str) -> Maybe[dict]:
    users = {"u1": {"name": "Alice", "email": "alice@example.com"}}
    return Some(users[user_id]) if user_id in users else Nothing

def get_email(user: dict) -> Maybe[str]:
    email = user.get("email")
    return Some(email) if email else Nothing

# 체이닝
result = find_user("u1").bind(get_email)  # Some("alice@example.com")
result = find_user("u999").bind(get_email)  # Nothing

# Result 사용
def parse_int(value: str) -> Result[int, str]:
    try:
        return Success(int(value))
    except ValueError:
        return Failure(f"Cannot parse '{value}' as int")

def validate_positive(n: int) -> Result[int, str]:
    return Success(n) if n > 0 else Failure("Must be positive")

# 파이프라인
result = parse_int("42").bind(validate_positive)  # Success(42)
result = parse_int("-1").bind(validate_positive)   # Failure("Must be positive")
result = parse_int("abc").bind(validate_positive)  # Failure("Cannot parse 'abc' as int")

from dataclasses import dataclass, field, replace
from typing import Tuple

@dataclass(frozen=True)
class AppState:
    users: Tuple[str, ...] = ()
    counter: int = 0

    def add_user(self, name: str) -> "AppState":
        return replace(self, users=self.users + (name,))

    def increment(self) -> "AppState":
        return replace(self, counter=self.counter + 1)

# 불변 상태 변환 체인
state = AppState()
state = state.add_user("Alice").add_user("Bob").increment()
print(state)  # AppState(users=('Alice', 'Bob'), counter=1)

┌──────────────────┬──────────────────────┬──────────────────────┐
│     관점          │         OOP          │         FP           │
├──────────────────┼──────────────────────┼──────────────────────┤
│ 기본 단위        │ 객체 (상태 + 행동)    │ 함수 (변환)          │
│ 상태 관리        │ 가변 상태 캡슐화      │ 불변 데이터 변환      │
│ 다형성           │ 상속 / 인터페이스     │ 타입 클래스 / 패턴매칭│
│ 코드 재사용      │ 상속                  │ 합성                 │
│ 부작용           │ 어디서든 허용          │ 격리 및 관리          │
│ 동시성           │ 락 / 동기화 필요       │ 불변성으로 안전       │
│ 에러 처리        │ 예외 (try-catch)      │ Result / Either      │
│ 디자인 패턴      │ GoF 패턴             │ 모나드, 펑터 등       │
│ 테스트           │ Mock 의존성 주입      │ 순수 함수 직접 테스트  │
│ 학습 곡선        │ 상대적으로 낮음       │ 상대적으로 높음       │
└──────────────────┴──────────────────────┴──────────────────────┘

// 클래스 + 불변성 + 함수형 메서드
class OrderService {
  constructor(
    private readonly db: Database,
    private readonly logger: Logger
  ) {}

  // 순수 함수: 비즈니스 로직
  private static calculateTotal(items: ReadonlyArray<OrderItem>): number {
    return items.reduce((sum, item) => sum + item.price * item.qty, 0);
  }

  private static applyDiscount(
    total: number,
    discountRate: number
  ): number {
    return total * (1 - discountRate);
  }

  // 불순한 쉘: I/O
  async processOrder(orderId: string): Promise<Result<Order, Error>> {
    const order = await this.db.findOrder(orderId);
    if (!order) return err(new Error("Order not found"));

    const total = OrderService.calculateTotal(order.items);
    const finalTotal = OrderService.applyDiscount(total, order.discountRate);

    const updated = { ...order, total: finalTotal, status: "processed" as const };
    await this.db.saveOrder(updated);
    this.logger.info(`Order ${orderId} processed: ${finalTotal}`);

    return ok(updated);
  }
}

성공 레일: ──── validate ──── transform ──── save ──── ✓
                  │                │           │
실패 레일: ──────┼────────────────┼───────────┼──── ✗
                  │                │           │
           유효성실패        변환에러      저장실패

// Railway 함수: 성공이면 다음으로, 실패면 바로 에러 레일
type Railway<T, E> = Result<T, E>;

function railway<A, B, E>(
  fn: (a: A) => Railway<B, E>
): (input: Railway<A, E>) => Railway<B, E> {
  return (input) => {
    if (input.tag === "err") return input;
    return fn(input.value);
  };
}

// 실전: 사용자 등록 파이프라인
const registerUser = flow(
  validateInput,              // Railway<Input, ValidationError>
  railway(checkDuplicate),    // Railway<Input, DuplicateError>
  railway(hashPassword),      // Railway<HashedInput, HashError>
  railway(saveToDb),          // Railway<User, DbError>
  railway(sendWelcomeEmail),  // Railway<User, EmailError>
);

const result = registerUser(ok(rawInput));

// 데이터 처리 파이프라인
type Transform<A, B> = (input: A) => B;

function pipeline<A>(...transforms: Transform<any, any>[]): Transform<A, any> {
  return (input: A) => transforms.reduce((acc, fn) => fn(acc), input as any);
}

// ETL 파이프라인 예시
const processLogs = pipeline<RawLog[]>(
  // Extract
  (logs) => logs.filter((l) => l.level === "ERROR"),
  // Transform
  (logs) => logs.map((l) => ({
    timestamp: new Date(l.ts),
    message: l.msg,
    service: l.service,
    stackTrace: l.stack?.split("\n"),
  })),
  // Load
  (logs) => groupBy(logs, (l) => l.service),
);

// 이벤트 정의
type AccountEvent =
  | { type: "ACCOUNT_OPENED"; owner: string; initialBalance: number }
  | { type: "DEPOSITED"; amount: number }
  | { type: "WITHDRAWN"; amount: number }
  | { type: "CLOSED" };

// 상태 정의
interface AccountState {
  owner: string;
  balance: number;
  status: "active" | "closed";
}

const initialState: AccountState = {
  owner: "",
  balance: 0,
  status: "active",
};

// 리듀서: (State, Event) => State (순수 함수!)
function accountReducer(
  state: AccountState,
  event: AccountEvent
): AccountState {
  switch (event.type) {
    case "ACCOUNT_OPENED":
      return {
        owner: event.owner,
        balance: event.initialBalance,
        status: "active",
      };
    case "DEPOSITED":
      return { ...state, balance: state.balance + event.amount };
    case "WITHDRAWN":
      return { ...state, balance: state.balance - event.amount };
    case "CLOSED":
      return { ...state, status: "closed" };
  }
}

// 이벤트 재생으로 현재 상태 복원
const events: AccountEvent[] = [
  { type: "ACCOUNT_OPENED", owner: "Alice", initialBalance: 1000 },
  { type: "DEPOSITED", amount: 500 },
  { type: "WITHDRAWN", amount: 200 },
];

const currentState = events.reduce(accountReducer, initialState);
// { owner: "Alice", balance: 1300, status: "active" }

// 액션 타입 (ADT)
type Action =
  | { type: "ADD_TODO"; payload: { id: string; text: string } }
  | { type: "TOGGLE_TODO"; payload: { id: string } }
  | { type: "DELETE_TODO"; payload: { id: string } };

interface State {
  readonly todos: ReadonlyArray<Todo>;
}

// 리듀서: 순수 함수
function reducer(state: State, action: Action): State {
  switch (action.type) {
    case "ADD_TODO":
      return {
        ...state,
        todos: [...state.todos, {
          id: action.payload.id,
          text: action.payload.text,
          completed: false,
        }],
      };
    case "TOGGLE_TODO":
      return {
        ...state,
        todos: state.todos.map((todo) =>
          todo.id === action.payload.id
            ? { ...todo, completed: !todo.completed }
            : todo
        ),
      };
    case "DELETE_TODO":
      return {
        ...state,
        todos: state.todos.filter((todo) => todo.id !== action.payload.id),
      };
  }
}

const arr = [1, 2, 3, 4, 5];
const result = arr
  .filter(x => x % 2 === 0)
  .map(x => x * 3)
  .reduce((acc, x) => acc + x, 0);

import * as O from "fp-ts/Option";
import { pipe } from "fp-ts/function";

const result = pipe(
  O.some(5),
  O.map(x => x * 2),
  O.flatMap(x => x > 5 ? O.some(x) : O.none),
);