Functional Programming Practical Guide: Immutability, Pure Functions, and Monads for Backend Developers

┌──────────────────────────────────────────────────┐
│          Why FP Went Mainstream (2025)            │
├──────────────────────────────────────────────────┤
│  React Hooks    → Functional components standard │
│  Rust           → Ownership + immutability       │
│  TypeScript     → fp-ts, Effect ecosystem growth │
│  Java 21+       → Records, Pattern Matching      │
│  Python 3.12+   → match statement, functools     │
│  Kotlin         → Coroutines + FP built-in       │
└──────────────────────────────────────────────────┘

// Mutable - dangerous
const user = { name: "Alice", age: 30 };
user.age = 31; // Original mutated → unexpected behavior for other references

// Immutable - safe
const user = { name: "Alice", age: 30 };
const updatedUser = { ...user, age: 31 }; // New object created
// user is still { name: "Alice", age: 30 }

┌──────────────────────────────────────┐
│      Problems with Mutable State     │
├──────────────────────────────────────┤
│  Thread A: user.balance = 100        │
│  Thread B: user.balance = 200        │
│  Result: ??? (Race Condition)        │
├──────────────────────────────────────┤
│     Immutable State Solves This      │
├──────────────────────────────────────┤
│  Thread A: newUser = {...user, 100}  │
│  Thread B: newUser = {...user, 200}  │
│  Result: Each independent (safe)     │
└──────────────────────────────────────┘

// readonly keyword
interface User {
  readonly name: string;
  readonly age: number;
}

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

// Readonly utility type
type ImmutableUser = Readonly<User>;

// Deep immutability (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!

# Update using replace
from dataclasses import replace
updated = replace(user, age=31)

# NamedTuple is also immutable
class Point(NamedTuple):
    x: float
    y: float

// case class is immutable by default
case class User(name: String, age: Int)

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

// Immutable collections are the default
val list = List(1, 2, 3)
val newList = 0 :: list  // List(0, 1, 2, 3) — original preserved

Original tree:        After update:
    A                     A'
   / \                   / \
  B   C                 B   C'
 / \   \               / \   \
D   E   F             D   E   F'

→ B, D, E are shared (no copy needed)
→ Only A→A', C→C', F→F' newly created

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 (structural sharing)

// Pure function
function add(a: number, b: number): number {
  return a + b;
}

// Impure - depends on external state
let counter = 0;
function increment(): number {
  return ++counter; // Side effect: modifies external variable
}

// Impure - non-deterministic
function now(): number {
  return Date.now(); // Different result every time
}

// Referentially transparent
const x = add(2, 3); // 5
// add(2, 3) can be replaced with 5 anywhere

// Referentially opaque
const y = Math.random();
// Replacing Math.random() with y's value changes behavior

// Bad: side effects mixed into business logic
async function processOrder(orderId: string) {
  const order = await db.findOrder(orderId);         // side effect
  const discount = calculateDiscount(order);          // pure
  const total = applyDiscount(order.amount, discount); // pure
  await db.updateOrder(orderId, total);               // side effect
  await emailService.send(order.email, total);        // side effect
}

// Good: pure logic separated
// Pure functions
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 };
}

// Impure shell (kept thin)
async function processOrder(orderId: string) {
  const order = await db.findOrder(orderId);
  const result = computeOrderResult(order);  // Pure logic call
  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) │    │          │
│  │  │  - Calculations        │    │          │
│  │  │  - Transformations     │    │          │
│  │  │  - Validations         │    │          │
│  │  └────────────────────────┘    │          │
│  └────────────────────────────────┘          │
│                                              │
└──────────────────────────────────────────────┘

// Takes a function as argument
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;
}

// Returns a function
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" },
];

// Imperative approach
let total = 0;
for (const order of orders) {
  if (order.status === "completed") {
    total += order.amount;
  }
}

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

// Manual composition
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));

// Usage
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"]

// Explicit style
const getNames = (users: User[]) => users.map((u) => u.name);

// Point-free style
const getName = (u: User) => u.name;
const getNames = (users: User[]) => users.map(getName);

// More extreme point-free (fp-ts style)
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

// Normal function
function add(a: number, b: number): number {
  return a + b;
}

// Curried function
function curriedAdd(a: number): (b: number) => number {
  return (b: number) => a + b;
}

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

// Generic curry utility
function curry<A, B, C>(fn: (a: A, b: B) => C): (a: A) => (b: B) => C {
  return (a: A) => (b: B) => fn(a, b);
}

// Practical example: API client factory
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",
});

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

// Request processing middleware
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;
}

// Bad: boolean flag proliferation
interface RequestState {
  isLoading: boolean;
  isError: boolean;
  data: Data | null;
  error: Error | null;
}
// isLoading=true, isError=true, data=something → impossible state representable

// Good: ADT eliminates impossible states
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 "Idle";
    case "loading": return "Loading...";
    case "success": return `Data: ${state.data}`;
    case "error":   return `Error: ${state.error.message}`;
  }
}

// Option type implementation
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;
}

// Dangerous code
function getUserCity(userId: string): string {
  const user = db.findUser(userId);       // could be null
  const address = user.address;            // error if null!
  return address.city;                     // error if null!
}

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

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

// Result type implementation
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: "Name is required" });
}

function validateEmail(email: string): Result<string, ValidationError> {
  return email.includes("@")
    ? ok(email)
    : err({ code: "INVALID_EMAIL", message: "Invalid email" });
}

function validateAge(age: number): Result<number, ValidationError> {
  return age >= 18
    ? ok(age)
    : err({ code: "UNDERAGE", message: "Must be 18 or older" });
}

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

