뤼졸ㅌ

[YoonAh-dev]

Result

👩🏻‍🎨 에러를 보다 유연하게 처리할 수 있는 Result<Value, Error> 문법

우리는 Error를 비동기적으로 처리하기 위해서 이렇게 사용했습니다.

func load(with nickname: String, completionHandler: @escaping (Data?, Error?) -> Void) {
		//...
}

load { (data, error) in
	guard error == nil else { handleError(error!) }
	guard let data = data else { return }

	handleError(data)
}

이런 방식으로 에러를 처리할 때는 문제점이 존재합니다.

문제점

• error에 data가 반드시 있다고 보장할 수 없습니다. 즉, error, data가 모두 nil이 들어올 수도 있어요.
• 우리는 우리가 생각한 것보다 많은 경우의 수를 따져볼 필요가 있습니다.

위의 코드에서 우리가 처리하고자하는 실행 결과는 두가지입니다.

• 성공(success)
• 실패(failure)

하지만 위의 경우에는 총 네 가지의 가짓수가 나타날 수 있습니다.

대체로 일어나는 결과는 2, 3번 행이지만 1, 4번같은 상태도 나타날 수 있는 것이죠.

Data	Error
Data	Error
Data	Error
Data	Error

▶️  Result 타입이 이러한 문제를 명확하게 해결해줄 수 있습니다.

Swift5에서 Result를 이렇게 정의합니다.

enum Result<Success, Failure: Error> {
	case success(Success)
	case failure(Failure)
}

위 코드를 Result를 이용해서 바꿔보면

func load(with nickname: String, completionHandler: @escaping (Result<Data, Error>) -> Void) {
		//...
}

load { result in
	switch result {
	case .success(let data):
		// 데이터 처리
	case .failure(let error)"
		// error 처리
	}
}

Result를 사용하면 모호한 상태를 처리할 필요가 없고 꼭 필요한 상태만 처리하면 되다보니 명시적이고 간결하게 에러처리를 할 수 있게 됩니다.

Result 변형

1. Type Errors

   앞에 있는 예시들처럼 코드를 썼을 때에 Error프로토콜을 따르는 모든 형태가 에러가 될 수 있습니다. 이 때는 어떤 에러가 발생했는지 정확하게 파악이 어렵기 때문에 에러를 안전하고 정확하게 처리하기 위해서 연관된 에러를 정의해 사용할 수 있습니다.

   enum LoadingError: Error {
       case networkUnavailable
       case timedOut
       case invalidStatusCode(Int)
   }
   
   typealias Handler = (Result<Data, LoadingError>) -> Void
   
   func load(with nickname: String, completionHandler: @escaping Handler) {
   		//...
   }
   
   load { [weak self] result in
       switch result {
       case .success(let data):
           self?.handle(data)
       case .failure(let error):
           switch error {
           case .networkUnavailable:
               self?.showErrorView(withMessage: .unavailable)
           case .timedOut:
               self?.showErrorView(withMessage: .timedOut)
           case .invalidStatusCode(let code):
               self?.showErrorView(withMessage: .statusCode(code))
           }
       }
   }

   에러가 발생하면 정의한 에러의 종류에 따라 처리할 수 있습니다.

2. Throw 처리

   Switch를 사용하지 않고 try do catch에서 직접 결과값을 받아서 처리하고 싶을 때가 있습니다. 이런 경우 성공시 결과값을 반환하고 실패했을시에는 throw를 뱉도록 처리 가능합니다.

   extension Result {
       func process() throws -> Success {
           switch self {
           case .success(let value)
               return value
           case .failure(let error)
               throw error
           }
       }
   }
   
   do {
       let result = try value?.process()
       handleValue(result)
   }
   catch {
       handleError(error)
   }

3. 지연 처리(Delayed Error Handling)

   에러 처리를 나중에 하고 싶을 때 Result를 이용하면 클로저를 초기화 파라미터로 사용해서 코드를 간결하게 작성할 수 있습니다.

   // 기존 방식
   var configString: String?
   var configError: Error?
   
   do {
       configString = try String(contentsOfFile: "myfile.data")
   } catch {
       configError = error
   }
   
   func doSomethingWithConfig() {
       guard let configString = self.configString else {
           handle(configError)
       }
   }

   let configuration = Result { try String(contentsOfFile: "myfile.data") }
   
   func doSomethingWithCongifg() {
       switch configuration {
       case .success(let success)
           handleSuccess(success)
       case .failure(let error)
           handlError(error)
       }
   }

   Result 타입에는 throwing closure를 받는 초기자가 있습니다. 클로저가 값을 성공적으로 반환하면 success case에서 그 값을 연관값으로 저장하고 그렇지 않으면 throw된 에러를 failure case의 연관값으로 저장합니다.

4. Result 변형

   func generateRandomNumber(maximum: Int) -> Result<Int, Error> {
       //...
   }
   
   let result = generateRandomNumber(maximum: 7)
   let number = result.map { "Generated Random number is : \($0)" }

   public func map<NewSuccess>(_ transform: (Success) -> NewSuccess) -> Result<NewSuccess, Failure> { }
   
   public func mapError<NewFailure>(_ transform: (Failure) -> NewFailure) -> Result<Success, NewFailure> { }
   
   public func flatMap<NewSuccess>(_ transform: (Success) -> Result<NewSuccess, Failure>) -> Result<NewSuccess, Failure> { }
   
   public func flatMapError<NewFailure>(_ transform: (Failure) -> Result<Success, NewFailure>
   ) -> Result<Success, NewFailure> { }

   Result 자체에서 map() flatMap() mapError() flatMapError() 함수를 지원합니다.

5. get() 메서드 사용

   Result 타입에는 get() 메서드가 있습니다. 메서드는 성공한 값이 있으면 반환하고 그렇지 않으면 에러를 throw합니다. get() 메서드를 사용하면 Result 타입 사용을 일반적인 예외 던지기로 변환할 수 있습니다.

   • 작업의 성공만을 고려한다면 get() 사용하는 것이 좋습니다.

   fetchUnreadCount1(from: "https://www.hackingwithswift.com") { result in
       if let count = try? result.get() {
           print("(count) unread messages.")
       }
   }

[Swift] Result 타입](https://jusung.github.io/Result-%ED%83%80%EC%9E%85/)](https://jusung.github.io/Result-%ED%83%80%EC%9E%85/)

Result 타입](https://tech.burt.pe.kr/swift/what-new/swift-5.0/result-type)