OOP + FP - 객제지향과 함수형 적절히 사용하기
03 Jul 2019 |
절차지향 -> 객체지향
절차지향은 순차적인 처리로 프로그램을 구성하는 방식이다. 컴퓨터의 처리구조와 유사해서 실행속도가 빠르다. 일을 처리하는 순서대로 프로그램이 진행된다.
절차지향에서 “데이터와 처리함수를 함께 묶을 수 없을까?”, “어떻게 하면 프로그램을 구조적으로 나눌 수 있을까?” 라는 질문에서 출발한게 객체지향이다. 절차지향에서는 변수는 서브루틴(함수)와 연결되어있지 않다. 따라서 관련된 함수여도 변수는 다른 곳에서 선언된다. 절차지향은 처리속도가 빠르지만, 모듈을 재활용하기는 힘들다.
반면에 객체지향에서는 데이터와 관련된 함수를 하나로 묶어 객체가 된다. 이 객체는 상태값을 가지고 그 상태값에 따라 다르게 행동한다. 클래스 단위로 데이터와 처리 메소드가 같이 묶여있으므로 모듈을 재활용하기에도 용이하다.
객체지향 -> 함수 중심
객체 지향에서는 상태값이 존재한다. 이 상태값에 따라 다른 행동을 취한다. 따라서 런타임에 상태값의 변화에 따른 동작을 예측할 수 없다. 이를 side effect라고 한다.
이런 불편함을 해결하기 위해 immutable 불변의 속성을 가진 순수함수를 연결해서 프로그램을 구성하는 방식이 함수형, 함수 중심 프로그래밍이다. 객체 지향에서는 상태에 따라 동작이 달라지므로 복잡도가 증가한다. 이 복잡도를 줄이기 위해 함수 중심 프로그래밍이 주목받고 있다.
OOP + FP
Swift 를 포함한 최근 등장한 언어들은 대부분 객체지향과 함수형의 특성을 모두 갖고있다. Kotlin Rust, Ruby, Scala 등 여러 언어가 객체지향과 함수형 컨셉을 모두 구현하고 있다.
OOP 혹은 FP 어느 한쪽이 더 좋은 방법이라는 절대적이고 명확한 정답은 없다. 그저 서로의 단점을 보완하기 위해, 그리고 경우에 따라 더 적절하게 판단할 수 있다는 것 뿐이다.
oop , fp 전혀 다른게 아니며, 완전 정반대의 개념이 아니다. 문제를 해결하는 방식의 차이이며, 적절한 것을 사용하는게 중요하다.
고려 해볼 것들
- 객체 생성 - 불변(immutable) 객체 만들기
- 상태의 변화 없이 복사본을 생성하기
- 객체의 메소드를 순수함수처럼 상태의 변화가 없도록 만들기
- 참조 투명성 - reference 가 없어야 한다.
- 함수를 리턴타입, 매개변수로 쓰이는데 익숙해져야한다.
- 타입 기반 개발 - 타입이 필요한건지, 타입에 관련된 함수가 필요한건지 생각해본다
- 함수가 필요하면 struct, class 를 확장
- 타입만 필요하면 typealias를 사용
- 재귀호출 : depth 가 어디까지 인지 명확하지 않은 경우에 주로 사용한다
- exit 이 확실하면 재귀호출 사용이 적절할 수 있다
- 하지만 메모리 사용을 고려해야 된다. 모바일은 특히 메모리 고려해야 됨
- 구조체 vs. 클래스
- 추상화 <——> 구체화
- 프로토콜 ↔️ 클래스 ↔️ 객체
- Lazy evaluation : Swift 의
lazykeyword- 미리 계산하지 않고 나중에 해야 이점이 있는 경우
- 특히 배열관련
Example : fizzbuzz
1~100 에 대해 다음을 출력한다.
- fizz : 3로 나누어 떨어지는 경우
- buzz : 5로 나누어 떨어지는 경우
- fizzbuzz : 3, 5 로 모두 나누어 떨어지는 경우
- 모두 해당 안되는 경우 그냥 그 수 출력
FP 로 변하는 과정
1️⃣
func fizzbuzz() {
for index in 1...100 {
let isFizz = index % 3 == 0
let isBuzz = index % 5 == 0
switch (isFizz, isBuzz) {
case (true, true):
print("fizzbuzz")
case (true, _):
print("fizz")
case (_, true):
print("buzz")
default:
print("\(index)")
}
}
}
2️⃣ foreach() 와 closure 사용 (avoid side effect)
func fizzbuzzEach() {
(1...100).forEach { index in
let isFizz = index % 3 == 0
let isBuzz = index % 5 == 0
switch (isFizz, isBuzz) {
case (true, true):
print("fizzbuzz")
case (true, _):
print("fizz")
case (_, true):
print("buzz")
default:
print("\(index)")
}
}
}
3️⃣ fizz와 buzz 에 해당할 경우 출력 문자열을 반환하는 함수를 변수에 넣어 사용하기
func fizzbuzzClosure() {
let fizz: (Int) -> String = { index in index % 3 == 0 ? "fizz" : ""}
let buzz: (Int) -> String = { index in index % 5 == 0 ? "buzz" : ""}
(1...100).forEach { index in
let result = fizz(index) + buzz(index)
let output = result.isEmpty? "\(index)" : result
print(output)
}
}
4️⃣ 출력도 함수로 선언해서 사용하자 (Declarative)
func fizzbuzzDeclarative() {
let fizz: (Int) -> String = { index in index % 3 == 0 ? "fizz" : ""}
let buzz: (Int) -> String = { index in index % 5 == 0 ? "buzz" : ""}
let fizzbuzz: (Int) -> String = { index in
{ result in result.isEmpty? "\(index)" : result } (fizz(index) + buzz(index))
}
// index 에 Int 타입 값을 넣으면 {result in ~} 함수에 (fizz(index) + buzz(index)) 값을 넣어 실행한 결과를 반환한다
let output: (String) -> () = { print($0) }
(1...100).map(fizzbuzz).forEach(output)
}
index -> ((result -> result.isEmpty? "\(index)" : result)(fizz(index) + buzz(index)))
5️⃣ Type Inference 타입 추론 사용 ($0 사용하기)
func fizzbuzzTypeInference() {
let fizz = { index % 3 == 0 ? "fizz" : ""}
let buzz = { index % 5 == 0 ? "buzz" : ""}
let fizzbuzz = { index in
{ $0.isEmpty? "\(index)" : $0 } (fizz(index) + buzz(index))
}
let output: (String) -> () = { print($0) }
(1...100).map(fizzbuzz).forEach(output)
}
6️⃣ Monad : context 안의 content를 가공해서 같은 type의 context에 넣어 반환해줌
func + (_ s1: String?, _ s2: String?) -> (String?) {
if s1 == nil, s2 == nil { return nil }
if s1 != nil, s2 == nil { return s1 }
if s1 == nil, s2 != nil { return s2 }
return s1! + s2!
}
func fizzbuzzMonad() {
let fizz = { index % 3 == 0 ? "fizz" : nil}
let buzz = { index % 5 == 0 ? "buzz" : nil}
let fizzbuzz = { index in fizz(index) + buzz(index) ?? String(index)}
let output = { print($0) }
(1...100).map(fizzbuzz).forEach(100)
}
7️⃣ Iterate
func fizzbuzzIterate() {
func iterate<A>(_ arr: [A], _ f: ((A) -> ())) {
arr.forEach( { f($0) } )
}
let fizz = { index % 3 == 0 ? "fizz" : nil}
let buzz = { index % 5 == 0 ? "buzz" : nil}
let fizzbuzz = { index in fizz(index) + buzz(index) ?? String(index)}
let output = { print($0) }
iterate(Array(1...100)) { index in output(fizzbuzz(index)) }
}
8️⃣ 연산 순서대로 할 수 있게 하기 (➡️ 이방향으로) : //custom operator 정의하기
// 우선순위 그룹 정의
precedencegroup ForwardPipe {
associativity: left
higherThan: LogicalConjunctionPrecedence
}
// 중위 연산자 정의
infix operator |> : ForwardPipe
// rhs(lhs(result)) 를 lhs |> rhs 순서로 명시할 수 있게 해줌
public func |> <A, B, C>(lhs: @escaping (A) -> B, rhs: @escaping (B) -> C) -> (A) -> B {
return { result in rhs(lhs(result)) }
}
func fizzbuzzPipe() {
func iterate<A>(_ arr: [A], _ f: ((A) -> ())) {
arr.forEach( { f($0) } )
}
let fizz = { index % 3 == 0 ? "fizz" : nil}
let buzz = { index % 5 == 0 ? "buzz" : nil}
let fizzbuzz = { index in fizz(index) + buzz(index) ?? String(index)}
let output = { print($0) }
iterate(Array(1...100), fizzbuzz |> output )
// 앞에서는 output(fizzbuzz(index)) 였음
}
Reference