Regular map:  Option<T>  → (T → U)          → Option<U>
flatMap:      Option<T>  → (T → Option<U>)  → Option<U>

map     transforms the value inside the box
flatMap creates a new box from the value and unwraps the double box

┌──────────────────────────────────────────────────┐
│  map: Open box, transform, put back              │
│                                                  │
│  [5]  --map(x => x * 2)-->  [10]                │
│                                                  │
│  flatMap: Open box, create new box               │
│                                                  │
│  [5]  --flatMap(x => [x, x+1])-->  [5, 6]       │
│  (NOT double-boxed [[5, 6]]!)                    │
│                                                  │
│  Option example:                                 │
│  Some(5) --flatMap(x => Some(x*2))--> Some(10)  │
│  None    --flatMap(x => Some(x*2))--> None      │
│  (If None, function execution is skipped)        │
└──────────────────────────────────────────────────┘

// 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 (actually serves both map and flatMap roles)
p.then((x) => x * 2);                        // like map
p.then((x) => Promise.resolve(x * 2));        // like flatMap (auto-flatten)

// Promise is "almost" a monad
// But auto-flattening causes slight deviations from strict monad laws
// Promise<Promise<T>> is impossible → always flattened to 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
interface Functor<F> {
  map: <A, B>(fa: F<A>, f: (a: A) => B) => F<B>;
}

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

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

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

// When you want to add two Option values
const a: Option<number> = some(3);
const b: Option<number> = some(4);

// map alone is insufficient:
// map(a, x => map(b, y => x + y)) → Option<Option<number>> nested!

// Applicative: puts function in context and applies
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:     Transform a single value  → map
Applicative: Combine independent values → parallel validation
Monad:       Sequential dependent ops   → next step depends on previous result

Practical examples:
- Functor: Convert username to uppercase
- Applicative: Validate name, email, age simultaneously and combine results
- Monad: Look up user → query user's orders → process order payment

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 usage
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 usage
const parseAge = (input: string): E.Either<string, number> => {
  const age = parseInt(input, 10);
  return isNaN(age)
    ? E.left("Invalid age")
    : age < 0
      ? E.left("Age cannot be negative")
      : E.right(age);
};

// Chaining with pipe
const result = pipe(
  "25",
  parseAge,
  E.map((age) => age + 1),
  E.fold(
    (error) => `Error: ${error}`,
    (age) => `Next year's age: ${age}`
  )
);

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

// Wrap DB query as 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}`)
  );

// Pipeline
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 definition
const divide = (a: number, b: number): Effect.Effect<number, Error> =>
  b === 0
    ? Effect.fail(new Error("Division by zero"))
    : Effect.succeed(a / b);

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

// Execute
Effect.runPromise(program).then(console.log);

// Give meaning to primitive types
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;

// Type safety: userId and orderId cannot be mixed up
function findOrder(id: OrderId): Order { /* ... */ }

// findOrder(userId("u1"))  // Type error!
findOrder(orderId("o1"));    // OK

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

T = TypeVar("T")

# partial: partial application
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: accumulation
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: memoization (ideal for pure functions)
@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: connect iterables
combined = list(chain([1, 2], [3, 4], [5, 6]))  # [1, 2, 3, 4, 5, 6]

# groupby: grouping
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 totals
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 usage
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

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

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

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

# Immutable state transformation chain
state = AppState()
state = state.add_user("Alice").add_user("Bob").increment()
print(state)  # AppState(users=('Alice', 'Bob'), counter=1)

┌──────────────────┬──────────────────────┬──────────────────────┐
│     Aspect        │         OOP          │         FP           │
├──────────────────┼──────────────────────┼──────────────────────┤
│ Basic unit       │ Object (state+behav) │ Function (transform) │
│ State mgmt       │ Mutable encapsulate  │ Immutable transform  │
│ Polymorphism     │ Inheritance/Iface    │ Type class/Matching  │
│ Code reuse       │ Inheritance          │ Composition          │
│ Side effects     │ Anywhere allowed     │ Isolated/managed     │
│ Concurrency      │ Locks/sync needed    │ Safe via immutability│
│ Error handling   │ Exceptions try-catch │ Result / Either      │
│ Design patterns  │ GoF patterns         │ Monads, functors     │
│ Testing          │ Mock/DI required     │ Pure function direct │
│ Learning curve   │ Relatively lower     │ Relatively higher    │
└──────────────────┴──────────────────────┴──────────────────────┘

// Class + immutability + functional methods
class OrderService {
  constructor(
    private readonly db: Database,
    private readonly logger: Logger
  ) {}

  // Pure function: business logic
  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);
  }

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

Success rail: ──── validate ──── transform ──── save ──── OK
                      │                │           │
Failure rail: ────────┼────────────────┼───────────┼──── ERR
                      │                │           │
                Validation fail   Transform err  Save fail

// Railway function: success continues, failure stays on error rail
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);
  };
}

// Practical: user registration pipeline
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));

// Data processing pipeline
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 pipeline example
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),
);

// Event definitions
type AccountEvent =
  | { type: "ACCOUNT_OPENED"; owner: string; initialBalance: number }
  | { type: "DEPOSITED"; amount: number }
  | { type: "WITHDRAWN"; amount: number }
  | { type: "CLOSED" };

// State definition
interface AccountState {
  owner: string;
  balance: number;
  status: "active" | "closed";
}

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

// Reducer: (State, Event) => State (pure function!)
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" };
  }
}

// Replay events to restore current state
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" }

// Action types (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>;
}

// Reducer: pure function
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),
);