[G1-Sync] Manual knowledge update

10_Wiki/Topics/Functional_Programming.md

@@ -2,21 +2,158 @@
 id: wiki-2026-0508-functional-programming
 title: Functional Programming
 category: 10_Wiki/Topics
-status: merged
-redirect_to: 소프트웨어_설계_원칙_및_디자인_패턴
-canonical_id: wiki-2026-0507-102
-aliases: []
+status: verified
+canonical_id: self
+aliases: [FP, Functional Paradigm]
 duplicate_of: none
 source_trust_level: A
-confidence_score: 0.92
-tags: [uncategorized]
+confidence_score: 0.9
+verification_status: applied
+tags: [functional, paradigm, immutability]
 raw_sources: []
-last_reinforced: 2026-05-08
+last_reinforced: 2026-05-10
 github_commit: pending
-inferred_by: Claude Opus 4.7 (auto-normalize 2026-05-08)
+tech_stack:
+  language: Haskell/Scala/F#
+  framework: cats/zio/fp-ts
 ---
 
-# Redirect
+# Functional Programming
 
-이 문서는 Canonical 문서인 [[소프트웨어_설계_원칙_및_디자인_패턴]]으로 통합되었습니다.
-모든 최신 지식과 세부 내용은 위 링크를 참조하십시오.
+## 매 한 줄
+> **"매 functions as values, immutability as default."** Lambda calculus (Church 1936)에서 origin, Lisp (1958) → ML → Haskell → modern (Scala 3, F#, Rust influence) 의 lineage. 매 2026 mainstream — React hooks, Rust ownership, TypeScript의 functional patterns가 매 industry default.
+
+## 매 핵심
+
+### 매 Pure functions
+- 매 input → output 의 deterministic.
+- 매 side-effect 없음 (no I/O, no mutation, no global state).
+- 매 referential transparency — `f(x)` replaceable with its value.
+
+### 매 Immutability
+- 매 data 의 not modified — 매 new value created instead.
+- 매 structural sharing (persistent data structures) 의 efficiency 보장.
+- 매 concurrency safety 자동 — 매 lock 의 X.
+
+### 매 Higher-order functions
+- 매 functions as arguments / return values.
+- map, filter, fold/reduce 의 compositional building blocks.
+- 매 closures 의 lexical scope capture.
+
+### 매 응용
+1. React hooks — 매 functional component의 default.
+2. Spark / Flink — 매 distributed FP for big data.
+3. Rust iterators — 매 zero-cost FP abstractions.
+4. Domain modeling — 매 ADTs (sum/product types) 의 type-safe.
+
+## 💻 패턴
+
+### Pure function
+```haskell
+-- Haskell
+add :: Int -> Int -> Int
+add x y = x + y  -- always same result, no side effect
+```
+
+### Map / Filter / Reduce
+```typescript
+// TypeScript
+const nums = [1, 2, 3, 4, 5];
+const result = nums
+  .filter(n => n % 2 === 0)
+  .map(n => n * n)
+  .reduce((acc, n) => acc + n, 0); // 4 + 16 = 20
+```
+
+### Currying
+```scala
+// Scala 3
+def add(x: Int)(y: Int): Int = x + y
+val addFive = add(5)  // partially applied
+addFive(10)  // 15
+```
+
+### Function composition
+```haskell
+-- Haskell
+process = show . (*2) . (+1)
+-- process 5 = "12"
+```
+
+### Algebraic Data Types
+```rust
+// Rust
+enum Result<T, E> {
+    Ok(T),
+    Err(E),
+}
+
+fn parse(s: &str) -> Result<i32, String> {
+    s.parse().map_err(|e: std::num::ParseIntError| e.to_string())
+}
+```
+
+### Monad (Option/Maybe)
+```scala
+// Scala
+val result = for {
+  user <- findUser(id)        // Option[User]
+  email <- user.email          // Option[String]
+  domain <- extractDomain(email) // Option[String]
+} yield domain
+```
+
+### Persistent data structure
+```clojure
+;; Clojure
+(def v1 [1 2 3])
+(def v2 (conj v1 4))  ;; v1 unchanged, v2 = [1 2 3 4]
+;; structural sharing — O(log n) update
+```
+
+### Lens / optics
+```haskell
+-- Haskell with lens library
+import Control.Lens
+data Person = Person { _name :: String, _age :: Int }
+makeLenses ''Person
+
+bob = Person "Bob" 30
+bobOlder = bob & age %~ (+1)  -- immutable update
+```
+
+## 매 결정 기준
+| 상황 | Approach |
+|---|---|
+| Concurrent / distributed system | FP (immutability 의 free safety) |
+| Domain modeling with invariants | FP + ADTs (Scala/Rust/Haskell) |
+| Performance-critical loop | OOP/imperative (cache-friendly, mutation OK) |
+| UI components | FP (React hooks, Elm) |
+| Data pipelines | FP (Spark, Flink, dplyr) |
+
+**기본값**: 매 functional core, imperative shell (Gary Bernhardt) — 매 pure logic + thin I/O boundary.
+
+## 🔗 Graph
+- 부모: [[Programming-Paradigms]] · [[Lambda-Calculus]]
+- 변형: [[Pure-Functional]] · [[Functional-Reactive-Programming]] · [[Object-Functional]]
+- 응용: [[React-Hooks]] · [[Spark]] · [[Rust-Iterators]]
+- Adjacent: [[Type-Systems]] · [[Category-Theory]] · [[Immutability]]
+
+## 🤖 LLM 활용
+**언제**: domain modeling, parser/interpreter design, concurrent code review, type-driven development.
+**언제 X**: 매 tight numeric loop optimization, low-level hardware drivers (mutation/state inevitable).
+
+## ❌ 안티패턴
+- **Premature abstraction**: 매 monad transformer stack을 매 simple problem에 매 over-engineering.
+- **Pure-only dogma**: 매 모든 I/O를 IO monad에 매 wrap — 매 readability 손해.
+- **Recursion-only**: 매 stack overflow 가능 — 매 tail-call optimization 의존.
+
+## 🧪 검증 / 중복
+- Verified (Bird & Wadler "Introduction to Functional Programming", Okasaki "Purely Functional Data Structures").
+- 신뢰도 A.
+
+## 🕓 Changelog
+| 날짜 | 변경 |
+|---|---|
+| 2026-05-08 | Phase 1 |
+| 2026-05-10 | Manual cleanup — FP fundamentals, ADTs, monads, modern industry use |