Completable

Completable

Completable is a special version of Observable. Unlike Observable that can emit multiple elements, it can only generate a completed event or an error event.

• Emit zero elements
• Issue a completed event or an error event
• Does not share additional effects

Completable is suitable for the situation that only cares about the completion of the task, and does not need to care about the return value of the task. It is similar to Observable.

• How to create a Completable

Creating a Completable is very similar to creating an 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 {}  } } 

You can use Completable like this:

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

You can also use this call

以使用如下方式使用这个 Completable：

cacheLocally()
    .subscribe { completable in
 switch completable {  case .completed:  print("保存成功!")  case .error(let error):  print("保存失败: \(error.localizedDescription)")  }  }  .disposed(by: disposeBag)

The subscription provides an enumeration of CompletableEvent:

public enum CompletableEvent {
    case error(Swift.Error)
    case completed
}

• completed-Generate a completed event
• error-generates an error

Maybe

Maybe is a special version of Observable. It is between Single and Completable, it can only emit one element, or generate a completed event, or generate an error event

• Emit an element or a completed event or an error event
• Does not share additional effects

If you encounter one that may need to emit an element, and may not need to emit, you can use Maybe.

• How to create Maybe Creating Maybe is very similar to creating Observable:

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

 // OR   maybe(.completed)   // OR   maybe(.error(error))   return Disposables.create {}  } }

Maybe can be used like this:

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)

You can also call the .asMaybe () method on Observable to convert it to Maybe.