[RxSwift] Traits - Single, Completable, Maybe

안녕하세요 제인입니다!

오늘은 Traits가 무엇인지에 대해 알아보고, RxSwift의 Traits에 대해 정리해보겠습니다.

(RxCocoa의 Traits는 다음 게시글에서 이어서 정리하도록 할게요!)

이번 게시글은 ReactiveX/RxSwift의 Traits 문서를 번역하면서 Traits에 대해 정리해보도록 하겠습니다.

Traits란?

Swift는 애플리케이션의 정확성과 안정성을 향상시키고 Rx 사용을 보다 직관적이고 간단하게 만드는 데 사용할 수 있는 강력한 유형 시스템을 갖추고 있습니다.

Traits는 인터페이스 경계를 넘어 관찰 가능한 시퀀스 속성을 전달하고 보장하는 데 도움이 될 뿐만 아니라 모든 컨텍스트에서 사용할 수 있는 원시 Observable과 비교할 때 문맥적인 의미를 제공하고 더 구체적인 use-cases를 타겟으로 합니다.

Traits의 사용은 선택사항이며, 사용 목적은 코드를 읽는 사람에게 의도를 더 명확하게 전달하기 위함입니다. Traits를 사용하면 코드를 보다 직관적으로 만드는 데 도움이 될 수 있습니다.

 

Traits은 읽기전용(read-only) Observable sequence property을 랩핑하는 구조체 입니다.

 

struct Single<Element> {
    let source: Observable<Element>
}

struct Driver<Element> {
    let source: Observable<Element>
}
...

 

observable sequence에 대한 일종의 빌더 패턴 구현이라고 생각할 수 있습니다.

Traits 생성 후, .asObservable()을 호출하면 그것을 다시 평범한 observable sequence로 변환합니다.

RxSwift Traits의 종류

RxSwift의 Traits로는 Single, Completable, Maybe가 있습니다.

하나씩 살펴보겠습니다!

Single

Single은 일련의 요소를 방출하는 대신 항상 단일 요소 또는 오류를 방출하는 것을 보장하는 Observable의 변형입니다 .

 

• 정확히 하나의 요소 또는 error를 방출합니다.
• 부수작용을 공유하지 않습니다.

Single을 사용하는 일반적인 사용 사례 중 하나는 응답이나 오류만 반환할 수 있는 HTTP 요청을 수행하는 경우입니다. 하지만, Single은 무한한 스트림 요소가 아닌 단일 요소만 고려하는 경우에 사용할 수 있습니다.

Single 생성하기

Single을 만드는 것은 Observable을 만드는것과 비슷합니다. 아래의 간단한 예제를 통해 알아봅시다.

func getRepo(_ repo: String) -> Single<[String: Any]> {
    return Single<[String: Any]>.create { single in
        let task = URLSession.shared.dataTask(with: URL(string: "https://api.github.com/repos/\(repo)")!) { data, _, error in
            if let error = error {
                single(.failure(error))
                return
            }

            guard let data = data,
                  let json = try? JSONSerialization.jsonObject(with: data, options: .mutableLeaves),
                  let result = json as? [String: Any] else {
                single(.failure(DataError.cantParseJSON))
                return
            }

            single(.success(result))
        }

        task.resume()

        return Disposables.create { task.cancel() }
    }
}

위의 함수를 만들고 아래와 같이 사용할 수 있습니다. (HTTP 요청 성공, 실패에 따른 처리)

getRepo("ReactiveX/RxSwift")
    .subscribe { event in
        switch event {
            case .success(let json):
                print("JSON: ", json)
            case .failure(let error):
                print("Error: ", error)
        }
    }
    .disposed(by: disposeBag)

혹은 subscribe(onSuccess:onError:) 를 이용해 아래와 같이 사용할 수도 있습니다.

getRepo("ReactiveX/RxSwift")
    .subscribe(onSuccess: { json in
                   print("JSON: ", json)
               },
               onError: { error in
                   print("Error: ", error)
               })
    .disposed(by: disposeBag)

subscription은 Single의 타입 요소를 포함하는 .success, .error일 수 있는 Swift의 Result 열거형을 사용합니다. 첫번째 이벤트 이후에는 더 이상 이벤트가 발생하지 않습니다.

// RxSwift > Single.swift
public typealias SingleEvent<Element> = Result<Element, Swift.Error>

public func subscribe(_ observer: @escaping (SingleEvent<Element>) -> Void) -> Disposable {
        var stopped = false
        return self.primitiveSequence.asObservable().subscribe { event in
            if stopped { return }
            stopped = true
            
            switch event {
            case .next(let element):
                observer(.success(element))
            case .error(let error):
                observer(.failure(error))
            case .completed:
                rxFatalErrorInDebug("Singles can't emit a completion event")
            }
        }
    }

또한, 원본 Observable sequence에 .asSingle()를 사용하여 Single로 변경하여 사용이 가능합니다.

Completable

Completable은 오직 complete 혹은 error만 방출할 수 있는 Observable의 변형으로, 어떠한 요소도 방출하지 않는 것을 보장합니다.

 

• 제로 요소 방출
• 완료 이벤트 또는 에러 방출
• 부수작용을 공유하지 않습니다.

