RxSwift Single, Maybe, Completable 알아보기

RxSwift Single, Maybe, Completable 알아보기

Single

• .success(), .error()를 한번만 방출하는 Observable이다.
• .success() = next 이벤트와 completed 이벤트를 합친것과 같다. 
• 정확히 한가지 연산자를 맵핑할때 유용하다.

print("------Single1------")
Single<String>.just("V")
    .subscribe(
        onSuccess: {
            print($0)
        },
        onFailure: {
            print("error: \($0)")
        },
        onDisposed: {
            print("disposed")
        }
    )
    .disposed(by: disposeBag)
    
print("------Single2------")
Observable<String>.just("V")
    .asSingle()
    .subscribe(
        onSuccess: {
            print($0)
        },
        onFailure: {
            print("error: \($0)")
        },
        onDisposed: {
            print("disposed")
        })
    .disposed(by: disposeBag)

• error

print("------Single2------")
Observable<String>.create { observer -> Disposable in
    observer.onError(TraitsError.single)
    return Disposables.create()
}
    .asSingle()
    .subscribe(
        onSuccess: {
            print($0)
        },
        onFailure: {
            print("error: \($0)")
        },
        onDisposed: {
            print("disposed")
        })
    .disposed(by: disposeBag)

• 결론 하나의 이벤트를 발생시키고 Observable 종료시키는 Single

print("------Single3------")
struct SomeJSON: Decodable {
    let name: String
}

enum JSONError: Error {
    case decodingError
}

let json1 = """
{"name":"park"}
"""

let json2 = """
{"my_name":"young"
"""

func decode(json: String) -> Single<SomeJSON> {
    Single<SomeJSON>.create { observer -> Disposable in
        guard let data = json.data(using: .utf8),
              let json = try? JSONDecoder().decode(SomeJSON.self, from: data) else {
            observer(.failure(JSONError.decodingError))
            return Disposables.create()
        }
        
        observer(.success(json))
        return Disposables.create()
    }
}

decode(json: json1)
    .subscribe {
        switch $0 {
        case .success(let json):
            print(json.name)
        case .failure(let error):
            print(error)
        }
    }
    .disposed(by: disposeBag)

decode(json: json2)
    .subscribe {
        switch $0 {
        case .success(let json):
            print(json.name)
        case .failure(let error):
            print(error)
        }
    }
    .disposed(by: disposeBag)

Maybe

• Single과 비슷하지만 유일하게 다른점은 성공적으로 completed되더라도 아무런 값을 방출하지 않는 completed을 포함한다.

print("------Maybe1------")
Maybe<String>.just("V")
    .subscribe(onSuccess: {
        print($0)
    },
               onError: {
        print($0)
    },
               onCompleted: {
        print("completed")
    },
               onDisposed: {
        print("disposed")
    }
    )
    .disposed(by: disposeBag)

print("------Maybe2------")
Observable<String>.create { observer -> Disposable in
    observer.onError(TraitsError.maybe)
    return Disposables.create()
}
.asMaybe() // Observable을 asMaybe를 사용해 Maybe로 형변환
.subscribe(
    onSuccess: {
        print("성공: \($0)")
    },
    onError: {
        print("에러 : \($0)")
    },
    onCompleted: {
        print("completed")
    },
    onDisposed: {
        print("disposed")
    }
)
.disposed(by: disposeBag)

Completable

• .completed 또는 .error만을 방출합니다. 
• Observable을 completable로 바꿀수는 없다.
• Completable Sequence를 생성하고 싶으면 create를 사용해야 한다.

print("------Completable1------")
Completable.create { observer -> Disposable in
    observer(.error(TraitsError.completable))
    return Disposables.create()
}
.subscribe(onCompleted: {
    print("completed")
},
           onError: {
    print("error : \($0)")
},
           onDisposed: {
    print("disposed")
}
)
.disposed(by: disposeBag)

print("------Completable2------")
Completable.create { observer -> Disposable in
    observer(.completed)
    return Disposables.create()
}
.subscribe {
    print($0)
}
.disposed(by: disposeBag)

Observable로 사용해도 되지만 좀 더 명시적이고 직관적인 코드 작성을 위해서 좀 더 제한적인 위에 3가지 아이템을 제시하고 있다.