関数型プログラミング実践ガイド：バックエンド開発者のための不変性・純粋関数・モナドの全て

┌──────────────────────────────────────────────────┐
│        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      │    │          │
│  │  │  (純粋ビジネスロジック)  │    │          │
│  │  │  - 計算                 │    │          │
│  │  │  - 変換                 │    │          │
│  │  │  - 検証                 │    │          │
│  │  └────────────────────────┘    │          │
│  └────────────────────────────────┘          │
│                                              │
└──────────────────────────────────────────────┘

// 関数を引数として受け取る
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

// 手動合成
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"]

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 });

// 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

// 悪い例: booleanフラグの乱用
interface RequestState {
  isLoading: boolean;
  isError: boolean;
  data: Data | null;
  error: Error | null;
}
// isLoading=true, isError=true → 不可能な状態が表現可能

// 良い例: 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;
}

// 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 });

// バリデーションチェーン
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歳以上である必要があります" });
}

通常の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>にフラット化

┌───────────────────────────────────────┐
│              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>         │  │  │
│    │    └───────────────────────┘  │  │
│    └───────────────────────────────┘  │
└───────────────────────────────────────┘

// 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>

const a: Option<number> = some(3);
const b: Option<number> = some(4);

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 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);
};

const findUserTE = (id: string): TE.TaskEither<Error, User> =>
  TE.tryCatch(
    () => db.findUser(id),
    (reason) => new Error(`User 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";

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);

from functools import reduce, partial, lru_cache

# 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

# lru_cache: メモ化（純粋関数に最適）
@lru_cache(maxsize=128)
def fibonacci(n: int) -> int:
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

from returns.result import Result, Success, Failure
from returns.maybe import Maybe, Some, Nothing

# 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")

┌──────────────────┬──────────────────────┬──────────────────────┐
│     観点          │         OOP          │         FP           │
├──────────────────┼──────────────────────┼──────────────────────┤
│ 基本単位         │ オブジェクト(状態+行動)│ 関数(変換)           │
│ 状態管理         │ 可変状態カプセル化    │ 不変データ変換        │
│ 多態性           │ 継承/インターフェース │ 型クラス/パターンマッチ│
│ コード再利用     │ 継承                  │ 合成                 │
│ 副作用           │ どこでも許可          │ 分離/管理            │
│ 並行性           │ ロック/同期が必要     │ 不変性で安全          │
│ エラー処理       │ 例外 (try-catch)     │ Result / Either      │
│ デザインパターン  │ GoFパターン          │ モナド、ファンクタ等  │
│ テスト           │ Mock/DI必要          │ 純粋関数直接テスト    │
│ 学習曲線         │ 比較的低い            │ 比較的高い           │
└──────────────────┴──────────────────────┴──────────────────────┘

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 ──── OK
                    │                │           │
失敗レール: ────────┼────────────────┼───────────┼──── ERR
                    │                │           │
              検証失敗          変換エラー    保存失敗

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(checkDuplicate),
  railway(hashPassword),
  railway(saveToDb),
  railway(sendWelcomeEmail),
);

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" }

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),
);