Completable은 작업이 완료되었다는 사실에만 관심있고 완료로 인해 발생하는 요소에는 관심이 없는 경우에 유용하게 사용할 수 있습니다. Observable<Void>를 사용해서 요소들을 방출할 수 없는 경우와 비교할 수 있습니다.

Completable 생성하기

Completable을 생성하는 것은 Observable 생성과 유사합니다. 간단한 예시는 다음과 같습니다.

func cacheLocally() -> Completable {
    return Completable.create { completable in
       // Store some data locally
       ...
       ...

       guard success else {
           completable(.error(CacheError.failedCaching))
           return Disposables.create {}
       }

       completable(.completed)
       return Disposables.create {}
    }
}

다음과 같이 사용할 수 있습니다.

cacheLocally()
    .subscribe { completable in
        switch completable {
            case .completed:
                print("Completed with no error")
            case .error(let error):
                print("Completed with an error: \(error.localizedDescription)")
        }
    }
    .disposed(by: disposeBag)

또는 subscribe(onCompleted:onError:)을 사용하여 다음과 같이 사용합니다.

cacheLocally()
    .subscribe(onCompleted: {
                   print("Completed with no error")
               },
               onError: { error in
                   print("Completed with an error: \(error.localizedDescription)")
               })
    .disposed(by: disposeBag)

구독은 작업이 오류 없이 완료되었음을 나타내는 .completed  또는 .error일 수 있는 CompletableEvent 열거형을 제공합니다. 첫 번째 이벤트 이후에는 더 이상의 이벤트가 발생하지 않습니다.

Maybe

Maybe는 Single과 Completable 사이에 있는 Observable의 변형입니다. 단일 요소를 방출하거나, 요소를 방출하지 않고 완료하거나, 오류를 방출할 수 있습니다.

Note: 이 세 가지 이벤트는 Maybe를 종료시킵니다. 즉, 종료된 Maybe는 요소를 방출할 수 없고 요소를 방출한 Maybe 역시 종료 이벤트를 내보낼 수 없습니다. (= 세 가지 이벤트 중 하나가 방출되면 종료됩니다)

 

• 완료된 이벤트, 싱글이벤트 또는 오류를 방출합니다.
• 부수작용을 공유하지 않습니다.

Maybe는 요소를 방출할 수 있는 어떤 작업에도 사용할 수 있습니다. 하지만, 요소를 반드시 방출할 필요는 없습니다.

Maybe 생성하기

Maybe는 Observabled을 만드는 것과 비슷합니다. 간단한 예제는 아래와 같습니다.

func generateString() -> Maybe<String> {
    return Maybe<String>.create { maybe in
        maybe(.success("RxSwift"))

        // OR

        maybe(.completed)

        // OR

        maybe(.error(error))

        return Disposables.create {}
    }
}

아래와 같이 사용합니다.

generateString()
    .subscribe { maybe in
        switch maybe {
            case .success(let element):
                print("Completed with element \(element)")
            case .completed:
                print("Completed with no element")
            case .error(let error):
                print("Completed with an error \(error.localizedDescription)")
        }
    }
    .disposed(by: disposeBag)

혹은 subscribe(onSuccess:onError:onCompleted:)을 이용해서 다음과 같이 사용할 수 있습니다.

generateString()
    .subscribe(onSuccess: { element in
                   print("Completed with element \(element)")
               },
               onError: { error in
                   print("Completed with an error \(error.localizedDescription)")
               },
               onCompleted: {
                   print("Completed with no element")
               })
    .disposed(by: disposeBag)

.asMaybe()를 사용해 원시 Observable 시퀀스를 Maybe로 변환하는 것 또한 가능합니다.

정리

RxSwift의 Traits 세 가지에 대해 ReactiveX 깃허브 공식문서를 번역하면서 알아보았는데요, 제가 이해한대로 정리를 간단하게 해보겠습니다.

 

Traits은 '특성'이라고 직역할 수 있듯이 어떤 특성이 존재하는 Observable 시퀀스입니다.

Traits은 read-only Observable의 wrapper 형태로,  Observable에 대한 접근을 제한해서 내부에 존재하는 Observable을 조정하여 일부 기능에 특화된 형태로 사용자에게 제공합니다.

Traits을 사용하면 코드를 보다 명확하고 직관적으로 만들 수 있습니다.

 

1. Single

- 항상 단일 요소 또는 오류를 방출

-> 성공 시 단일 요소 방출, 실패 시 error를 방출하기 때문에 데이터를 다운로드하거나 디스크에서 로드하는 경우와 같이 성공 or 실패에 따른 결과를 처리하는 일회성 프로세스에 유용

 

2. Completable

- 요소를 방출하지 않고, 오직 complete 혹은 error만 방출

-> 작업의 성공, 실패 여부만을 판단하는 경우 유용

 

3. Maybe

- 단일 요소를 방출 or 요소를 방출하지 않고 완료 or 오류 방출 (세 가지 중 하나 방출하고 종료됨)

-> 성공 또는 실패할 수 있는 작업에서 성공 시 선택적으로 값을 반환해야 하는 경우 유용