iOS. RxSwift Traits에 관하여 알아봅시다. 어렵지 않아요...

사전적인 의미로는 특성이라는 것으로 정의가 되어 있는데요.

쉽게 Rx의 흐름을 방출시킬수 있는 방법을 정의 하는 부분입니다.

가볍게 봐주셔도 됩니다.

거의 모든 분들은 그냥 Observable.create를 사용하여도 간단하게 만들수 있습니다.

 

1. Single

항상 단일 요소 또는 오류를 방출합니다.

즉, 하나의 흐름이 지나가면 끝나버립니다.

func getRequest(url: String?) -> Single<Bool> {
    return Single<Bool>.create { single in
        guard let url = url else {
            single(.error(NSError.init(domain: "error", code: -1, userInfo: nil)))
            return Disposables.create()
        }

        if url == "https://www.google.com" {
            single(.success(true))
        } else {
            single(.success(false))
        }

        return Disposables.create()
    }
}

예제는 url이 nil이면 error, google이면 true, 아니면 false의 흐름을 방출하게 되는 Single의 예였습니다.

 

사용은 아래처럼 하면 됩니다. Observable과는 조금 다르기는 합니다.

getRequest(url: "http://www.github.com")
    .subscribe(onSuccess: { success in
                
    }, onError: { error in
                
    })
    .disposed(by: disposeBag)

Single.swift 파일에 들어가보면 다음과 같이 되어 있습니다.

/// Sequence containing exactly 1 element
public enum SingleTrait { }
/// Represents a push style sequence containing 1 element.
public typealias Single<Element> = PrimitiveSequence<SingleTrait, Element>

public enum SingleEvent<Element> {
    /// One and only sequence element is produced. (underlying observable sequence emits: `.next(Element)`, `.completed`)
    case success(Element)
    
    /// Sequence terminated with an error. (underlying observable sequence emits: `.error(Error)`)
    case error(Swift.Error)
}

extension PrimitiveSequenceType where TraitType == SingleTrait {
    public typealias SingleObserver = (SingleEvent<ElementType>) -> Void
    
    ...

PrimitiveSequence를 이용하여 만들어진 녀석이며, 값은 success와 error만 존재합니다.

 

2. Completable

완료 이벤트나 에러를 방출합니다. 또는 아무것도 방출하지 않습니다.

func test(success: Bool) -> Completable {
    return Completable.create { completable in
		guard success else {
           completable(.error(NSError(...))
           return Disposables.create {}
       }

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

다음과 같이 사용이 가능합니다.

test(success: true)
    .subscribe(onCompleted: { completed in
                
    }, onError: { error in
                
    })
    .disposed(by: disposeBag)

 

3. Maybe

어쩌면... 이라는 뜻이랍니다. 하하...

Single과 Completable 사이의 Observable의 변형이라고 하고요.

단일 요소를 방출하거나 요소를 방출하지 않고 완료하거나 오류를 낼수 있다고 합니다. 즉 두가지 특징을 다 가집니다.

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

        // OR

        maybe(.completed)

        // OR

        maybe(.error(error))

        return Disposables.create {}
    }
}

다음과 같이 이용이 가능합니다.

test()
    .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)

Observable을 생성하는것과 거의 비슷합니다.

 

4. Observable

Maybe와 거의 비슷하나 한가지를 더 가지고 있습니다. 일반적으로 이것으로 선언해서 많이들 사용합니다.

onDisposed를 가지고 있으며, 이 Observable이 disposed될 때에 호출되어야 하는 부분들을 정리할수 있습니다.

// Maybe
.subscribe(onSuccess: {}, onError: {}, onCompleted: {})

// Observable
.subscribe(onNext: {}, onError: {}, onCompleted: {}, onDisposed: {})