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

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, tech_stack

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

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

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

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

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

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

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)

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)

(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

• 부모: Programming Paradigms · Lambda Calculus
• 변형: Pure FP (Haskell) · Hybrid FP (Scala, Rust) · FP-lite (JS, Python)
• 응용: React Hooks · Redux · Reactive Programming · CQRS
• Adjacent: Immutability · Type Theory · Monad · 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