2nd/10_Wiki/Topic_Programming/Architecture/Functional_Programming.md

---
id: wiki-2026-0508-functional-programming
title: Functional Programming
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [FP, Functional Programming, 함수형 프로그래밍]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [paradigm, programming, haskell, scala, rust]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: haskell
  framework: multi
---

# Functional Programming

## 매 한 줄
> **"매 function이 first-class — 매 computation은 immutable value 의 transformation"**. 매 FP는 lambda calculus(Church 1936)에서 시작, Haskell/ML/Lisp 통해 academic 으로, 매 React/Redux/Rx 의 mainstream 침투. 2026 mainstream language 모두 FP feature 흡수 (lambdas, map/filter, immutable, pattern match).

## 매 핵심

### 매 Pillars
- **Pure function**: 매 same input → same output, no side effect
- **Immutability**: 매 data 변경 대신 new value 생성
- **First-class function**: 매 function = value (pass, return, store)
- **Referential transparency**: 매 expression을 value로 substitute 가능
- **Higher-order function**: 매 function in/out

### 매 Type system 매력
- **ADT** (algebraic data types): sum (Either, Option) + product (tuple, record)
- **Pattern matching**: 매 exhaustive case analysis
- **Type inference**: 매 Hindley-Milner (ML, Haskell, Rust)
- **Typeclasses** (Haskell) / Traits (Rust) / Type classes (Scala)

### 매 응용
1. React functional components + hooks (modern frontend).
2. Rust iterators + Option/Result (systems FP).
3. Scala/Akka (distributed reactive).
4. Haskell (compilers, finance, formal verification).
5. F# (.NET FP, fintech).

## 💻 패턴

### Haskell — pure + ADT
```haskell
data Tree a = Leaf | Node (Tree a) a (Tree a)

insert :: Ord a => a -> Tree a -> Tree a
insert x Leaf = Node Leaf x Leaf
insert x t@(Node l v r)
  | x < v     = Node (insert x l) v r
  | x > v     = Node l v (insert x r)
  | otherwise = t

-- 매 IO monad: side effect 격리
main :: IO ()
main = do
  putStrLn "Enter name:"
  name <- getLine
  putStrLn $ "Hello, " ++ name
```

### Rust — iterators + Option
```rust
fn process(nums: Vec<i32>) -> Vec<i32> {
    nums.iter()
        .filter(|&&x| x > 0)
        .map(|&x| x * x)
        .take(10)
        .collect()
}

// 매 Option chaining (no null)
fn find_user(id: u64) -> Option<String> {
    db.get(id)
        .and_then(|u| u.email)
        .map(|e| e.to_lowercase())
}
```

### Scala — case class + pattern match
```scala
sealed trait Shape
case class Circle(r: Double) extends Shape
case class Rect(w: Double, h: Double) extends Shape

def area(s: Shape): Double = s match {
  case Circle(r)    => math.Pi * r * r
  case Rect(w, h)   => w * h
}

// 매 immutable List + fold
val sum = List(1, 2, 3, 4).foldLeft(0)(_ + _)
```

### TypeScript — immutable + HOF
```typescript
// 매 readonly + pipe
const pipe = <T>(...fns: Array<(x: T) => T>) =>
  (x: T): T => fns.reduce((v, f) => f(v), x);

const addOne = (n: number) => n + 1;
const double = (n: number) => n * 2;
const pipeline = pipe<number>(addOne, double);
console.log(pipeline(3));  // 8

// 매 Result type (avoid throw)
type Result<T, E> = { ok: true; value: T } | { ok: false; error: E };
```

### Haskell — Functor / Monad
```haskell
-- 매 Maybe monad: null-safe chain
safeDivide :: Double -> Double -> Maybe Double
safeDivide _ 0 = Nothing
safeDivide x y = Just (x / y)

calc :: Maybe Double
calc = do
  a <- safeDivide 10 2
  b <- safeDivide a 0   -- 매 short-circuit Nothing
  return (b + 1)
-- 매 result: Nothing
```

### Elm — pure UI
```elm
type Msg = Increment | Decrement
type alias Model = { count : Int }

update : Msg -> Model -> Model
update msg model =
    case msg of
        Increment -> { model | count = model.count + 1 }
        Decrement -> { model | count = model.count - 1 }

view : Model -> Html Msg
view model =
    div []
        [ button [ onClick Decrement ] [ text "-" ]
        , text (String.fromInt model.count)
        , button [ onClick Increment ] [ text "+" ]
        ]
```

### Python — functools (FP-lite)
```python
from functools import reduce, partial, lru_cache

# 매 immutable transform
@lru_cache(maxsize=None)
def fib(n: int) -> int:
    return n if n < 2 else fib(n-1) + fib(n-2)

# 매 currying via partial
multiply = lambda x, y: x * y
double = partial(multiply, 2)
print(list(map(double, [1, 2, 3])))  # [2, 4, 6]

# 매 reduce
product = reduce(lambda a, b: a * b, [1, 2, 3, 4], 1)
```

### Persistent data structures (Clojure)
```clojure
(def v [1 2 3])
(def v2 (conj v 4))  ; 매 v unchanged, structural sharing
(println v)   ; [1 2 3]
(println v2)  ; [1 2 3 4]

;; 매 transducer (composable transformation)
(def xform (comp (filter odd?) (map #(* % %))))
(transduce xform + [1 2 3 4 5])  ; 1 + 9 + 25 = 35
```

## 매 결정 기준
| 상황 | FP fit |
|---|---|
| Concurrent / parallel | High — immutability eliminates race |
| Compilers / parsers | High — ADT + pattern match natural fit |
| UI state management | High — Redux/Elm pure update |
| Game loop (perf-critical) | Low — manual memory + mutation 필요 |
| OS kernel / driver | Low — direct hardware control 필요 |
| Domain modeling | High — ADT 가 매 invariants 표현 |

**기본값**: 매 mainstream language 에서 매 pure function preference + immutable default + side effect 격리.

## 🔗 Graph
- 응용: [[프론트엔드 및 UIUX 표준|Redux]] · [[CQRS]]
- Adjacent: [[Immutability]] · [[Type Theory]] · [[Algebraic Data Types]]

## 🤖 LLM 활용
**언제**: 매 refactor toward purity, type signature 설계, monad/applicative usage 설명.
**언제 X**: 매 hot loop micro-opt — mutation + cache locality 가 더 빠름.

## ❌ 안티패턴
- **Premature abstraction**: 매 Functor/Monad 도입했는데 매 use case 1개 → 매 cognitive overhead.
- **Pure obsession**: 매 logging/IO 도 monad transformer stack — 매 maintenance 지옥.
- **Recursion without TCO**: 매 stack overflow (Python — TCO 없음).
- **Over-currying**: 매 모든 function 1-arg curried → 매 readability 저하.

## 🧪 검증 / 중복
- Verified (Hutton, "Programming in Haskell", 2nd ed., 2016).
- Verified (Okasaki, "Purely Functional Data Structures", 1998).
- Verified (Wadler, "Theorems for free!", 1989).
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — pure FP + modern Haskell/Scala/Rust patterns |