🥚

Recent Notes

See 20 more →

Either & Result

6 min read

순수 함수형 프로그래밍언어 Haskell에는 Either라는 자료구조가 있다. 둘 중 하나의 타입을 가질 수 있는 경우 사용하는 자료구조라 한다. 이 Either 자료구조에 영감을 얻어 태어난 것이 Swift의 Result라 한다. 이번 글에서는 Either와 Result의 개념을 알아보고, 실제 사용할 때, 어떠한 식으로 변형하여 사용할 수 있는지 알아보자. 어떻게 보면 난해할 수 있으니 마음을 단단히 먹고 읽어보자.

Maybe / Optional

  • Value의 부재 가능성을 표현
  • functor이자 Nomad
  • map, flatmap 사용가능
    • value가 부재 상태로 변할 가능성이 없는 transform (nil 리턴 없음)의 경우 map 사용
    • value가 부재 상태로 변할 가능성이 있는 transform (nil 리턴)의 경우 flatMap 사용

Either

  • 어떤 Value가 두가지의 type을 가질 수 있는 경우 표현
  • value가 A or B
  • 통상 right/left로 표현
enum Either<L, R> {
    case left(L)
    case right(R)
}
 
var either: Either<String, Int> = .right(3)
 
switch either {
    case .left(let l):
      print(l)
    case .right(let r):
      print(r)
}
  • 정리
    • 하나의 변수
    • String을 저장하거나 (left)
    • Int를 저장하거나 (right)
    • 하나의 변수에 다른 두가지 type을 정의하여 사용
  • 사용 경우
    • function이 상황에 따라 다른 두가지 type의 return value를 가지는 경우
    • 대표적으로 정상적인 처리 결과이거나 Error
      • Optional로 사용하는 경우, 어떤 Error인지 명시할 방법이 없음
    • Swift의 Result가 사용예

Result

  • Either에서 정상/Error로 제한을 걸어 사용하는 자료ㅕ구조
enum Result<T> {
    case success(T)
    case failure(Error)
}
  • Struct로 한다면?
struct Result<T> {
    var success: T?
    var failure: Error?
}
  • 성공 혹은 실패여야 하나, property로 갖고 있기 때문에 둘다 값이 있거나, 없는 경우를 배제할 수 없음
  • Functor로 개선하기 
        enum Result<T> {
        case success(T)
        case faliure(Error)
        
        func map<U>(_ transform: (T) throws -> U) rethrows -> Result<U> {
            switch self {
            case .success(let t):
                return Result<U>.success(try transform(t))
            case .faliure(let error):
                return Result<U>.faliure(error)
            }
        }
    }
    • rethrows
      • 에러를 리턴할 수 있는 함수를 매개변수로 받은 함수(이 경우에서는 map)가 다시 해당 에러를 바깥으로 뱉고 싶을 때 사용
      • 참고
    • map의 transform 함수는 return value가 Optional이 아닌 녀석이 와야하여 U로 리턴되는 것을 볼 수 있음
  • Monad로 개선하기 
    enum Result<T> {
    case success(T)
    case failure(Error)
    
    static func flatten<T>(_ result: Result<Result<T>>) -> Result<T> {
        switch result {
        case .success(let t): // 성공하면 T 타입(여기서 T타입은 Result<T>로 대응됨
            return t
        case .failure(let e): // 성공이 아닌 경우는 무조건 Error Type임!!
            return Result<T>.failure(e)
        }
    }
    
    func map<U>(_ transform: (T) throws -> U) rethrows -> Result<U> {
        switch self {
        case .success(let t):
            return Result<U>.success(try transform(t))
        case .failure(let error):
            return Result<U>.failure(error)
        }
    }
    
    func flatMap<U>(_ transform: (T) throws -> Result<U>) rethrows -> Result<U> {
        switch self {
        case .success:
            let transformed = try self.map(transform) // Result<Result<U>>: map은 transform이 완전 타입으로 리턴된다고 가정하고 Box를 한번 더 씌움
            return Result.flatten(transformed) // flatten 작업을 해줌
        case .faliure(let e):
            return Result<U>.failure(e)
        }
    }
}
    • 헷갈리면 위의 코드를 실제로 쳐보면 알 수 있음
  • Result의 활용 
    struct Person {
    var name: String
    var age: Int
    
    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
    
    init?(dict: [String: Any]) {
        guard let age = dict["age"] as? Int,
            let name = dict["name"] as? String else {
                return nil
            }
        self.init(name: name, age: age)
    }
}
 
enum MyError: Error {
    case parseError
    case initializeError
}
 
func convertor4(data: Result<Data>) -> Result<Person> {
    let result = data.flatMap { (data: Data) -> Result<[String: Any]> in
        guard let json = (try? JSONSerialization.jsonObject(with: data, options: [])) as? [String: Any] else {
            return Result.failure(MyError.parseError)
        }
        
        return Result.success(json)
    }
    .flatMap { (dict: [String: Any]) -> Result<Person> in
        guard let result = Person(dict: dict) else {
            return Result.failure(MyError.initializeError)
        }
        return Result.success(result)
    }
    
    return result
}
    • 뭔가 좋게 만들고자 만들었는데, convertor 코드가 상당히 복잡하다.
    • Error를 처리하는데 있어 flatMap이 뭔가 부족하다.
  • Custom transform function 추가하기
    • Error를 처리하는 map
    • Error Handling 추가
    enum Result<T> {
    // ...
    
    func errorMap<U>(_ transform: (T) throws -> U) -> Result<U> {
        do {
            return try self.map(transform)
        } catch let e {
            return Result<U>.failure(e)
        }
    }
}
 
func convertor5(data: Result<Data>) -> Result<Person> {
    let result = data.errorMap { try JSONSerialization.jsonObject(with: $0, options: []) }
        .errorMap{ try ($0 as? [String: Any]).unwrap(errorIfNil: MyError.castingError) }
        .errorMap{ Person(dict: dict) }
    return result
}
 
func convertor6(data: Result<Data>) -> Result<Person> {
    let result = data
                .errorMap(jsonParser(data:))
                .errorMap(checkType(any:))
                .errorMap(Person.init(dict:))
}
    • Error가 발생한 경우 Result의 failure로 넣어서 넘긴 것이 다임
    • 하지만, 실제 코드의 가독성과 간결성이 매우 향상됨
    • 각각의 동작 역시 순수함수로 분리했다면 6번 처럼 구성됨
  • 효과
    • Error handling이 Result안으로 숨음
    • Error handling code가 제거되어 주 logic을 가리지 않음
    • detail한 error를 추가하기가 더 쉬워짐
    • Optional-flatMap 조합에서 확인이 불가능했던 정확한 Error위치와 내용이 남음
      • Error 타입을 만들어서 받을 수 있음!

Graph