함수형 프로그래밍
개요
함수형 프로그래밍(Functional Programming, FP)은 계산을 수학적 함수의 평가로 다루고, 상태 변경과 가변 데이터를 피하는 프로그래밍 패러다임으로, 함수형 패러다임이라고도 부른다.
함수형 프로그래밍은 객체지향 프로그래밍과 함께 널리 쓰이지만, 그 이론적 기반인 람다 계산법(lambda calculus)은 객체지향이 형성되기 전인 1930년대 수리논리학에서 출발했다. 이처럼 오래 이어진 이론이라는 점에서 "오래된 새 패러다임"이라고 불리기도 한다.
객체지향 = 데이터와 그 데이터를 조작하는 행위를 객체 단위로 묶는다
함수형 = 데이터를 변환하는 순수 함수의 합성으로 프로그램을 구성한다
핵심 정의
함수형 프로그래밍은 다음 성질을 강하게 강조하는 패러다임이다.
1. 함수가 일급 시민(first-class)이다.
2. 함수는 수학적 의미의 함수에 가깝다 (동일 입력 → 동일 출력).
3. 상태 변경(mutation)과 부수 효과(side effect)를 회피한다.
4. 반복(loop)보다 재귀(recursion)와 고차 함수(higher-order)를 선호한다.
5. 자료는 변경되지 않고 새 자료를 만든다 (immutability).
이 성질들을 얼마나, 또 어떤 방식으로 강제하는지는 언어마다 다르며, 함수형 전용 언어가 아니더라도 함수형 사고방식은 여러 형태로 쓰인다.
역사
함수형 프로그래밍의 역사는 산업이 아니라 수리논리학에서 시작된다. 이 출발점이 함수형 프로그래밍의 문화와 어휘를 객체지향과 다르게 만들었다.
람다 계산법 (1930년대)
Alonzo Church가 1930년대에 발전시킨 람다 계산법은 함수 추상화와 적용을 중심으로 계산을 표현한다. 비타입 람다 계산법과 튜링 기계가 같은 계산 가능 함수를 표현한다는 동등성은 증명되어 있는데, 처치–튜링 명제(Church–Turing thesis)는 이 형식 체계들이 직관적인 "효과적으로 계산 가능한 것"의 범위를 포착한다는 주장이다. 형식 체계 사이의 동등성 정리와 이 명제는 구분해야 한다.1
람다 계산법의 기본 연산:
- 변수: x
- 추상: λx. M (x를 받아 M을 반환하는 함수)
- 적용: M N (함수 M에 인자 N을 적용)
람다식의 적용을 식으로 적으면 다음과 같다. M은 함수 본문, N은 인자이고, M[x := N]은 본문에서 자유롭게 나타나는 x를 N으로 치환한 결과다. 치환 과정에서 변수 이름이 우연히 겹치면 먼저 이름을 바꾸어, 인자 안의 변수가 다른 람다에 묶이지 않게 한다.
하스켈의 (\x -> x + 1) 2는 같은 적용을 실행 코드로 적은 예이며 결과는 3이다.
Haskell 2010 Report는 람다 추상식과 함수 적용의 문법을 정의한다.2
비타입 람다 계산법에서는 이 세 가지 구문만으로 자연수와 불, 자료구조와 재귀까지 부호화할 수 있는데, 현대 함수형 언어는 여기에 타입 이론, 대수적 자료형, 모듈, 효과 처리 등 여러 흐름을 더해 발전했다.
Lisp (1958)
John McCarthy가 1958년부터 설계한 Lisp(LISt Processor)는 람다 표기에서 영향을 받은 초기 언어이자 함수형 프로그래밍의 중요한 출발점이다. McCarthy의 1960년 논문 "Recursive Functions of Symbolic Expressions and Their Computation by Machine"이 기초 문헌이다.3
Lisp는 함수형 사고방식의 핵심 요소(일급 함수, 재귀 중심, 동질 자료/코드)를 도입했지만, 가변 변수와 부수 효과를 자유롭게 허용했다. Lisp는 함수형의 출발점이지 순수 함수형은 아니다.
ISWIM과 이론적 기반 (1960년대)
Peter Landin은 1966년 논문 "The Next 700 Programming Languages"에서 가상 언어 ISWIM(If you See What I Mean)을 제시했다. 논문에는 실험적 프로토타입 구현도 나오지만 널리 쓰이는 완성 제품보다는 언어 설계의 틀로 후속 언어에 영향을 주었고, let/where 구문과 표현식 중심 설계, 오프사이드 규칙 계열의 사고방식이 이 흐름과 연결된다.45
Backus의 튜링 강연 (1977년 수상·1978년 출판)
1977년 튜링상 수상자인 John Backus는 1978년 논문으로 출판된 수상 강연 "Can Programming Be Liberated from the Von Neumann Style?"에서 명령형 프로그래밍이 폰 노이만 구조에 너무 묶여 있다고 비판하고, 함수 수준(function-level) 프로그래밍을 제안했다.6 이 강연은 함수형 프로그래밍 운동의 산업적 정당화로 자주 인용된다.
Backus는 명령형 프로그래밍의 대표 언어인 FORTRAN의 설계자였다. 그 언어를 만든 사람이 직접 패러다임의 한계를 지적했다는 점에서 이 강연은 더 무게를 가진다.
ML 계열 (1973)
Robin Milner가 LCF(Logic for Computable Functions) 정리 증명기를 위해 1973년 무렵 만든 ML(Meta Language)은 정적 타입 추론을 함수형 언어에 결합한 대표적 사례다.7 Hindley-Milner 타입 시스템은 ML 계열을 통해 널리 알려졌고, 이후 정적 타입 함수형 언어의 기반이 되었다.
ML 계열 후예:
Standard ML (1983년 설계 작업 시작, 1990년 정의 출판, 1997년 개정)8
Caml (1985) / OCaml (1996)
F# (2005) - Microsoft, OCaml 기반
영향 받음: Rust, Swift, Scala의 타입 시스템
Miranda와 게으른 평가 (1985)
David Turner가 1985년 발표한 Miranda는 게으른 평가(lazy evaluation), 순수 함수, 대수적 자료형을 결합한 상업 지원 순수 함수형 언어다.9 Miranda는 상표권 문제로 학계에서 공통 연구 언어로 쓰기 어려웠고, 여러 게으른 함수형 언어를 통합할 공개 표준의 필요성이 Haskell 탄생 배경 중 하나가 되었다.
Haskell (1990)
Haskell은 1987년 게으른 평가 기반 함수형 언어의 공통 표준을 만들기 위한 위원회로 시작해 1990년 첫 표준(Haskell 1.0)을 발표했다.10 이름은 람다 계산법 연구자 Haskell Curry에서 왔다.
Haskell의 결정적 기여:
게으른 평가를 기본으로 채택
I/O를 모나드로 분리하여 순수성 유지. 표준 모나딕 I/O는 Haskell 1.0(1990)이 아니라 1.3(1996)에 도입됨11
타입 클래스 도입 (Wadler & Blott, 1989)
학문과 산업 양쪽에서 함수형 사고방식의 표준 참조점이 됨
개인적인 메모: "하스켈로 프로그래밍하면 버그도 없지만 완성도 못 한다"는 농담이 있다. 나는 이 농담을 좋아한다.
동시성 중심 함수형 (Erlang, 1986)
Joe Armstrong을 비롯한 Ericsson 연구진이 1986년에 만든 Erlang은 통신 시스템의 동시성과 신뢰성을 위해 설계된 함수형 언어다. 경량 프로세스, 비동기 메시지 전달, "let it crash" 철학으로 고가용성 시스템에서 잘 알려져 있다. 이 프로세스 모델은 흔히 액터 모델로 설명되지만, 설계자들이 처음부터 액터 모델을 구현하려고 만든 것은 아니다. Elixir(2011)는 같은 Erlang VM을 사용하는 별도의 언어다.12
모던 함수형의 재부상 (2000년대 이후)
산업 영역에서 함수형 프로그래밍이 다시 주목받기 시작한 계기:
멀티코어 시대 도래 - 가변 상태의 동시성 비용이 커짐
Scala (2004년 첫 공개; 초기 1.0은 2003년으로도 기록됨), Clojure (2007), F# (2005) 등 JVM/CLR 함수형 언어 등장1314
Rust (2010-) - 함수형 영향이 강한 시스템 언어
React + Redux (2015-) - JS 프론트엔드에 단방향 데이터 흐름과 불변성 도입
TypeScript (2012-) - discriminated union, type-level 표현력
함수형 프로그래밍의 여러 도구는 이제 주류 다중 패러다임 언어에서도 쓸 수 있다.
핵심 개념
일급 함수 (First-class Function)
함수가 다른 값과 동등하게 다뤄진다는 의미.
- 변수에 함수를 할당할 수 있다
- 함수를 다른 함수의 인자로 넘길 수 있다
- 함수를 다른 함수의 반환값으로 받을 수 있다
- 자료구조에 함수를 저장할 수 있다
일급 함수가 있으면 고차 함수를 자연스럽게 쓸 수 있다. 다만 함수 인자는 받으면서 함수 값을 저장하거나 반환하는 데는 제약을 두는 언어도 있으니, 완전한 일급 함수 지원까지 갖춰야만 고차 함수를 쓸 수 있는 것은 아니다.
순수 함수 (Pure Function)
다음 두 조건을 모두 만족하는 함수:
입력과 결과를 수학적 함수로 보면 f : A → B에서 A는 입력의 집합, B는 결과의 집합이다. 여기서는 계산이 종료되고 값이 정의된 입력을 다루는 모형을 쓰며, 같은 입력이 같은 결과로 이어지는 관계를 다음처럼 적는다.
이 식은 입력과 결과의 관계를 적은 것이고, 순수성에는 관찰 가능한 부수 효과가 없다는 조건도 함께 들어간다. 하스켈의 타입 화살표만으로 함수가 모든 입력에서 종료한다는 사실까지 증명되지는 않는다.
1. 같은 입력은 외부 상태와 무관하게 같은 의미의 결과를 갖는다.
2. 외부 상태를 변경하거나 관찰 가능한 부수 효과를 일으키지 않는다.전역 변수 변경, 콘솔 출력, 파일 쓰기, 네트워크 통신은 전형적인 부수 효과이며, 예외를 관찰하고 처리하는 동작도 효과로 다뤄질 수 있다. Haskell의 error나 비종료는 순수 표현식 안에도 나타나는 bottom(⊥)이므로, 순수하다고 해서 항상 정상적인 값을 반환하는 것은 아니다.
순수 함수의 가치는 표현식을 그 결과 값으로 치환해도 프로그램 의미가 바뀌지 않는 참조 투명성(referential transparency)에 있으며, 함수형 추론과 최적화도 이 성질에 기대고 있다.
불변성 (Immutability)
한 번 만든 값은 그대로 두고, 변경이 필요할 때 새 값을 만드는 성질이다.
xs, ys :: [Int]
xs = [1, 2, 3]
ys = 0 : xs
main :: IO ()
main = print (xs, ys)
불변 값을 갱신하려면 새 데이터를 위한 메모리를 할당하는데, 영속 자료구조(persistent data structure)는 바뀌지 않은 부분을 구조 공유(structural sharing)로 재사용해 전체를 복사하는 비용을 줄인다. 실제 할당량과 처리 시간은 어떤 자료구조에 무슨 연산을 하느냐에 따라 달라진다.
고차 함수 (Higher-order Function)
함수를 인자로 받거나 반환하는 함수로, 함수형 프로그래밍에서는 이런 고차 함수를 추상화 단위로 쓴다.
-- Prelude 함수의 리스트 전용 타입 서명:
-- map :: (a -> b) -> [a] -> [b]
-- filter :: (a -> Bool) -> [a] -> [a]
-- foldr :: (a -> b -> b) -> b -> [a] -> b
main :: IO ()
main = do
let xs = [1, 2, 3, 4] :: [Int]
print (map (* 2) xs)
print (filter even xs)
print (foldr (+) 0 xs)
위 예제의 map은 함수 자체를 받아 리스트의 각 원소에 적용하고, foldr는 원소와 누적값을 결합하는 함수를 받아 하나의 결과를 만든다. 유한 리스트에서 그 계산 모양을 펼치면 다음 두 식이 된다.
foldr (+) 0 [1,2,3]이라면 1 + (2 + (3 + 0))으로 읽는다. 이 식은 값을 결합하는 구조를 보여 주며, 게으른 평가에서는 계산에 필요한 값이 요구될 때 평가한다.
객체지향에서 다형성과 상속이 추상화 도구라면, 함수형에서는 고차 함수가 그 역할을 한다.
함수 합성 (Function Composition)
두 함수를 이어 하나의 함수로 만드는 연산.
f의 결과를 g의 입력으로 넘길 수 있다면 두 함수를 합성할 수 있다. g ∘ f는 먼저 f를 적용하고 그 결과에 g를 적용하는 순서이며, 하스켈에서는 g . f로 적는다.
아래의 negate . double에 3을 넣으면 double 3이 만든 6을 negate에 넘기므로 결과는 -6이다.
double :: Int -> Int
double x = x * 2
doubleNegate :: Int -> Int
doubleNegate = negate . double
main :: IO ()
main = print (doubleNegate 3)
함수 합성은 함수형의 모듈성 단위다. 객체지향이 객체를 조립한다면 함수형은 함수를 합성한다.
커링과 부분 적용 (Currying / Partial Application)
커링은 튜플로 인자를 받는 함수 (a, b) -> c를 한 인자씩 받는 a -> b -> c로 바꾸는 변환으로, 여러 인자를 받는 방식을 함수의 연속으로 표현한다. 이름은 Haskell Curry에서 왔으며, 함수에 일부 인자만 먼저 주는 부분 적용과는 구별한다.
커링은 두 인자를 한 쌍으로 받는 함수를, 첫 인자를 받은 뒤 다음 인자를 기다리는 함수로 대응시킨다. 정의된 값을 다루는 수학적 함수에서 그 관계는 다음처럼 적을 수 있다.
하스켈에서 add 1은 첫 인자를 1로 고정한 함수다. 커링은 인자를 받는 구조이고, 이렇게 일부 인자만 먼저 주는 사용 방식은 부분 적용이다.
add :: Int -> Int -> Int
add x y = x + y
addOne :: Int -> Int
addOne = add 1
addPair :: (Int, Int) -> Int
addPair = uncurry add
main :: IO ()
main = print (addOne 4, addPair (2, 3), curry addPair 2 3)
Haskell과 OCaml에서는 f x y 같은 커링된 정의를 자연스럽게 쓴다. 튜플 하나를 받는 f (x, y)도 가능하므로 "모든 함수가 자동 커링된다"고 말하는 것은 부정확하다. JavaScript와 Python에서도 함수를 반환하는 함수로 같은 구조를 직접 만들 수 있다.
게으른 평가 (Lazy Evaluation)
값이 실제로 필요한 시점까지 계산을 미루는 평가 전략. Haskell이 대표적.
naturals :: [Integer]
naturals = [1..]
main :: IO ()
main = print (take 5 naturals)
게으른 평가는 함수를 합성하고 추상화하는 데 도움이 되지만, 미룬 계산 때문에 공간 누수(space leak)가 생기거나 디버깅이 어려워지기도 한다. 이런 함정은 뒤의 함수형 안티패턴에서 다시 다룬다.
재귀와 꼬리 호출 최적화
함수형 코드에서는 map, fold, traverse 같은 고차 함수나 재귀로 반복을 표현하는데, 직접 재귀를 쓴다면 호출 뒤에 계산이 남는지와 호출이 꼬리 위치에 있는지에 따라 공간 사용이 달라질 수 있다. 꼬리 호출 최적화(TCO, Tail Call Optimization)는 꼬리 호출에서 호출자 스택을 재사용하도록 하는 구현 기법이다.
import Data.List (foldl')
sumNonTail :: [Int] -> Int
sumNonTail [] = 0
sumNonTail (x:xs) = x + sumNonTail xs
-- Tail position alone does not force acc + x.
sumTailLazy :: Int -> [Int] -> Int
sumTailLazy acc [] = acc
sumTailLazy acc (x:xs) = sumTailLazy (acc + x) xs
sumStrict :: [Int] -> Int
sumStrict = foldl' (+) 0
main :: IO ()
main = do
let xs = [1..100] :: [Int]
print (sumNonTail xs, sumTailLazy 0 xs, sumStrict xs)
Scheme과 Erlang은 꼬리 호출의 공간 동작을 언어·런타임 차원에서 중요하게 다루고, OCaml도 꼬리 재귀를 지원한다. 다만 Haskell에서는 꼬리 위치의 호출이라도 누산기 값이 자동으로 엄격해지지 않는다. 위 sumTailLazy의 acc + x가 thunk로 쌓이면 힙 사용량이 늘고, 이 체인을 나중에 평가하다 스택이 넘칠 수도 있다. 이런 공간 누수를 줄이려면 seq, bang pattern, foldl' 같은 엄격성 제어가 필요하다.15
타입 시스템과 결합한 함수형 개념
대수적 자료형 (Algebraic Data Type)
곱 타입(product, AND)과 합 타입(sum, OR)의 조합으로 자료를 표현한다.
data Point = Point Double Double deriving Show
data Shape = Circle Point Double
| Rectangle Point Point
| Triangle Point Point Point
deriving Show
main :: IO ()
main = mapM_ print
[ Circle (Point 0 0) 2
, Rectangle (Point 0 0) (Point 3 4)
, Triangle (Point 0 0) (Point 4 0) (Point 0 3)
]
Point는 x좌표와 y좌표를 함께 가져야 하므로 곱 타입이고, Shape는 Circle·Rectangle·Triangle 중 하나를 선택하므로 합 타입이다. 선택한 도형에 필요한 좌표나 반지름은 다시 한 묶음으로 담긴다.
Result 타입, Option 타입, 트리, 리스트, 모두 대수적 자료형으로 표현된다.
패턴 매칭 (Pattern Matching)
대수적 자료형을 분해하면서 분기하는 구문.
data Point = Point Double Double
data Shape = Circle Point Double
| Rectangle Point Point
| Triangle Point Point Point
area :: Shape -> Double
area (Circle _ r) = pi * r * r
area (Rectangle (Point x1 y1) (Point x2 y2)) =
abs (x2 - x1) * abs (y2 - y1)
area (Triangle (Point x1 y1) (Point x2 y2) (Point x3 y3)) =
abs ((x2 - x1) * (y3 - y1) - (x3 - x1) * (y2 - y1)) / 2
main :: IO ()
main = do
print (area (Circle (Point 0 0) 1) == pi)
print (area (Rectangle (Point 0 0) (Point 3 4)))
print (area (Triangle (Point 0 0) (Point 4 0) (Point 0 3)))
정적 타입 언어에서는 exhaustiveness check로 빠진 패턴을 컴파일 시점에 찾을 수 있지만, 실제로 어떤 생성자의 값이 들어왔는지 보고 분기를 고르는 일은 보통 실행 시점에 한다. GHC에서 누락 패턴을 오류로 다루려면 -Werror=incomplete-patterns 옵션을 사용한다.16
타입 클래스 (Type Class)
Haskell이 도입한 ad-hoc 다형성 메커니즘. Philip Wadler와 Stephen Blott가 1989년 논문 "How to Make Ad-Hoc Polymorphism Less Ad Hoc"에서 제안했다.17
-- Eq already exists in Prelude. Define an instance for our own type.
newtype UserId = UserId Int
instance Eq UserId where
UserId x == UserId y = x == y
main :: IO ()
main = print (UserId 7 == UserId 7, UserId 7 == UserId 8)
Rust의 trait, Scala의 implicit/given을 이용한 타입 클래스 패턴, Swift의 protocol은 타입에 대한 연산 집합을 추상화하는 데 쓰이며, 특히 Rust trait과 Scala type class 패턴은 Haskell 타입 클래스와 자주 비교된다. 다만 모듈 시스템과 객체 시스템, 컴파일러의 제약은 서로 다르다.
매개변수 다형성 (Parametric Polymorphism)
구체적인 타입 대신 타입 변수 a를 써서 여러 타입에 같은 구현을 적용하는 다형성이다. identity는 입력 타입의 내부 구조를 알아야 할 이유가 없으며 Java 제네릭과 비교할 수 있는데, C++ 템플릿은 타입마다 다른 연산을 선택할 수 있다는 점에서 차이가 있다.
identity :: a -> a
identity x = x
listLength :: [a] -> Int
listLength [] = 0
listLength (_:xs) = 1 + listLength xs
main :: IO ()
main = do
print (identity True, identity "hello")
print (listLength [False, True], listLength "hello")
타입 변수 a는 어떤 타입으로도 인스턴스화될 수 있다.
부수 효과 다루기
상태 전이는 s -> (a, s) 같은 순수 함수로, 실패는 Maybe나 Either 값으로 표현할 수 있다. Haskell의 IO a도 순수하게 조합하는 동작 값이고, 이를 실행해 외부 세계와 상호작용하는 일은 런타임이 맡는다.
모나드 (Monad)
모나드는 값을 계산 문맥에 넣고 앞선 결과에 따라 다음 계산을 이어 붙이는 연산과 법칙을 갖는 추상으로, 부수 효과를 다루는 데 쓰이지만 용도가 거기에만 한정되지는 않는다. Eugenio Moggi는 1988년 기술 보고서와 1989년 LICS 논문에서 이 접근을 전개한 뒤 1991년 "Notions of Computation and Monads"에서 계산 의미론으로 다뤘고, Philip Wadler 등은 이를 함수형 프로그래밍과 Haskell에 적용했다.181920
main :: IO ()
main = do
name <- getLine
putStrLn ("Hello, " ++ name)
getLine이 IO String을 반환한다는 것은 "문자열을 만드는 IO 작업"이라는 의미이지 "문자열 그 자체"가 아니다. 이 타입 차이가 순수 함수와 부수 효과를 분리한다.
위 코드에서 name <- getLine은 입력 동작이 만든 문자열을 다음 동작에서 쓸 이름 name에 연결한다. do는 이런 계산을 순서대로 이어 쓰는 표기로, 이 예제는 >>=를 써서 다음처럼 적을 수도 있다.21
main :: IO ()
main = getLine >>= \name -> putStrLn ("Hello, " ++ name)
모나드를 잇는 연산을 수식에서는 bind라고 쓰고, 하스켈의 (>>=)에 대응시킬 수 있다. pure는 값을 해당 계산 문맥에 넣는다. 법칙을 만족하는 모나드 구현은 아래처럼 pure를 앞뒤에 붙이거나 계산을 묶는 위치를 바꾸어도 같은 의미를 유지한다.
순서대로 왼쪽 항등법칙, 오른쪽 항등법칙, 결합법칙이다. 컴파일러는 타입을 검사하고, 인스턴스 구현자는 이 법칙도 만족하도록 구현한다. 등식은 계산의 의미를 비교하며 실행 시간이나 메모리 할당량까지 같다고 요구하지는 않는다.
Haskell 2010 Report는 Monad의 연산과 세 법칙을 설명한다.22
두 코드는 한 줄을 읽어 같은 인사를 출력하며, name은 다음 출력 동작에서 쓰는 문자열이다. 문자열을 얻었어도 전체 계산의 타입은 여전히 IO ()로 남는다.
흔한 오해 정정:
모나드 = 카테고리 이론에서 빌려온 형식이지만, 사용 자체는 카테고리 이론 지식이 필요하지 않다
모나드는 if/then/else처럼 프로그래밍 도구일 뿐 신비한 개념이 아니다
개인적인 메모: 모나드를 처음 볼 때 가장 위험한 순간은 "아, 이제 알았다"라고 말하는 순간이다. 보통 그때부터 다시 모른다.
효과 시스템 (Effect System)
효과 시스템은 표현식이 낼 수 있는 효과를 타입과 함께 추적하는 장치로 모나드와 함께 쓸 수 있으며, 대수적 효과(algebraic effects)와 핸들러는 효과 연산의 선언과 그 해석을 분리한다. Eff, Koka, Unison 같은 언어가 이런 접근을 시도하고 있다.23
모나드: 계산을 이어 붙이는 인터페이스. IO는 여러 종류의 외부 동작을 담을 수 있다.
모나드 변환자: ReaderT, StateT, ExceptT 등을 쌓아 문맥을 조합한다. 순서에 따라 의미가 달라질 수 있다.
효과 시스템: 어떤 효과가 가능한지 타입 수준에서 추적한다.
대수적 효과와 핸들러: 효과 연산과 그 처리 방식을 분리한다.
함수형 프로그래밍 vs 객체지향 프로그래밍
두 패러다임은 같은 문제를 다른 축으로 분해한다.
특성 | 객체지향 | 함수형 |
|---|---|---|
상태 | 객체 내부에 캡슐화 | 불변, 함수 외부로 명시 |
다형성 | 서브타이핑 + 매개변수 다형성 | 매개변수 다형성 + 타입 클래스 |
재사용 | 상속, 합성, 위임 | 함수 합성, 고차 함수 |
시간 | 객체의 상태 변화 | 값의 변환 흐름 |
오류 처리 | 예외 + try/catch | Result/Either, 모나드 |
모듈성 | 클래스, 패키지 | 모듈, 함수, 타입 |
- 특성
상태
- 객체지향
객체 내부에 캡슐화
- 함수형
불변, 함수 외부로 명시
- 특성
다형성
- 객체지향
서브타이핑 + 매개변수 다형성
- 함수형
매개변수 다형성 + 타입 클래스
- 특성
재사용
- 객체지향
상속, 합성, 위임
- 함수형
함수 합성, 고차 함수
- 특성
시간
- 객체지향
객체의 상태 변화
- 함수형
값의 변환 흐름
- 특성
오류 처리
- 객체지향
예외 + try/catch
- 함수형
Result/Either, 모나드
- 특성
모듈성
- 객체지향
클래스, 패키지
- 함수형
모듈, 함수, 타입
같은 문제, 다른 분해:
"주문 상태를 추적하라"
객체지향: Order 객체가 status 필드를 가지고 메서드로 상태를 바꾼다
함수형: Order는 불변. 상태 전이는 새 Order를 만드는 함수 (Order -> Order)
두 접근은 양립 가능하다. 현대 언어 대부분은 두 패러다임을 함께 지원한다(Scala, Rust, C#, TypeScript).
순수성 스펙트럼
모든 함수형 언어가 같은 수준의 순수성을 강제하지 않는다.
[효과 분리 강제: 강함 (외부 I/O 기준)]
Haskell, Idris, Agda, Elm
- 일반적인 I/O는 IO·Cmd·Sub 같은 명시된 경계를 거친다.
[효과 분리 강제: 약함 (외부 I/O 기준)]
일반 함수에서 외부 I/O를 수행할 수 있다.
- ML 계열: Standard ML, OCaml, F#
- Lisp 계열: Clojure, Common Lisp, Scheme, Racket
- 다중 패러다임: Scala, Rust, Swift
- 명령형 기반 언어: C#, JavaScript/TypeScript, Python, Java
여기서 비교하는 것은 일반 코드와 표준 API가 순수 계산과 외부 I/O를 얼마나 강하게 분리하도록 하는가이며, 각 묶음 안의 순서를 우열로 읽을 필요는 없다.
평가 전략과 종료성 검사, 정적·동적 타입, 불변 자료구조 지원은 별도 특성이다. Haskell은 기본적으로 게으르게, ML 계열은 엄격하게 평가하며 ML은 가변 참조와 예외를 허용한다. Lisp 계열은 주로 동적 타입이고 가변성 정책이 서로 다르며, Clojure는 불변 자료구조가 기본이다. 다중 패러다임 언어는 함수 값·고차 함수·효과 통제 도구의 지원 범위가 다르고, 함수형 기법을 객체지향·명령형 코드와 함께 사용한다.
대표 기법
map / filter / fold
리스트 변환의 3대 기본 연산.
main :: IO ()
main = do
let xs = [1, 2, 3, 4] :: [Int]
print (map (* 2) xs)
print (filter (> 2) xs)
print (foldr (+) 0 xs)
명령형으로는 for 루프 + 누산기 + 조건문이 필요한 작업이 한 줄 표현으로 압축된다.
함수 합성과 파이프라인
문자열 목록에서 숫자로 읽을 수 있는 값만 골라 음수를 제외하고 두 배로 만드는 예제로, 파싱에 실패한 문자열은 mapMaybe readMaybe에서 버린다.
import Data.Maybe (mapMaybe)
import Text.Read (readMaybe)
-- Invalid strings are intentionally omitted; negative numbers are filtered out.
processData :: [String] -> [Int]
processData = map (* 2) . filter (>= 0) . mapMaybe readMaybe
main :: IO ()
main = print (processData ["3", "bad", "-1", "0"])
합성 연산자 (.)의 오른쪽부터 mapMaybe readMaybe, filter (>= 0), map (* 2)가 적용된다. 데이터가 어떻게 바뀌는지는 아래처럼 위에서 아래로 따라갈 수 있다.
// F#: 왼쪽에서 오른쪽 (|> 파이프 연산자)
let processData rawData =
rawData
|> List.map parse
|> List.filter isValid
|> List.map normalize
Point-free 스타일
입력 인자의 이름을 적지 않고 기존 함수들을 조합해 정의하는 스타일이다. 아래의 sum . map square도 xs를 직접 받는 대신, 입력 리스트에 map square를 적용한 결과를 sum에 넘기도록 두 함수를 잇는다.
square :: Int -> Int
square x = x * x
sumOfSquaresExplicit :: [Int] -> Int
sumOfSquaresExplicit xs = sum (map square xs)
sumOfSquaresPointFree :: [Int] -> Int
sumOfSquaresPointFree = sum . map square
main :: IO ()
main = print (sumOfSquaresExplicit [1, 2, 3], sumOfSquaresPointFree [1, 2, 3])
가독성이 좋아지는 영역에서만 써야 한다. 과도하면 안티패턴.
영속 자료구조 (Persistent Data Structure)
갱신할 때 기존 값을 그대로 두는 자료구조다. 이전 값을 가리키는 참조를 남겨 두면 새 값과 함께 쓸 수 있으며, 여기서 영속이라는 말은 변경 이력을 자동으로 전부 저장한다는 뜻과는 다르다. 구조 공유와 경로 복사는 이를 효율적으로 구현하는 흔한 방법인데, 비용은 연산마다 다르다. 연결 리스트 앞에 원소를 붙이는 (:)는 O(1), 뒤에 붙이는 (++)는 왼쪽 리스트 길이에 비례하고, 균형 트리 기반 Data.Map의 삽입은 O(log n)이다.24
대표 사례:
- Hash Array Mapped Trie (HAMT)
- Finger Tree
- Persistent Red-Black Tree
- Clojure의 PersistentVector / PersistentHashMap
- Haskell의 Data.Map (균형 이진 트리)
Chris Okasaki의 1998년 책 "Purely Functional Data Structures"가 이 분야의 표준 참고서다.25
불변성은 실제로 어떻게 구현되는가
많은 함수형 구현은 힙에 새 노드를 만들고, 기존 노드를 공유하는 식으로 동작한다. 이렇게 갱신해도 프로그램에서 관찰하는 기존 값은 그대로 남는다.
명령형 업데이트:
배열/객체의 같은 위치를 덮어쓴다.
함수형 업데이트:
바뀐 경로의 노드만 새로 만들고,
나머지 하위 구조는 기존 노드를 공유한다.
리스트의 구조 공유
Haskell 리스트의 cons cell 하나에는 원소와 나머지 리스트를 가리키는 참조가 들어 있다. 아래에서는 이 노드들이 이어지다가 빈 리스트 []에서 끝난다.
xs, ys :: [Int]
xs = [1, 2, 3]
ys = 0 : xs
main :: IO ()
main = print (xs, ys, tail ys == xs)
메모리 관점에서는 대략 이렇게 볼 수 있다.
ys를 만들 때 [1, 2, 3] 전체를 복사하는 대신, 값 0과 다음 노드의 참조를 담는 cons cell 하나를 새로 만든다. 위 그림의 [0]이 그 노드이고 tail은 xs가 가리키던 기존 리스트를 공유하니, 앞에 원소를 붙이는 (:)에는 새 노드 하나면 된다. 반대로 (++)로 뒤에 리스트를 붙일 때는 왼쪽 리스트를 따라가며 앞부분을 다시 만든다. 예제의 True는 두 리스트의 값이 같다는 비교 결과이며 메모리 주소를 비교한 값은 아니다.
트리와 맵의 구조 공유
균형 트리 기반 map/set도 비슷하다. 어떤 키 하나를 바꾸면 루트에서 해당 키까지의 경로만 새로 만들고, 건드리지 않은 서브트리는 공유한다.
기존 트리:
A
/ \
B C
/ \
D E
E만 바꾼 새 트리:
A'
/ \
B' C <- 공유
/ \
D E' <- D도 공유
그림에서 A는 기존 트리의 루트, A'는 E를 바꾼 새 트리의 루트다. A를 가리키는 참조를 남겨 두면 두 트리를 함께 쓸 수 있고, 새로 만드는 것은 바뀐 경로의 A', B', E'뿐이라서 C와 D는 두 트리가 공유한다.
스택과 힙 관점
아래는 흔한 구현을 그린 개념도다. 인라이닝이나 꼬리 호출로 호출 프레임을 없앨 수 있고 지역 값도 레지스터·스택·힙에 놓일 수 있으므로, 함수 호출 하나가 언제나 새 스택 프레임 하나를 만든다고 읽으면 곤란하다. 리스트와 트리 노드, 클로저, thunk는 보통 힙에 놓이지만 실제 배치는 컴파일러와 최적화 결과에 달려 있다.
스택:
- 함수 호출 프레임
- 짧은 수명의 지역 바인딩
- 평가 중인 임시 상태
힙:
- 리스트/트리/레코드 같은 자료구조 노드
- 클로저가 캡처한 환경
- Haskell의 지연 계산 thunk
- 공유되는 persistent data structure 노드
이런 구현은 힙 할당과 GC를 활용하고, 구조 공유와 컴파일러 최적화로 비용을 줄인다.
개인적인 메모: 불변성은 공짜 점심이 아니다. 다만 계산서를 "복사 전체"가 아니라 "바뀐 경로"에만 청구하는 기술이라고 한다. 나는 외상만 한가득이다.
Haskell의 thunk와 공간 누수
Haskell은 게으른 평가를 사용해 값이 필요할 때까지 계산을 미룰 수 있고, thunk는 바로 그 미룬 계산을 담아 둔다.
sumBad :: Integer
sumBad = foldl (+) 0 [1..1000000]
main :: IO ()
main = print sumBad
위 코드는 직관적으로는 누산기를 계속 더하는 것처럼 보이지만, 게으른 평가에서는 다음과 같은 계산 덩어리가 쌓일 수 있다.
((((0 + 1) + 2) + 3) + ...)
thunk 체인은 힙 사용량을 키울 수 있고, 누적된 계산을 강제하는 순간 스택 오버플로우로도 드러날 수 있다. 그래서 Haskell 성능을 볼 때는 "스택이냐 힙이냐"만 고르기보다 어떤 계산이 언제 평가되는지 확인해야 한다.
import Data.List (foldl')
sumGood :: Integer
sumGood = foldl' (+) 0 [1..1000000]
main :: IO ()
main = print sumGood
foldl'은 각 단계에서 누산기를 WHNF(weak head normal form), 즉 가장 바깥 형태를 알 수 있는 상태까지 평가한다. 위 예제처럼 Integer 덧셈을 누적할 때는 덧셈을 미룬 thunk가 길게 이어지는 것을 줄인다. 하지만 누산기가 튜플이면 튜플이라는 바깥 형태만 드러내고 내부 원소의 계산은 남겨 둘 수 있다. 내부 값도 매 단계 계산하려면 누산기 구조에 맞춰 엄격한 필드나 deepseq를 사용한다.26
실무 언어에서의 불변성
JavaScript/TypeScript, C#, Java에서도 복사나 불변 컬렉션으로 불변 업데이트를 구현하며, JavaScript/TypeScript에서는 객체·배열을 얕게 복사하거나 Immutable.js·Immer 같은 라이브러리를 활용한다. Clojure식 영속 컬렉션도 구현 선택지다.
// 얕은 복사 기반 불변 업데이트
const next = {
...prev,
status: "paid",
};
prev 자체는 그대로지만 중첩 객체의 참조까지 복사한 것은 아니어서, 공유한 객체를 바꾸면 이전 객체에서도 바뀐 내용이 보인다.
불변성 구현 방식:
- Haskell/Clojure: 언어/표준 자료구조 차원에서 구조 공유가 기본
- Scala/F#/OCaml: 불변 컬렉션과 가변 컬렉션을 선택
- JS/TS/React: 관례와 라이브러리로 불변 업데이트를 유지
- Rust: 소유권/빌림 규칙으로 aliasing과 mutation을 통제
언어별 함수형 예시
Haskell
-- This teaching example is not balanced: insertion is O(height).
data Tree a = Leaf | Node a (Tree a) (Tree a) deriving (Eq, Show)
insert :: Ord a => a -> Tree a -> Tree a
insert x Leaf = Node x Leaf Leaf
insert x (Node y left right)
| x < y = Node y (insert x left) right
| x > y = Node y left (insert x right)
| otherwise = Node y left right
toAscList :: Tree a -> [a]
toAscList Leaf = []
toAscList (Node x left right) = toAscList left ++ [x] ++ toAscList right
main :: IO ()
main = do
let oldTree = foldr insert Leaf [2, 1, 3] :: Tree Int
newTree = insert 4 oldTree
print (toAscList oldTree, toAscList newTree, insert 2 oldTree == oldTree)
OCaml
(* 옵션 타입과 패턴 매칭 *)
let rec find_first pred = function
| [] -> None
| x :: rest when pred x -> Some x
| _ :: rest -> find_first pred rest
F#
// 파이프라인 중심
let processOrders orders =
orders
|> List.filter (fun o -> o.Status = Active)
|> List.map (fun o -> { o with Total = computeTotal o })
|> List.sortByDescending (fun o -> o.Total)
Clojure
;; 데이터 변환 파이프라인
(->> orders
(filter active?)
(map compute-total)
(sort-by :total >))
Scala
// for-comprehension (모나드 추상)
val result = for {
user <- findUser(id)
account <- findAccount(user)
balance <- getBalance(account)
} yield balance
JavaScript / TypeScript
// 고차 함수와 합성
const processOrders = (orders: Order[]): Result[] =>
orders
.filter(o => o.status === "active")
.map(o => ({ ...o, total: computeTotal(o) }))
.sort((a, b) => b.total - a.total);
C#
// 전제: Order는 record이며 Total은 with 식으로 갱신 가능한 속성이다.
// 다른 도메인 선언과 orders, ComputeTotal은 이 발췌문 밖에서 정의한다.
// LINQ는 사실상 함수형 쿼리 언어
var result = orders
.Where(o => o.Status == OrderStatus.Active)
.Select(o => o with { Total = ComputeTotal(o) })
.OrderByDescending(o => o.Total)
.ToList();
Rust
// 전제: Order: Clone, Status는 비교 가능, compute_total(&Order)와 orders는 별도 정의.
// Iterator 체이닝 + 클로저
let result: Vec<_> = orders
.iter()
.filter(|o| o.status == Status::Active)
.map(|o| Order { total: compute_total(o), ..o.clone() })
.collect();
동시성과 분산
함수형 프로그래밍이 멀티코어 시대에 부활한 주된 이유는 불변성이 동시성 비용을 낮추기 때문이다.
가변 상태의 동시성 비용:
- 락(lock) 관리
- 경쟁 조건(race condition)
- 데드락
- 메모리 일관성 모델
불변 상태의 동시성 이득:
- 락이 필요 없다 (읽기 전용)
- 부수 효과가 명시되어 추론 가능
- 액터 모델, 메시지 패싱과 자연스럽게 결합
위의 '락이 필요 없다'는 같은 불변 값을 읽는 경우를 말한다. 공유 참조를 새 값으로 교체하는 작업에는 별도의 동기화가 필요하다. 대표 사례:
Erlang / Elixir: 액터 모델, 경량 프로세스, 고가용성 통신 시스템 사례로 유명
Akka (Scala/Java): 액터 기반 분산 시스템 프레임워크
Hadoop / Spark: MapReduce의 map/reduce 인터페이스는 함수형 언어에서 영향을 받았다. 분산 실행·재시도·저장은 별도의 런타임 책임이다.27
React + Redux: 단방향 데이터 흐름, 상태는 불변, 변경은 reducer 함수
Elm: 프론트엔드에서 순수 함수형 강제
흔한 오해와 정정
오해 1: "함수형 프로그래밍에는 가변성이 전혀 없다"
부정확. 순수 함수형 언어조차 부수 효과를 다루는 메커니즘을 갖는다(Haskell의 IO 모나드, ST 모나드). 다중 패러다임 함수형 언어(OCaml, F#, Scala)는 가변 참조를 명시적으로 허용한다. 함수형의 핵심은 "변경 금지"가 아니라 "기본은 불변, 변경은 명시적"이다.
오해 2: "함수형은 객체를 안 쓴다"
부정확. F#, OCaml, Scala는 모두 객체 시스템을 가진다. Haskell도 레코드와 타입 클래스로 객체와 유사한 추상을 만든다. 함수형은 OOP의 부정이 아니라 다른 우선순위의 패러다임이다.
오해 3: "재귀가 항상 반복보다 낫다"
부정확. JavaScript의 규격에 있는 proper tail call은 엔진 지원과 구분해야 하는데, JavaScriptCore가 엄격 모드에서 지원하더라도 엔진 전반에서 기대할 수 있는 기능은 아니다.28 CPython에서도 깊은 재귀를 반복문처럼 써서는 안 된다. 명확함이 같다면 실제 실행 환경이 자연스럽게 지원하는 형태를 따르는 게 옳다.
오해 4: "모나드는 카테고리 이론을 알아야 이해할 수 있다"
부정확. 모나드를 사용하기 전에 카테고리 이론부터 배울 필요는 없다. "계산 문맥 안의 값을 다음 계산으로 이어 붙인다"는 직관에서 시작하면 되는데, 박스 비유는 입문에 도움이 되더라도 IO처럼 실행할 동작을 나타내는 경우까지 설명하지는 못한다. 실제로는 연산의 타입과 모나드 법칙을 익혀야 한다.
개인적인 메모: 하지만 함수형 프로그래밍 커뮤니티 가서 이 소리 하면 발작 일으키니 주의할 것. 모든 프로그래밍 커뮤니티는 결과적으로 밈에 최적화되고 교조주의적으로 변한다.
오해 5: "함수형 프로그래밍은 산업에서 실용적이지 않다"
부정확. WhatsApp의 Erlang/FreeBSD 인프라, Jane Street의 OCaml, Meta/Facebook의 Haskell 기반 Sigma, Twitter의 Scala, Klarna의 Erlang처럼 공개된 산업 적용 사례가 있다. 각 출처는 서로 다른 시기의 사례를 설명하며, 모든 시스템의 현재 구성을 확인한 것은 아니다.2930313233 적어도 함수형 언어가 산업에서 전혀 쓰이지 않는다는 주장은 이 사례들과 맞지 않는다.
개인적인 메모: 오해라고 붙여놨지만 사실 이부분은 내 생각엔 오해가 아닌 거 같다. 함수형 프로그래밍을 할 줄 알면 연봉 앞자릿수가 달라진다해서 배웠지만, 달라지긴 했다. 그게 줄어드는 방향으로 감소했을 뿐이지.
함수형 안티패턴
1. map 안에서 부수 효과
이름을 기록하는 부수 효과만 필요하면서, map이 만든 새 배열은 쓰지 않는 경우다.
const items = ["Ada", "Grace"];
const sent = [];
items.map(name => { sent.push(name); });
console.log(sent.join(","));
이름을 기록하는 일만 필요하다면 forEach로 의도를 드러내면 된다. 비동기 작업은 for...of에서 하나씩 기다릴 수도 있고, map으로 만든 Promise 배열을 Promise.all에 넘겨 함께 기다릴 수도 있는데, 뒤의 경우에는 map이 만든 새 배열을 실제로 사용한다.
// 동기 부수 효과만 필요하면 forEach를 쓴다.
// 비동기 작업은 아래처럼 for...of 또는 Promise.all로 기다린다.
const items = ["Ada", "Grace"];
const sent = [];
function recordName(name) { sent.push(name); }
items.forEach(recordName);
// 실제 메일 전송 대신 결과 문자열을 반환하는 예제다.
async function sendEmail(name) {
return "sent: " + name;
}
async function sendSequentially() {
const results = [];
for (const item of items) {
results.push(await sendEmail(item));
}
return results;
}
async function sendConcurrently() {
return Promise.all(items.map(sendEmail));
}
async function main() {
console.log(sent.join(","));
console.log((await sendSequentially()).join(","));
console.log((await sendConcurrently()).join(","));
}
main().catch(error => { console.error(error); process.exitCode = 1; });
개인적인 메모: map을 보면 각 값을 새 값으로 바꿔 새 배열을 만든다고 읽는데, 콜백이 바깥 변수를 고치고 이메일까지 보내면 무슨 일을 하는지 콜백을 전부 열어 봐야 한다. 새 배열은 버리고 이런 일만 한다면 함수형이 된 것이 아니라 변환처럼 보이는 곳에 부수 효과를 숨겨 놓은 것이다.
2. 과도한 point-free
-- Valid Haskell, but unnecessarily difficult to read.
processAll :: ((a, b) -> c -> d) -> (a, b) -> (d -> e) -> c -> e
processAll = ((.) . (.)) (flip (.)) (uncurry . curry)
processAllReadable :: ((a, b) -> c -> d) -> (a, b) -> (d -> e) -> c -> e
processAllReadable f pair after x = after (f pair x)
main :: IO ()
main = do
let f (x, y) z = x + y + z :: Int
print (processAll f (1, 2) (* 2) 3, processAllReadable f (1, 2) (* 2) 3)
point-free는 가독성이 좋아질 때만 써야 한다.
개인적인 메모: 이 정도 point-free 코드는 동료에게 지식을 전달하는 게 아니라 암호문을 제출하는 쪽에 가깝다.
3. 조기 모나드 추상화
import Control.Monad.Trans.Class (lift)
import Control.Monad.Trans.Except (ExceptT, runExceptT, throwE)
import Control.Monad.Trans.Reader (ReaderT, ask, runReaderT)
import Control.Monad.Trans.State.Strict (StateT, get, modify', runStateT)
newtype Config = Config Int
newtype World = World Int deriving Show
data AppError = NegativeStep deriving Show
type App a = ReaderT Config (StateT World (ExceptT AppError IO)) a
advance :: App Int
advance = do
Config step <- ask
if step < 0
then lift (lift (throwE NegativeStep))
else do
lift (modify' (\(World n) -> World (n + step)))
World n <- lift get
pure n
runApp :: Int -> IO (Either AppError (Int, World))
runApp step = runExceptT (runStateT (runReaderT advance (Config step)) (World 0))
main :: IO ()
main = do
runApp 3 >>= print
runApp (-1) >>= print
세 단계 stacked 모나드는 거의 항상 과도하다. 처음에는 단일 IO 또는 단일 Either로 시작해서 필요할 때 추상화를 올리는 게 옳다.
4. 게으른 평가로 인한 공간 누수
Haskell의 고전적 함정.
import Data.List (foldl')
sumBad, sumGood :: Integer
sumBad = foldl (+) 0 [1..1000000]
sumGood = foldl' (+) 0 [1..1000000]
main :: IO ()
main = print (sumBad, sumGood)
foldl vs foldl'을 모르면 큰 리스트에서 메모리가 폭증한다. 이게 게으른 평가의 함정.
5. type class 계층을 OOP 클래스 계층처럼 사용
-- Anti-pattern: reproducing a deep taxonomy with type classes.
class Animal a where
sound :: a -> String
class Animal a => Mammal a where
warmBlooded :: a -> Bool
class Mammal a => Dog a where
fetch :: a -> String
data PetDog = PetDog
instance Animal PetDog where
sound _ = "woof"
instance Mammal PetDog where
warmBlooded _ = True
instance Dog PetDog where
fetch _ = "ball"
main :: IO ()
main = print (sound PetDog, warmBlooded PetDog, fetch PetDog)
타입 클래스는 OOP 상속 계층의 대체재가 아니다. 다른 도구.
6. 중간 리스트 누적
import Data.List (foldl')
-- Source-level stages; allocation depends on laziness and GHC list fusion.
resultPipeline :: [Int] -> Int
resultPipeline = sum . map (* 2) . filter even . map (+ 1)
resultFold :: [Int] -> Int
resultFold = foldl' step 0
where
step acc x = let y = x + 1
in if even y then acc + y * 2 else acc
main :: IO ()
main = print (resultPipeline [1..10], resultFold [1..10])
리스트 융합(list fusion)이 자동으로 최적화하는 경우가 많지만, 명시적으로 스트림이나 폴드로 통합하는 게 안전.
이어서 볼 것은 JavaScript와 TypeScript에서 map, filter, reduce를 쓸 때 생기는 실수다. 문법은 맞아서 리뷰에서도 놓치기 쉬우며, AI 도구가 작성한 코드를 볼 때도 같은 점을 살펴야 한다.
7. async 콜백을 map에 넘기고 기다리지 않기
async 콜백을 받은 map은 결과 값 대신 Promise 배열을 돌려준다. 이를 기다리지 않으면 저장이 끝나기 전에 다음 줄이 실행될 수 있고, 실패도 호출부가 기다리는 결과로 전달되지 않는다. forEach에 async 콜백을 넘겨도 forEach가 기다려 주지는 않는다.
const saved = [];
const save = async (id) => { await new Promise((r) => setTimeout(r, 10)); saved.push(id); return id; };
const ids = [1, 2, 3];
const results = ids.map(async (id) => save(id));
console.log(results); // [ Promise { <pending> }, Promise { <pending> }, Promise { <pending> } ]
console.log("saved:", saved.length); // saved: 0
Promise.all로 배열의 Promise를 함께 기다린다. 작업은 map의 콜백을 부를 때 이미 시작됐으니 입력이 아주 많으면 배치로 나누거나 동시 실행 수를 제한하고, 앞 작업이 끝난 뒤 다음 작업을 시작해야 한다면 for...of 안에서 await한다.
// saved, save and ids are the same as above.
const results = await Promise.all(ids.map((id) => save(id)));
console.log(results); // [ 1, 2, 3 ]
console.log("saved:", saved.length); // saved: 3
8. map 안에서 원래 객체를 변경하기
map이 새로 만드는 것은 배열이지 원소 객체까지는 아니다. 콜백이 받은 객체의 속성을 바꾸면 원래 배열의 객체도 바뀌며, 두 배열은 여전히 같은 객체들을 가리킨다.
const users = [{ name: "Ada", active: false }];
const activated = users.map((u) => { u.active = true; return u; });
console.log(users[0].active, activated[0] === users[0]); // true true
const users2 = [{ name: "Ada", active: false }];
const activated2 = users2.map((u) => ({ ...u, active: true }));
console.log(users2[0].active, activated2[0] === users2[0]); // false false
변경할 객체를 펼침 구문으로 새로 만들면 된다. 다만 한 단계만 복사하므로 중첩 객체를 바꿀 때는 그 단계도 새로 만들어야 한다.
9. map(parseInt)
map은 값과 함께 인덱스, 배열도 콜백에 넘긴다. parseInt는 두 번째 인자를 진법으로 읽어서 인덱스 1과 2가 진법 자리에 들어가 NaN이 나오는데, 여러 인자를 받는 함수를 그대로 넘길 때 생기는 문제다.
console.log(["1", "2", "3"].map(parseInt)); // [ 1, NaN, NaN ]
console.log(["1", "2", "3"].map((s) => Number.parseInt(s, 10))); // [ 1, 2, 3 ]
10. filter(Boolean)으로 빈 값 제거하기
null과 undefined만 빼려던 filter(Boolean)은 0과 빈 문자열, false도 버린다. 재고 0처럼 의미 있는 값이 아무 경고 없이 사라진다.
const stock = [0, 3, null, 5, undefined];
console.log(stock.filter(Boolean)); // [ 3, 5 ]
console.log(stock.filter((n) => n != null)); // [ 0, 3, 5 ]
n != null은 null과 undefined만 거른다. TypeScript에서는 (n): n is number => n != null처럼 타입 가드로 적으면 결과 배열도 number[]로 좁혀진다.
11. reduce마다 누산기를 통째로 복사하기
객체를 만드는 reduce에서 매번 { ...acc }로 복사하면 지금까지 쌓인 속성을 단계마다 다시 복사한다. 서로 다른 키가 계속 늘어나는 입력에서는 전체 작업량이 원소 수의 제곱에 비례해, 데이터가 커질수록 급격히 느려진다.
const users = [{ id: "a", name: "Ada" }, { id: "g", name: "Grace" }];
const byIdSlow = users.reduce((acc, u) => ({ ...acc, [u.id]: u }), {}); // copies everything at each step
const byId = Object.fromEntries(users.map((u) => [u.id, u])); // builds it once
console.log(Object.keys(byIdSlow), Object.keys(byId)); // [ 'a', 'g' ] [ 'a', 'g' ]
Object.fromEntries나 Map을 쓰거나, reduce에서 누산기 객체 하나에 값을 추가하면 된다. 내부에서 만든 누산기를 밖에서 관찰하지 않는다면 이 지역적인 변경은 함수형 원칙과 충돌하지 않는다.
12. 체인 중간의 sort가 원본을 바꾸기
sort와 reverse는 새 배열을 돌려줄 것처럼 보이지만 원래 배열을 바꾸고 그 배열을 반환한다. map이나 filter와 섞여 있으면 원본 변경을 놓치기 쉽다.
const scores = [40, 90, 70];
const top = scores.sort((a, b) => b - a).slice(0, 2);
console.log(top, scores); // [ 90, 70 ] [ 90, 70, 40 ]
const scores2 = [40, 90, 70];
const top2 = scores2.toSorted((a, b) => b - a).slice(0, 2);
console.log(top2, scores2); // [ 90, 70 ] [ 40, 90, 70 ]
ES2023의 toSorted, toReversed, toSpliced는 복사본을 돌려주며 Node.js 20 이상에서 쓸 수 있다. 이전 환경에서는 [...scores].sort(...)처럼 먼저 복사한다.
함수형 프로그래밍의 비판
학습 곡선
monad, functor, applicative 같은 수학적 어휘와 추상적 사고가 진입 장벽을 높여, 명령형이나 객체지향에 익숙한 개발자도 "다시 배우는" 과정을 거친다.
I/O 모델의 복잡성
모나드 변환자(monad transformer)는 효과를 조합하는 강력한 도구지만 학습 비용이 크다.
메모리 할당 비용
불변성은 새 객체 할당을 빈번하게 발생시킨다. 영속 자료구조와 컴파일러 최적화로 완화되지만, 지연 시간에 민감한(latency-critical) 시스템에서는 여전히 부담이 된다.
가독성 논쟁
point-free, 모나드 do-notation, 타입 클래스 등은 익숙해지면 강력하지만 초심자에게는 암호처럼 보이고, 익숙하지 않으면 코드 리뷰에 더 많은 시간이 들 수 있다.
왜 지금 중요한가
2010년대 이후 함수형 프로그래밍이 다시 주목받는 데는 다음 이유가 있다.
- 멀티코어 시대: 가변 상태 동시성 비용이 커짐
- 분산 시스템: 불변성과 메시지 패싱이 자연스러움
- 데이터 파이프라인: map/reduce 인터페이스는 함수형 언어의 영향을 받음
- 프론트엔드 상태 관리: React/Redux의 단방향 흐름
- 타입 시스템 발전: TypeScript, Rust가 ML 계열 영향을 흡수John Hughes의 "Why Functional Programming Matters"는 함수형 프로그래밍의 핵심 가치를 고차 함수와 게으른 평가가 제공하는 모듈화 능력으로 설명한 고전 논문이다.34 Paul Hudak의 survey는 람다 계산법, Lisp, ISWIM, FP, ML, Miranda, Haskell로 이어지는 함수형 언어의 역사와 기술적 특징을 정리한 대표적 개관이다.35
오늘날 함수형 프로그래머가 된다는 건 Haskell 전업보다, 쓰는 언어에서 함수형 사고를 활용한다는 뜻에 가깝다.
학습 경로
함수형 사고방식 입문은 언어 선택보다 사고 전환이 더 중요하다.36
1. 익숙한 언어에서 시작
- JavaScript의 map/filter/reduce
- Python의 list comprehension, functools
- C#의 LINQ
- 가변성을 줄이고 함수 합성을 의식적으로 사용
2. 다중 패러다임 함수형 언어로 확장
- F#, OCaml, Scala 중 하나
- 타입 시스템과 패턴 매칭에 익숙해지기
3. 순수 함수형 도전
- Haskell 또는 Elm
- Haskell을 선택하면 모나드, 타입 클래스, 게으른 평가 학습
4. 이론적 기반 보강
- 람다 계산법
- 타입 이론 입문 (Pierce "Types and Programming Languages")
- 카테고리 이론 (선택사항)
핵심 질문:
이 문제를 데이터 변환의 흐름으로 표현할 수 있는가?
이 상태 변경을 새 값 생성으로 바꿀 수 있는가?
이 부수 효과를 타입으로 명시할 수 있는가?
이 반복을 고차 함수로 표현할 수 있는가?
요약
함수형 프로그래밍은 1930년대 람다 계산법에 뿌리를 두고, Lisp(1958), ML(1973), Haskell(1990)을 거쳐 현대로 이어진 패러다임이다. 핵심은 다음 다섯 가지다.
1. 함수는 일급 시민이다
2. 함수는 수학적 함수에 가깝다 (순수성)
3. 자료는 불변이다
4. 부수 효과는 명시된다
5. 추상화 단위는 고차 함수와 함수 합성이다
함수형 프로그래밍은 객체지향의 대체재가 아니라 짝이다. 멀티코어와 분산 시스템 환경에서 불변성과 순수 계산의 가치가 커졌고, 주요 기법들은 현대 주류 언어에도 폭넓게 흡수되어 있다. "함수형 프로그래머"는 특정 언어 사용자가 아니라 함수형 사고방식을 활용할 줄 아는 개발자에 가깝다.
같이 보기
프로그래밍 패러다임
디자인 패턴
람다 계산법
모나드
타입 시스템
대수적 자료형
Result 타입
Option 타입
영속 자료구조
참조 투명성
고차 함수
함수 합성
게으른 평가
꼬리 호출 최적화
Hindley-Milner 타입 시스템
액터 모델
참고문헌
Hughes, John (1989). "Why Functional Programming Matters". The Computer Journal. 32 (2): 98–107.
Hudak, Paul (1989). "Conception, Evolution, and Application of Functional Programming Languages". ACM Computing Surveys. 21 (3): 359–411.
Moggi, Eugenio (1991). "Notions of computation and monads". Information and Computation. 93 (1): 55–92.
Pierce, Benjamin C. (2002). Types and Programming Languages. MIT Press.
외부 링크
공식 문서/언어 사이트
핵심 논문/역사 자료
개관
분류: 프로그래밍 | 프로그래밍 패러다임 | 프로그래밍 언어 | 소프트웨어 공학 | WIKI
각주
- Turing (1936), appendix: equivalence of formal models ↩
- Haskell 2010 Report ↩
- McCarthy, John (1960). "Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I". Communications of the ACM. 3 (4): 184–195. ↩
- Landin, Peter J. (1966). "The Next 700 Programming Languages". Communications of the ACM. 9 (3): 157–166. ↩
- Landin (1966), experimental prototype, p. 160 ↩
- Backus, John (1978). "Can Programming Be Liberated from the von Neumann Style? A Functional Style and Its Algebra of Programs". Communications of the ACM. 21 (8): 613–641. doi:10.1145/359576.359579. ↩
- Milner, Robin; Tofte, Mads; Harper, Robert; MacQueen, David (1997). *The Definition of Standard ML (Revised)*. MIT Press. ML의 역사적 배경은 LCF 정리 증명기와 연결된다. ↩
- MacQueen, Harper and Reppy, The History of Standard ML ↩
- Turner, David. The Miranda Programming Language. Miranda는 Research Software Ltd.가 상업 지원한 lazy/pure functional language로 Haskell에 직접 영향을 주었다. ↩
- Hudak, Paul; Hughes, John; Peyton Jones, Simon; Wadler, Philip (2007). "A History of Haskell: Being Lazy With Class". HOPL III. ↩
- Changes from Haskell 1.2 to Haskell 1.3 ↩
- Virding, Erlang design and the actor model (2012) ↩
- Odersky, 10 Years of Scala (2014) ↩
- Scala 2.12 specification, historical preface ↩
- GHC User's Guide. "Bang patterns and Strict Haskell". GHC는 lazy evaluation이 기본이고, 성능이 중요한 코드에서는 thunk 제거와 strictness 제어가 중요하다고 설명한다. ↩
- Haskell 2010 Report, expressions and pattern matching ↩
- Wadler, Philip; Blott, Stephen (1989). "How to Make Ad-Hoc Polymorphism Less Ad Hoc". POPL '89: Proceedings of the 16th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages. pp. 60–76. doi:10.1145/75277.75283. ↩
- Wadler, Philip (1995). "Monads for functional programming". Advanced Functional Programming. Lecture Notes in Computer Science. Vol. 925. pp. 24–52. doi:10.1007/3-540-59451-5_2. Moggi의 이론적 출발점은 "Notions of Computation and Monads"도 함께 봐야 한다. ↩
- Moggi, Eugenio (1991). "Notions of computation and monads". Information and Computation. 93 (1): 55–92. doi:10.1016/0890-5401(91)90052-4. ↩
- Moggi, author publication list (1988, 1989, 1991) ↩
- Haskell 2010 Language Report, §7.2 Sequencing I/O Operations. IO 동작의 결과를 다음 IO 동작으로 전달하는 >>=와 do 표기. ↩
- Haskell 2010 Report ↩
- Koka book, effect types and handlers ↩
- containers, Data.Map.Strict operation complexities ↩
- Okasaki, Chris (1998). *Purely Functional Data Structures*. Cambridge University Press. ISBN 0-521-66350-4. ↩
- base 4.18.3.0, Data.Foldable (also in verified GHC bindist) ↩
- Dean and Ghemawat (2004), MapReduce ↩
- WebKit, ECMAScript 6 Proper Tail Calls ↩
- Reed, Rick. "That's 'Billion' with a 'B': Scaling to the Next Level at WhatsApp". InfoQ / Erlang Factory SF Bay, 2014. WhatsApp의 Erlang/FreeBSD 기반 확장 사례. ↩
- Jane Street. "Technology at Jane Street". Jane Street는 가능한 많은 시스템을 OCaml로 작성한다고 설명한다. ↩
- Meta Engineering. "Fighting spam with Haskell". Facebook/Meta의 Sigma rule engine Haskell 적용 사례. ↩
- Twitter. "Effective Scala". Twitter의 Scala 사용과 함수형/표현식 중심 스타일에 대한 내부 가이드. ↩
- Erlang Solutions. "Klarna case study". Klarna의 Erlang 기반 고가용성 결제 시스템 사례. ↩
- Hughes, John (1989). "Why Functional Programming Matters". The Computer Journal. 32 (2): 98–107. doi:10.1093/comjnl/32.2.98. 저자 공개본: Chalmers mirror. ↩
- Hudak, Paul (1989). "Conception, Evolution, and Application of Functional Programming Languages". ACM Computing Surveys. 21 (3): 359–411. doi:10.1145/72551.72554. ↩
- Pierce, Benjamin C. (2002). *Types and Programming Languages*. MIT Press. ISBN 978-0-262-16209-8. ↩