🥚

Recent Notes

See 20 more →

Functor & Monad

8 min read

함수형 프로그래밍을 공부하다보면 벽을 한번 마주한다. Functor와 Monad가 그것이다. 이걸 이해하기 위해서 위키피디아에서 집합론?, 범주론? 이런 걸 읽었던 적이 있는 것 같은데 여전히 잘 모르겠다. 이번에는 와닿는 방식으로 이해하는 것을 목표로 한다.

Functor

  • optional의 map
    • 값이 있으면 실행, 없으면 말아
  • Collection의 map
    • 값을 하나씩 가지고와서 매핑해라
  • Dictionary의 map
    • 각 딕셔너리의 key, value를 tuple로 들고와서 매핑해라
  • function의 map
    • Composition 해라
  • map을 이용한 transform을 지원하는, value를 가지는 context
  • Context + value + transform(map) = Functor
    • context
      • 어떤 value가 처해있는 상태
      • Collection, Optional 등 다른 값을 가지는 Container
      • 포함하는 value가 generic으로 표현되어야 함
    • value
      • Context에 넣어지는 실제 내용
      • Context가 generic으로 표현되기 대문에, 어떤 type의 value도 사용이 가능하다.
    • Transform
      • 어떤 값 T를 U로 변환해주는 function
      • T와 U는 같은 Type이어도 괜찮음
      • 실패할 가능성이 없는 경우를 말함
        • 실패할 가능성이 있는 경우는 flatMap이 나음
  • Context에 싸여있는 Value에 function을 적용하기 위해 사용
    • Optional
      • Box로 이해하기
      enum Optional<Wrapped> {
    case some(Wrapped)
    case none
}
      • 이런 Optional(Context)에다가 연산을 수행하기 위해서는 guard, if와 같이 Optional Unwrapping을 해주어야 함
    • Map을 사용하면, Optional Unwrapping이 없이 같은 타입으로 변환이 가능함 
      Optional(2).map { (v: Int) -> Int in
    return v + 3
}
      • 5를 리턴했으나, map의 결과는 Optional(5)
    • 동작 이해하기
      • Value가 있는 경우
        • Optional(2) -> Context로 부터 Unwrapping -> 2 -> 함수 적용(+3) -> 5 -> Context에 Rewrapping -> Optional(5)
      • Value가 없는 경우
        • nil -> 값 없음 확인 -> 함수 적용하지 않음 -> 그대로 리턴(nil)
  • Chaining
    • Optional Chaining
      • let result = a?.b?.c?.d?.e
    • Map Chaining
      • let result = a.map { $0 }.map { $0 }.map { $0 }.map { $0 }
      • 이게 가능한 이유는 Context가 안바뀌기 때문(Box)
      • 의미
        • Value가 없는 예외 상황에 대한 처리를 주 logic에서 제거하여 따로 처리 가능
        • Step을 명확하게 볼 수 있음
        • 평소에 Code를 작은 단위의 함수로 분리해야 적용 가능
        • 간결해지고 가독성이 높아짐
  • Function에 map 함수를 사용할 수 있을까?
    • 즉, Function역시 Context인가?
    • Function에 map을 사용한다는 것은 Function을 composition 한다는 의미 
      func map<A, B, C>(f: @escaping (B) -> C, g: @escaping: (A) -> B) -> (A) -> C {
    return { x in
        f(g(x))
    }
}
      • A -> B 함수와 B -> C 함수를 합성해서 A -> C 함수를 만들어라
  • Result Functor 
    enum Result<T> {
    case value(T)
    case error(Error)
 
    func map<U>(_ transform: (T) -> U) -> Result<U> {
        switch self {
            case .value(let value):
              let transformed = transform(value)
              return Result<U>.value(transformed)
            case .error(let error):
              return Result<U>.error(error)  
        }
    }
}
    • Optional은 값이 있거나 없거나
    • 하지만 실패하는 경우를 알아보기 위해서 Optional만을 사용하는 것은 정보를 많이 제공하지 못한다.
    • 그런데 case만 가지고 있는 자료구조인 경우, 실제 사용할 때, switch 문을 통해서 계속 판단해줘야 한다. 지저분 하다.
      • switch 문을 실제 로직에서 사용하고 싶지 않았음
    • 그래서 내부에 map 함수를 도입해서(리턴값을 보면 context가 유지되기 때문에 map이 맞다) 간결하게 해결하고자 함
    • 활용 
      func f(string: String) -> Result<Int> {
    guard let integer=  Int(string) else {
        return Result<Int>.error(MyError.notANumber)
    }
    return Result<Int>.value(integer)
}
 
func transform10(value: Int) -> Int {
    return value * 10
}
 
let result = f(string: "1234").map(transform10(value:))

Monad

  • flatMap을 이용한 transform을 지원하는 value를 가지는 context
  • Context + value + flatMap transform = Monad
    • map은 Context를 유지함
    • transform의 결과에 상관없이 박스안에 다시 넣음(Context)
    • 그래서 위에 설명시, 모두 변환이 가능한 경우에 사용하라 했던 것임
      • 사상이 같은 집합내에서 완전하게 이뤄지는 것을 바람
    • 만약 그렇지 않은 경우 (transform의 결과가 nil이라면)에는 transform의 결과인 nil을 다시 상자에 넣는(Context) 상황이 초래됨
      • 즉, transform의 output이 Optional인 상황을 말함
      • Optional(nil), Optional(Optional(3))
    • 이런 경우는 보통 바라지 않는 상황일 것임
      • nil, Optional(3)을 원함
    • 이 경우, map의 연산을 하되, nil인 경우를 제외하는 flatten의 역할이 필요함
    • 이 두 역할을 수행하는 것이 flatMap임
  • Monad 활용
    • 서버로 부터 받은 Data가 다음과 같다고 하자
      • { "age": 3, "name": "kim" }
    • JSON Parser 후, Struct로 변환 
      struct Person {
    var name: String
    var age: Int
}
    • 기존 코드 
      struct Person {
    var name: String
    var age: Int
}
 
func convertor(data: Data?) -> Person? {
    guard let unwrappedData = data,
        let json = try? JSONSerialization.jsonObject(with: unwrappedData, options: []),
        let dict = json as? [String: AnyObject],
        let name = dict["name"] as? String,
        let age = dict["age"] as? Int else { return nil }
    
    return Person(name: name, age: age)
}
    • 변경된 코드 
      struct Person {
    var name: String
    var age: Int
    
    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
    
    init?(dict: [String: AnyObject]) {
        guard let age = dict["age"] as? Int,
            let name = dict["name"] as? String else {
                return nil
            }
        self.init(name: name, age: age)
    }
}
 
func parser(data: Data) -> [String: AnyObject]? {
    let json = try? JSONSerialization.jsonObject(with: data, options: [])
    return (json as? [String: AnyObject])
}
 
func convertor2(data: Data?) -> Person? {
    return data.flatMap({ parser(data: $0) })
                .flatMap({ Person(dict: $0) })
}
 
func convertor3(data: Data?) -> Person? {
    return data.flatMap(parser(data:))
                .flatMap(Person.init(dict:))
}
      • 너무나 간결해졌다.
    • 결론
      • 작업 순서
        • 명확한 작업 단위의 function으로 분리한다.
        • Data의 Mapping을 map, flatMap의 Chaining으로 처리
        • 결과에 대한 판단은 최종적으로 transform된 내용을 본다.
      • 장점
        • 각 단위 function이 명확해지고 Test하기 용이해짐
        • 본연의 로직이 명확하게 드러남
        • 반복적으로 나온 예외처리 코드들이 사라짐

Graph