From 6139b16ca3be78eca1da55f06704869cd5b7796b Mon Sep 17 00:00:00 2001 From: Krunoslav Zaher Date: Fri, 4 Sep 2015 23:15:16 +0200 Subject: [PATCH] Updates documentation. --- CHANGELOG.md | 2 + Documentation/Migration.md | 2 + README.md | 7 +- .../Contents.swift | 140 +++++------ .../Contents.swift | 49 ++-- .../Contents.swift | 70 +++--- .../Contents.swift | 235 ------------------ .../Contents.swift | 99 +++----- .../Contents.swift | 26 +- .../Index.xcplaygroundpage/Contents.swift | 19 +- .../Contents.swift | 222 +++++++---------- .../Contents.swift | 13 +- .../Contents.swift | 75 +++--- .../Subjects.xcplaygroundpage/Contents.swift | 60 +++-- .../Contents.swift | 61 ++--- Rx.playground/contents.xcplayground | 1 - 16 files changed, 370 insertions(+), 711 deletions(-) delete mode 100644 Rx.playground/Pages/Creating_observables.xcplaygroundpage/Contents.swift diff --git a/CHANGELOG.md b/CHANGELOG.md index ad9fc6fa..68427872 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -13,8 +13,10 @@ All notable changes to this project will be documented in this file. * Change from `disposeBag.addDisposable` to `disposable.addDisposableTo` * Changes in RxCocoa extensions to enable fluent style * Rename of `do*` to `doOn*` +* Deprecates `returnElement` in favor of `just` * Deprecates `aggregate` in favor of `reduce` * Deprecates `variable` in favor of `shareReplay(1)` (to be consistent with RxJS version) +* Method `next` on `Variable` is now `sendNext` #### Fixed diff --git a/Documentation/Migration.md b/Documentation/Migration.md index 5b277f9f..01305ade 100644 --- a/Documentation/Migration.md +++ b/Documentation/Migration.md @@ -5,9 +5,11 @@ The migration should be pretty straightforward. The changes are mostly cosmetic, * Find replace all `>- ` to `.` * Find replace all "variable" to "shareReplay(1)" * Find replace all "catch" to "catchErrorResumeNext" +* Find replace all "returnElement" to "just" * Since we've moved from `>-` to `.`, free functions are now methods, so it's `.switchLatest()`, `.distinctUntilChanged()`, ... instead of `>- switchLatest`, `>- distinctUntilChanged` * we've moved from free functions to extensions so it's now `[a, b, c].concat()`, `.merge()`, ... instead of `concat([a, b, c])`, `merge(sequences)` * Now it's `subscribe { n in ... }.addDisposableTo(disposeBag)` instead of `>- disposeBag.addDisposable` +* Method `next` on `Variable` is now `sendNext` * If you want to use `tableViews`/`collectionViews`, this is the basic use case now ```swift diff --git a/README.md b/README.md index 9583125b..60b41971 100644 --- a/README.md +++ b/README.md @@ -456,8 +456,9 @@ Open Rx.xcworkspace, choose `RxExample` and hit run. This method will build ever # Podfile use_frameworks! -pod 'RxSwift' -pod 'RxCocoa' +pod 'RxSwift', '~> 2.0-alpha' +pod 'RxCocoa', '~> 2.0-alpha' +pod 'RxBlocking', '~> 2.0-alpha' ``` type in `Podfile` directory @@ -471,7 +472,7 @@ $ pod install Add this to `Cartfile` ``` -git "git@github.com:ReactiveX/RxSwift.git" +git "git@github.com:ReactiveX/RxSwift.git" "2.0-alpha.1" ``` ``` diff --git a/Rx.playground/Pages/Combining_Observables.xcplaygroundpage/Contents.swift b/Rx.playground/Pages/Combining_Observables.xcplaygroundpage/Contents.swift index 849539b4..35b66d0b 100644 --- a/Rx.playground/Pages/Combining_Observables.xcplaygroundpage/Contents.swift +++ b/Rx.playground/Pages/Combining_Observables.xcplaygroundpage/Contents.swift @@ -6,11 +6,13 @@ import RxSwift ## Combination operators Operators that work with multiple source Observables to create a single Observable. +*/ +/*: ### `startWith` -Return an observeble which emits a specified item before emitting the items from the source Observable. +emit a specified sequence of items before beginning to emit the items from the source Observable ![](https://raw.githubusercontent.com/kzaher/rxswiftcontent/master/MarbleDiagrams/png/startwith.png) @@ -18,79 +20,67 @@ Return an observeble which emits a specified item before emitting the items from */ example("startWith") { - let aggregateSubscriber = sequenceOf(4, 5, 6, 7, 8, 9) + let subscription = sequenceOf(4, 5, 6, 7, 8, 9) .startWith(3) .startWith(2) .startWith(1) .startWith(0) - .subscribeNext { int in - print(int) + .subscribe { + print($0) } - } /*: ### `combineLatest` -Takes several source Obserbables and a closure as parameters, returns an Observable which emits the latest items of each source Obsevable, procesed through the closure. -Once each source Observables have each emitted an item, `combineLatest` emits an item every time either source Observable emits an item. +when an item is emitted by either of two Observables, combine the latest item emitted by each Observable via a specified function and emit items based on the results of this function ![](https://raw.githubusercontent.com/kzaher/rxswiftcontent/master/MarbleDiagrams/png/combinelatest.png) [More info in reactive.io website]( http://reactivex.io/documentation/operators/combinelatest.html ) -The next example shows how */ -example("combineLatest 1st") { +example("combineLatest 1") { let intOb1 = PublishSubject() let intOb2 = PublishSubject() combineLatest(intOb1, intOb2) { "\($0) \($1)" } - .subscribeNext { + .subscribe { print($0) } - print("send A to first channel") intOb1.on(.Next("A")) - print("note that nothing outputs") - print("\nsend 1 to second channel") intOb2.on(.Next(1)) - print("now that there is something in both channels, there is output") - print("\nsend B to first channel") intOb1.on(.Next("B")) - print("now that both channels are full, whenever either channel emits a value, the combined channel also emits a value") - print("\nsend 2 to second channel") intOb2.on(.Next(2)) - print("note that the combined channel emits a value whenever either sub-channel emits a value, even if the value is the same") } -//: This example show once in each channel there are output for each new channel output the resulting observable also produces an output +//: To produce output, at least one element has to be received from each sequence in arguements. -example("combineLatest 2nd") { +example("combineLatest 2") { let intOb1 = just(2) let intOb2 = sequenceOf(0, 1, 2, 3, 4) combineLatest(intOb1, intOb2) { $0 * $1 } - .subscribeNext { (x: Int) in - print(x) + .subscribe { + print($0) } } -/*: -Rx has a group of `combineLatest` functions. -The next sample demonstrates `combineLatest` with three arguments. -*/ -example("combineLatest 3rd") { + +//: Combine latest has versions with more then 2 arguments. + +example("combineLatest 3") { let intOb1 = just(2) let intOb2 = sequenceOf(0, 1, 2, 3) let intOb3 = sequenceOf(0, 1, 2, 3, 4) @@ -98,8 +88,8 @@ example("combineLatest 3rd") { combineLatest(intOb1, intOb2, intOb3) { ($0 + $1) * $2 } - .subscribeNext { (x: Int) in - print(x) + .subscribe { + print($0) } } @@ -108,48 +98,36 @@ example("combineLatest 3rd") { /*: ### `zip` -Takes several source Observables and a closure as parameters, returns an Observable which emit the items of the second Obsevable procesed, through the closure, with the last item of first Observable -The Observable returned by `zip` emits an item only when all of the imputs Observables have emited an item +combine the emissions of multiple Observables together via a specified function and emit single items for each combination based on the results of this function ![](https://raw.githubusercontent.com/kzaher/rxswiftcontent/master/MarbleDiagrams/png/zip.png) [More info in reactive.io website](http://reactivex.io/documentation/operators/zip.html) */ -example("zip 1st") { +example("zip 1") { let intOb1 = PublishSubject() let intOb2 = PublishSubject() zip(intOb1, intOb2) { "\($0) \($1)" } - .subscribeNext { (x: String) in - print(x) + .subscribe { + print($0) } - print("send A to first channel") - sendNext(intOb1, "A") - print("note that nothing outputs") + intOb1.on(.Next("A")) - print("\nsend 1 to second channel") - sendNext(intOb2, 1) - print("now that both source channels have output, there is output") + intOb2.on(.Next(1)) - print("\nsend B to first channel") - sendNext(intOb1, "B") - print("note that nothing outputs, since channel 1 has two outputs but channel 2 only has one") + intOb1.on(.Next("B")) - print("\nsend C to first channel") - sendNext(intOb1, "C") - print("note that nothing outputs, it is the same as in the previous step, since channel 1 has three outputs but channel 2 only has one") + intOb1.on(.Next("C")) - print("\nsend 2 to second channel") - sendNext(intOb2, 2) - print("note that the combined channel emits a value with the second output of each channel") + intOb2.on(.Next(2)) } -//: This example show once in each channel there are output for each new channel output the resulting observable also produces an output -example("zip 2nd") { +example("zip 2") { let intOb1 = just(2) let intOb2 = sequenceOf(0, 1, 2, 3, 4) @@ -157,25 +135,22 @@ example("zip 2nd") { zip(intOb1, intOb2) { $0 * $1 } - .subscribeNext { (x: Int) in - print(x) + .subscribe { + print($0) } } -/*: -Demostrates simple usage of `zip` operator. -*/ -example("zip 3rd") { +example("zip 3") { let intOb1 = sequenceOf(0, 1) let intOb2 = sequenceOf(0, 1, 2, 3) let intOb3 = sequenceOf(0, 1, 2, 3, 4) zip(intOb1, intOb2, intOb3) { - ($0 + $1) * $2 + ($0 + $1) * $2 } - .subscribeNext { (x: Int) in - print(x) + .subscribe { + print($0) } } @@ -185,13 +160,13 @@ example("zip 3rd") { /*: ### `merge` -Combine multiple Observables, of the same type, into one by merging their emissions +combine multiple Observables into one by merging their emissions ![](https://raw.githubusercontent.com/kzaher/rxswiftcontent/master/MarbleDiagrams/png/merge.png) [More info in reactive.io website]( http://reactivex.io/documentation/operators/merge.html ) */ -example("merge 1st") { +example("merge 1") { let subject1 = PublishSubject() let subject2 = PublishSubject() @@ -201,33 +176,33 @@ example("merge 1st") { print(int) } - sendNext(subject1, 20) - sendNext(subject1, 40) - sendNext(subject1, 60) - sendNext(subject2, 1) - sendNext(subject1, 80) - sendNext(subject1, 100) - sendNext(subject2, 1) + subject1.on(.Next(20)) + subject1.on(.Next(40)) + subject1.on(.Next(60)) + subject2.on(.Next(1)) + subject1.on(.Next(80)) + subject1.on(.Next(100)) + subject2.on(.Next(1)) } -example("merge 2nd") { +example("merge 2") { let subject1 = PublishSubject() let subject2 = PublishSubject() sequenceOf(subject1, subject2) .merge(maxConcurrent: 2) - .subscribeNext { int in - print(int) + .subscribe { + print($0) } - sendNext(subject1, 20) - sendNext(subject1, 40) - sendNext(subject1, 60) - sendNext(subject2, 1) - sendNext(subject1, 80) - sendNext(subject1, 100) - sendNext(subject2, 1) + subject1.on(.Next(20)) + subject1.on(.Next(40)) + subject1.on(.Next(60)) + subject2.on(.Next(1)) + subject1.on(.Next(80)) + subject1.on(.Next(100)) + subject2.on(.Next(1)) } @@ -235,7 +210,7 @@ example("merge 2nd") { /*: ### `switchLatest` -Convert an Observable that emits Observables into a single Observable that emits the items emitted by the most-recently-emitted of those Observables. +convert an Observable that emits Observables into a single Observable that emits the items emitted by the most-recently-emitted of those Observables ![](https://raw.githubusercontent.com/kzaher/rxswiftcontent/master/MarbleDiagrams/png/switch.png) @@ -251,8 +226,8 @@ example("switchLatest") { let d = var3 .switchLatest() - .subscribeNext { (e: Int) -> Void in - print("\(e)") + .subscribe { + print($0) } var1.sendNext(1) @@ -264,7 +239,6 @@ example("switchLatest") { var2.sendNext(201) - print("var1 isn't observed anymore") var1.sendNext(5) var1.sendNext(6) var1.sendNext(7) diff --git a/Rx.playground/Pages/Conditional_and_Boolean_Operators.xcplaygroundpage/Contents.swift b/Rx.playground/Pages/Conditional_and_Boolean_Operators.xcplaygroundpage/Contents.swift index 752ffad7..03398d0c 100644 --- a/Rx.playground/Pages/Conditional_and_Boolean_Operators.xcplaygroundpage/Contents.swift +++ b/Rx.playground/Pages/Conditional_and_Boolean_Operators.xcplaygroundpage/Contents.swift @@ -8,8 +8,9 @@ import RxSwift Operators that evaluate one or more Observables or items emitted by Observables. +*/ - +/*: ### `takeUntil` Discard any items emitted by an Observable after a second Observable emits an item or terminates. @@ -19,23 +20,23 @@ Discard any items emitted by an Observable after a second Observable emits an it */ example("takeUntil") { - let observable1 = PublishSubject() - let observable2 = PublishSubject() + let originalSequence = PublishSubject() + let whenThisSendsNextWorldStops = PublishSubject() - observable1 - .takeUntil(observable2) - .subscribeNext { int in - print(int) - } + originalSequence + .takeUntil(whenThisSendsNextWorldStops) + .subscribe { + print($0) + } - sendNext(observable1, 1) - sendNext(observable1, 2) - sendNext(observable1, 3) - sendNext(observable1, 4) + originalSequence.on(.Next(1)) + originalSequence.on(.Next(2)) + originalSequence.on(.Next(3)) + originalSequence.on(.Next(4)) - sendNext(observable2, 1) + whenThisSendsNextWorldStops.on(.Next(1)) - sendNext(observable1, 5) + originalSequence.on(.Next(5)) } @@ -50,21 +51,21 @@ Mirror items emitted by an Observable until a specified condition becomes false */ example("takeWhile") { - let observable1 = PublishSubject() + let sequence = PublishSubject() - observable1 + sequence .takeWhile { int in int < 4 } - .subscribeNext { int in - print(int) - } + .subscribe { + print($0) + } - sendNext(observable1, 1) - sendNext(observable1, 2) - sendNext(observable1, 3) - sendNext(observable1, 4) - sendNext(observable1, 5) + sequence.on(.Next(1)) + sequence.on(.Next(2)) + sequence.on(.Next(3)) + sequence.on(.Next(4)) + sequence.on(.Next(5)) } diff --git a/Rx.playground/Pages/Connectable_Observable_Operators.xcplaygroundpage/Contents.swift b/Rx.playground/Pages/Connectable_Observable_Operators.xcplaygroundpage/Contents.swift index 914deb2a..01c41486 100644 --- a/Rx.playground/Pages/Connectable_Observable_Operators.xcplaygroundpage/Contents.swift +++ b/Rx.playground/Pages/Connectable_Observable_Operators.xcplaygroundpage/Contents.swift @@ -16,15 +16,15 @@ func sampleWithoutConnectableOperators() { let int1 = interval(1, MainScheduler.sharedInstance) int1 - .subscribeNext { + .subscribe { print("first subscription \($0)") } delay(5) { int1 - .subscribeNext { + .subscribe { print("second subscription \($0)") - } + } } } @@ -45,17 +45,17 @@ func sampleWithMulticast() { let subject1 = PublishSubject() subject1 - .subscribeNext { + .subscribe { print("Subject \($0)") - } + } let int1 = interval(1, MainScheduler.sharedInstance) .multicast(subject1) int1 - .subscribeNext { + .subscribe { print("first subscription \($0)") - } + } delay(2) { int1.connect() @@ -63,25 +63,21 @@ func sampleWithMulticast() { delay(4) { int1 - .subscribeNext { + .subscribe { print("second subscription \($0)") - print("---") - } + } } delay(6) { int1 - .subscribeNext { - print("thirth subscription \($0)") - } + .subscribe { + print("third subscription \($0)") + } } } -//sampleWithMulticast() - - - +// sampleWithMulticast() /*: @@ -100,7 +96,7 @@ func sampleWithReplayBuffer0() { .replay(0) int1 - .subscribeNext { + .subscribe { print("first subscription \($0)") } @@ -110,22 +106,21 @@ func sampleWithReplayBuffer0() { delay(4) { int1 - .subscribeNext { + .subscribe { print("second subscription \($0)") - print("---") - } + } } delay(6) { int1 - .subscribeNext { - print("thirth subscription \($0)") - } + .subscribe { + print("third subscription \($0)") + } } } -//sampleWithReplayBuffer0() +// sampleWithReplayBuffer0() func sampleWithReplayBuffer2() { @@ -136,7 +131,7 @@ func sampleWithReplayBuffer2() { .replay(2) int1 - .subscribeNext { + .subscribe { print("first subscription \($0)") } @@ -146,25 +141,21 @@ func sampleWithReplayBuffer2() { delay(4) { int1 - .subscribeNext { + .subscribe { print("second subscription \($0)") - print("---") } } delay(6) { int1 - .subscribeNext { + .subscribe { print("third subscription \($0)") } } } -//sampleWithReplayBuffer2() - - - +// sampleWithReplayBuffer2() /*: @@ -183,7 +174,7 @@ func sampleWithPublish() { .publish() int1 - .subscribeNext { + .subscribe { print("first subscription \($0)") } @@ -193,21 +184,22 @@ func sampleWithPublish() { delay(4) { int1 - .subscribeNext { + .subscribe { print("second subscription \($0)") - print("---") - } + } } delay(6) { int1 - .subscribeNext { + .subscribe { print("third subscription \($0)") - } + } } } +// sampleWithPublish() + XCPSetExecutionShouldContinueIndefinitely(true) //: [Index](Index) diff --git a/Rx.playground/Pages/Creating_observables.xcplaygroundpage/Contents.swift b/Rx.playground/Pages/Creating_observables.xcplaygroundpage/Contents.swift deleted file mode 100644 index 753ea56c..00000000 --- a/Rx.playground/Pages/Creating_observables.xcplaygroundpage/Contents.swift +++ /dev/null @@ -1,235 +0,0 @@ -//: [<< Previous](@previous) - [Index](Index) - -import RxSwift -import Foundation -/*: -## Creating observables - -Operators that originate new Observables. - - -### `empty` - -Creates an observable that contains no objects. The only message it sends is the `.Completed` message. - -![](https://raw.githubusercontent.com/kzaher/rxswiftcontent/master/MarbleDiagrams/png/empty.png) - -[More info in reactive.io website]( http://reactivex.io/documentation/operators/empty-never-throw.html ) -*/ - -example("Empty observable") { - let emptyObservable: Observable = empty() - - let emptySubscriber = emptyObservable .subscribe { event in - switch event { - case .Next(let box): - print("\(box.value)") - case .Completed: - print("completed") - case .Error(let error): - print("\(error)") - } - } -} - -/*: -As you can see, no values are ever sent to the subscriber of an empty observable. It just completes and is done. - - - -### `never` - -Creates an observable that contains no objects and never completes or errors out. - -![](https://raw.githubusercontent.com/kzaher/rxswiftcontent/master/MarbleDiagrams/png/never.png) - -[More info in reactive.io website]( http://reactivex.io/documentation/operators/empty-never-throw.html ) -*/ -example("Never observable") { - let neverObservable: Observable = never() - - let neverSubscriber = neverObservable - .subscribe { _ in - print("This block is never called.") - } -} - - - -/*: -### `failWith` a.k.a `throw` - -Creates an observable that contains no objects and send only a error out. - -![](https://raw.githubusercontent.com/kzaher/rxswiftcontent/master/MarbleDiagrams/png/throw.png) - -[More info in reactive.io website]( http://reactivex.io/documentation/operators/empty-never-throw.html ) -*/ -example("failWith") { - let error = NSError(domain: "Test", code: -1, userInfo: nil) - - let errorObservable: Observable = failWith(error) - - let errorSubscriber = errorObservable - .subscribe { event in - switch event { - case .Next(let box): - print("\(box.value)") - case .Completed: - print("completed") - case .Error(let error): - print("\(error)") - } - } -} - - -/*: -### `returnElement` / `just` - -These two functions behave identically. They send two messages to subscribers. The first message is the value and the second message is `.Complete`. - -![](https://raw.githubusercontent.com/kzaher/rxswiftcontent/master/MarbleDiagrams/png/just.png) - -[More info in reactive.io website]( http://reactivex.io/documentation/operators/just.html ) -*/ -example("returnElement/just") { - let oneObservable = just(32) - - let oneObservableSubscriber = oneObservable - .subscribe { event in - switch event { - case .Next(let box): - print("\(box.value)") - case .Completed: - print("completed") - case .Error(let error): - print("\(error)") - } - } -} - - -/*: -Here we see that the `.Next` event is sent just once, then the `.Completed` event is sent. - - - -### `sequenceOf` - -Now we are getting to some more interesting ways to create an Observable. This function creates an observable that produces a number of values before completing. -*/ -example("sequenceOf") { - let multipleObservable/* : Observable */ = sequenceOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9) - - let multipleObservableSubscriber = multipleObservable - .subscribe { event in - switch event { - case .Next(let box): - print("\(box.value)") - case .Completed: - print("completed") - case .Error(let error): - print("\(error)") - } - } -} - - -/*: -With the above, you will see that the `.Next` event was sent ten times, once for each element. Then `.Complete` was sent. - - - -### `from` -We can also create an observable from any SequenceType, such as an array. - -![](https://raw.githubusercontent.com/kzaher/rxswiftcontent/master/MarbleDiagrams/png/from.png) - -[More info in reactive.io website]( http://reactivex.io/documentation/operators/from.html ) -*/ -example("from") { - let fromArrayObservable = from([1, 2, 3, 4, 5]) - - let fromArrayObservableSubscriber = fromArrayObservable - .subscribe { event in - switch event { - case .Next(let box): - print("\(box.value)") - case .Completed: - print("completed") - case .Error(let error): - print("\(error)") - } - } -} - - - -/*: -### `create` - -Create an Observable from scratch by means of a function - -![](https://raw.githubusercontent.com/kzaher/rxswiftcontent/master/MarbleDiagrams/png/create.png) - -[More info in reactive.io website]( http://reactivex.io/documentation/operators/create.html ) -*/ -example("create") { - - print("creating") - let observable: Observable = create { observer in - print("emmiting") - sendNext(observer, 0) - sendNext(observer, 1) - sendNext(observer, 2) - - return AnonymousDisposable {} - } - - observable - .subscribeNext { - print($0) - } - - observable - .subscribeNext { - print($0) - } -} - -/*: -### `deferred` - -Create an Observable from a function which create an observable. But do not create the Observable until the observer subscribes, and create a fresh Observable for each observer - -![](https://raw.githubusercontent.com/kzaher/rxswiftcontent/master/MarbleDiagrams/png/defer.png) - -[More info in reactive.io website]( http://reactivex.io/documentation/operators/defer.html ) -*/ -example("deferred") { - let deferredSequence: Observable = deferred { - print("creating") - return create { observer in - print("emmiting") - sendNext(observer, 0) - sendNext(observer, 1) - sendNext(observer, 2) - - return AnonymousDisposable {} - } - } - - deferredSequence - .subscribeNext { - print($0) - } - - deferredSequence - .subscribeNext { - print($0) - } -} - - -//: [Index](Index) - [Next >>](@next) diff --git a/Rx.playground/Pages/Error_Handling_Operators.xcplaygroundpage/Contents.swift b/Rx.playground/Pages/Error_Handling_Operators.xcplaygroundpage/Contents.swift index eb048f9f..3d0df886 100644 --- a/Rx.playground/Pages/Error_Handling_Operators.xcplaygroundpage/Contents.swift +++ b/Rx.playground/Pages/Error_Handling_Operators.xcplaygroundpage/Contents.swift @@ -11,66 +11,46 @@ Operators that help to recover from error notifications from an Observable. /*: ### `catchError` -Recover from an onError notification by continuing the sequence without error +Recover from an `Error` notification by continuing the sequence without error ![](https://raw.githubusercontent.com/kzaher/rxswiftcontent/master/MarbleDiagrams/png/catch.png) [More info in reactive.io website]( http://reactivex.io/documentation/operators/catch.html ) */ -example("catchError 1st") { - let observable1 = PublishSubject() - let observable2 = PublishSubject() +example("catchError 1") { + let sequenceThatFails = PublishSubject() + let recoverySequence = sequenceOf(100, 200, 300, 400) - observable1 + sequenceThatFails .catchError { error in - return observable2 + return recoverySequence } - .subscribe { event in - switch event { - case .Next(let value): - print("\(value)") - case .Completed: - print("completed") - case .Error(let error): - print("\(error)") - } + .subscribe { + print($0) } - sendNext(observable1, 1) - sendNext(observable1, 2) - sendNext(observable1, 3) - sendNext(observable1, 4) - sendError(observable1, NSError(domain: "Test", code: 0, userInfo: nil)) - - sendNext(observable2, 100) - sendNext(observable2, 200) - sendNext(observable2, 300) - sendNext(observable2, 400) - sendCompleted(observable2) + sequenceThatFails.on(.Next(1)) + sequenceThatFails.on(.Next(2)) + sequenceThatFails.on(.Next(3)) + sequenceThatFails.on(.Next(4)) + sequenceThatFails.on(.Error(NSError(domain: "Test", code: 0, userInfo: nil))) } -example("catchError 2nd") { - let observable1 = PublishSubject() +example("catchError 2") { + let sequenceThatFails = PublishSubject() - observable1 + sequenceThatFails .catchErrorResumeNext(100) - .subscribe { event in - switch event { - case .Next(let value): - print("\(value)") - case .Completed: - print("completed") - case .Error(let error): - print("\(error)") - } + .subscribe { + print($0) } - sendNext(observable1, 1) - sendNext(observable1, 2) - sendNext(observable1, 3) - sendNext(observable1, 4) - sendError(observable1, NSError(domain: "Test", code: 0, userInfo: nil)) + sequenceThatFails.on(.Next(1)) + sequenceThatFails.on(.Next(2)) + sequenceThatFails.on(.Next(3)) + sequenceThatFails.on(.Next(4)) + sequenceThatFails.on(.Error(NSError(domain: "Test", code: 0, userInfo: nil))) } @@ -86,34 +66,27 @@ If a source Observable emits an error, resubscribe to it in the hopes that it wi */ example("retry") { var count = 1 // bad practice, only for example purposes - let observable: Observable = create { observer in + let funnyLookingSequence: Observable = create { observer in let error = NSError(domain: "Test", code: 0, userInfo: nil) - sendNext(observer, 0) - sendNext(observer, 1) - sendNext(observer, 2) + observer.on(.Next(0)) + observer.on(.Next(1)) + observer.on(.Next(2)) if count < 2 { - sendError(observer, error) + observer.on(.Error(error)) count++ } - sendNext(observer, 3) - sendNext(observer, 4) - sendNext(observer, 5) - sendCompleted(observer) + observer.on(.Next(3)) + observer.on(.Next(4)) + observer.on(.Next(5)) + observer.on(.Completed) - return AnonymousDisposable {} + return NopDisposable.instance } - observable + funnyLookingSequence .retry() - .subscribe { event in - switch event { - case .Next(let value): - print("\(value)") - case .Completed: - print("completed") - case .Error(let error): - print("\(error)") - } + .subscribe { + print($0) } } diff --git a/Rx.playground/Pages/Filtering_Observables.xcplaygroundpage/Contents.swift b/Rx.playground/Pages/Filtering_Observables.xcplaygroundpage/Contents.swift index 4a1ca395..fd478fd7 100644 --- a/Rx.playground/Pages/Filtering_Observables.xcplaygroundpage/Contents.swift +++ b/Rx.playground/Pages/Filtering_Observables.xcplaygroundpage/Contents.swift @@ -6,10 +6,10 @@ import RxSwift ## Filtering Observables Operators that selectively emit items from a source Observable. +*/ - - -### `where` / `filter` +/*: +### `filter` Emit only those items from an Observable that pass a predicate test @@ -19,12 +19,12 @@ Emit only those items from an Observable that pass a predicate test */ example("filter") { - let onlyEvensSubscriber = sequenceOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9) + let subscription = sequenceOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9) .filter { $0 % 2 == 0 } - .subscribeNext { value in - print("\(value)") + .subscribe { + print($0) } } @@ -39,10 +39,10 @@ Suppress duplicate items emitted by an Observable [More info in reactive.io website]( http://reactivex.io/documentation/operators/distinct.html ) */ example("distinctUntilChanged") { - let distinctUntilChangedSubscriber = sequenceOf(1, 2, 3, 1, 1, 4) + let subscription = sequenceOf(1, 2, 3, 1, 1, 4) .distinctUntilChanged() - .subscribeNext { value in - print("\(value)") + .subscribe { + print($0) } } @@ -57,13 +57,13 @@ Emit only the first n items emitted by an Observable [More info in reactive.io website]( http://reactivex.io/documentation/operators/take.html ) */ example("take") { - let distinctUntilChangedSubscriber = sequenceOf(1, 2, 3, 4, 5, 6) + let subscription = sequenceOf(1, 2, 3, 4, 5, 6) .take(3) - .subscribeNext { value in - print("\(value)") + .subscribe { + print($0) } } -//: [Index](Index) - [Next >>](@next) \ No newline at end of file +//: [Index](Index) - [Next >>](@next) diff --git a/Rx.playground/Pages/Index.xcplaygroundpage/Contents.swift b/Rx.playground/Pages/Index.xcplaygroundpage/Contents.swift index 88445867..a4910400 100644 --- a/Rx.playground/Pages/Index.xcplaygroundpage/Contents.swift +++ b/Rx.playground/Pages/Index.xcplaygroundpage/Contents.swift @@ -12,16 +12,15 @@ ## Index: 1. [Introduction](Introduction) -2. [Subjects](Subjects) -3. [Creating observables](Creating_observables) -4. [Transforming Observables](Transforming_Observables) -5. [Filtering Observables](Filtering_Observables) -6. [Combining Observables](Combining_Observables) -7. [Error Handling Operators](Error_Handling_Operators) -8. [Observable Utility Operators](Observable_Utility_Operators) -9. [Conditional and Boolean Operators](Conditional_and_Boolean_Operators) -10. [Mathematical and Aggregate Operators](Mathematical_and_Aggregate_Operators) -11. [Connectable Observable Operators](Connectable_Observable_Operators) +1. [Subjects](Subjects) +1. [Transforming Observables](Transforming_Observables) +1. [Filtering Observables](Filtering_Observables) +1. [Combining Observables](Combining_Observables) +1. [Error Handling Operators](Error_Handling_Operators) +1. [Observable Utility Operators](Observable_Utility_Operators) +1. [Conditional and Boolean Operators](Conditional_and_Boolean_Operators) +1. [Mathematical and Aggregate Operators](Mathematical_and_Aggregate_Operators) +1. [Connectable Observable Operators](Connectable_Observable_Operators) */ diff --git a/Rx.playground/Pages/Introduction.xcplaygroundpage/Contents.swift b/Rx.playground/Pages/Introduction.xcplaygroundpage/Contents.swift index 5af5386c..1666909f 100644 --- a/Rx.playground/Pages/Introduction.xcplaygroundpage/Contents.swift +++ b/Rx.playground/Pages/Introduction.xcplaygroundpage/Contents.swift @@ -1,6 +1,7 @@ //: [<< Index](@previous) import RxSwift +import Foundation /*: # Introduction @@ -20,190 +21,151 @@ Creating an Observable is one thing, but if nothing subscribes to the observable /*: ### empty -`empty` creates an observable that contains no objects. The only message it sends is the `.Completed` message. +`empty` creates an empty sequence. The only message it sends is the `.Completed` message. */ -example("Empty observable") { - let emptyObservable: Observable = empty() +example("empty") { + let emptySequence: Observable = empty() - let emptySubscriber = emptyObservable .subscribe { event in - switch event { - case .Next(let box): - print("\(box.value)") - case .Completed: - print("completed") - case .Error(let error): - print("\(error)") + let subscription = emptySequence + .subscribe { event in + print(event) } - } } - -/*: -As you can see, no values are ever sent to the subscriber of an empty observable. It just completes and is done. -*/ - /*: ### never -`never` creates an observable that contains no objects and never completes or errors out. +`never` creates a sequence that never sends any element or completes. */ -example("Never observable") { - let neverObservable: Observable = never() +example("never") { + let neverSequence: Observable = never() - let neverSubscriber = neverObservable .subscribe { _ in - print("This block is never called.") - } -} - -/*: -### returnElement/just -These two functions behave identically. They send two messages to subscribers. The first message is the value and the second message is `.Complete`. -*/ - -example("returnElement/just") { - let oneObservable = just(32) - - let oneObservableSubscriber = oneObservable - .subscribe { event in - switch event { - case .Next(let box): - print("\(box.value)") - case .Completed: - print("completed") - case .Error(let error): - print("\(error)") - } + let subscription = neverSequence + .subscribe { _ in + print("This block is never called.") } } /*: -Here we see that the `.Next` event is sent just once, then the `.Completed` event is sent. +### just +`just` represents sequence that contains one element. It sends two messages to subscribers. The first message is the value of single element and the second message is `.Completed`. */ +example("just") { + let singleElementSequence = just(32) + + let subscription = singleElementSequence + .subscribe { event in + print(event) + } +} + /*: -### sequence -Now we are getting to some more interesting ways to create an Observable. This function creates an observable that produces a number of values before completing. +### sequenceOf +`sequenceOf` creates a sequence of a fixed number of elements. */ -example("sequence") { - let multipleObservable/* : Observable */ = sequenceOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9) +example("sequenceOf") { + let sequenceOfElements/* : Observable */ = sequenceOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9) - let multipleObservableSubscriber = multipleObservable + let subscription = sequenceOfElements .subscribe { event in - switch event { - case .Next(let box): - print("\(box.value)") - case .Completed: - print("completed") - case .Error(let error): - print("\(error)") - } + print(event) } } -/*: -With the above, you will see that the `.Next` event was sent ten times, once for each element. Then `.Complete` was sent. -*/ - /*: ### from -We can also create an observable from any SequenceType, such as an array +`from` creates a sequence from `SequenceType` */ example("from") { - let fromArrayObservable = from([1, 2, 3, 4, 5]) + let sequenceFromArray = from([1, 2, 3, 4, 5]) - let fromArrayObservableSubscriber = fromArrayObservable + let subscription = sequenceFromArray .subscribe { event in - switch event { - case .Next(let box): - print("\(box.value)") - case .Completed: - print("completed") - case .Error(let error): - print("\(error)") - } + print(event) } } /*: -Now these functions are all well and good, but the really useful ones are in the RxCocoa library. -`rx_observe` exist on every NSObject and wraps KVO. -`rx_tap` exists on buttons and wraps @IBActions -`rx_notification` wraps NotificationCenter events -... and so on. - -Take some time and search for code matching `-> Observable` in the RxCocoa framework to get a sense of how every action can be modeled as an observable. You can even create your own functions that make Observable objects. - -## Subscribing -Up to this point, I have only used the `subscribe` method to listen to Observables, but there are several others. +### create +`create` creates sequence using Swift closure. This examples creates custom version of `just` operator. */ -example("subscribeNext") { - let nextOnlySubscriber = sequenceOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9) - .subscribeNext { value in - print("\(value)") +example("create") { + let myJust = { (singleElement: Int) -> Observable in + return create { observer in + observer.on(.Next(singleElement)) + observer.on(.Completed) + + return NopDisposable.instance + } + } + + let subscription = myJust(5) + .subscribe { event in + print(event) } } /*: -With the above we only interest ourselves in the values returned by the observable without regard to whether/when it completes or errors. Many of the observables that we use have an indefinite lifespan. There is also `subscribeCompleted` and `subscribeError` for when you are looking for when an observable will stop sending. - -Also note that you can have multiple subscribers following to the same observable (as I did in the example above.) All the subscribers will be notified when an event occurs. +### failWith +create an Observable that emits no items and terminates with an error */ -/*: -## Reducing a sequence -Now that you understand how to create Observables and subscribe to them. Let's look at the various ways we can manipulate an observable sequence. First lets examine ways to reduce a sequence into fewer events. - -### where/filter -The most common way to reduce a sequence is to apply a filter to it and the most generic of these is `where` or `filter`. You will see in the code below that the messages containing odd numbers are being removed so the subscriber wont see them. -*/ - -example("filter") { - let onlyEvensSubscriber = sequenceOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9) - .filter { - $0 % 2 == 0 - } - .subscribeNext { value in - print("\(value)") +example("failWith") { + let error = NSError(domain: "Test", code: -1, userInfo: nil) + + let erroredSequence: Observable = failWith(error) + + let subscription = erroredSequence + .subscribe { event in + print(event) } } /*: -### distinctUntilChanged -This filter tracks the last value emitted and removes like values. This function is good for reducing noise in a sequence. -*/ +### `deferred` -example("distinctUntilChanged") { - let distinctUntilChangedSubscriber = sequenceOf(1, 2, 3, 1, 1, 4) - .distinctUntilChanged() - .subscribeNext { value in - print("\(value)") +do not create the Observable until the observer subscribes, and create a fresh Observable for each observer + +![](https://raw.githubusercontent.com/kzaher/rxswiftcontent/master/MarbleDiagrams/png/defer.png) + +[More info in reactive.io website]( http://reactivex.io/documentation/operators/defer.html ) +*/ +example("deferred") { + let deferredSequence: Observable = deferred { + print("creating") + return create { observer in + print("emmiting") + observer.on(.Next(0)) + observer.on(.Next(1)) + observer.on(.Next(2)) + + return NopDisposable.instance + } + } + + deferredSequence + .subscribe { event in + print(event) + } + + deferredSequence + .subscribe { event in + print(event) } } - /*: -In the example above, the values 1, 2, 3, 1, 4 will be printed. The extra 1 will be filtered out. -There are several different versions of `distinctUntilChanged`. Have a look in the file Observable+Single.swift to review them. +There is a lot more useful methods in the RxCocoa library, so check them out: +* `rx_observe` exist on every NSObject and wraps KVO. +* `rx_tap` exists on buttons and wraps @IBActions +* `rx_notification` wraps NotificationCenter events +* ... and many others */ -/*: -## Reducing a sequence - -### `reduce` -This function will perform a function on each element in the sequence until it is completed, then send a message with the aggregate value. It works much like the Swift `reduce` function works on sequences. -*/ - -example("reduce") { - let aggregateSubscriber = sequenceOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9) - .reduce(0, +) - .subscribeNext { value in - print("\(value)") - } -} - //: [Index](Index) - [Next >>](@next) diff --git a/Rx.playground/Pages/Mathematical_and_Aggregate_Operators.xcplaygroundpage/Contents.swift b/Rx.playground/Pages/Mathematical_and_Aggregate_Operators.xcplaygroundpage/Contents.swift index be7a6c84..64273983 100644 --- a/Rx.playground/Pages/Mathematical_and_Aggregate_Operators.xcplaygroundpage/Contents.swift +++ b/Rx.playground/Pages/Mathematical_and_Aggregate_Operators.xcplaygroundpage/Contents.swift @@ -7,8 +7,9 @@ import RxSwift Operators that operate on the entire sequence of items emitted by an Observable +*/ - +/*: ### `concat` Emit the emissions from two or more Observables without interleaving them. @@ -26,8 +27,8 @@ example("concat") { let d = var3 .concat() - .subscribeNext { (e: Int) -> Void in - print("\(e)") + .subscribe { + print($0) } var1.on(.Next(1)) @@ -64,10 +65,10 @@ This function will perform a function on each element in the sequence until it i */ example("reduce") { - let reduceSubscriber = sequenceOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9) + sequenceOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9) .reduce(0, +) - .subscribeNext { value in - print("\(value)") + .subscribe { + print($0) } } diff --git a/Rx.playground/Pages/Observable_Utility_Operators.xcplaygroundpage/Contents.swift b/Rx.playground/Pages/Observable_Utility_Operators.xcplaygroundpage/Contents.swift index 4643d687..4df8d1ad 100644 --- a/Rx.playground/Pages/Observable_Utility_Operators.xcplaygroundpage/Contents.swift +++ b/Rx.playground/Pages/Observable_Utility_Operators.xcplaygroundpage/Contents.swift @@ -7,112 +7,107 @@ import Foundation A toolbox of useful Operators for working with Observables. +*/ - +/*: ### `subscribe` -Create an Disposable which listen events from source Observable, the given closure take the Even and is responsible for the actions to perform when the it is produced. [More info in reactive.io website]( http://reactivex.io/documentation/operators/subscribe.html ) */ example("subscribe") { - let intOb1 = PublishSubject() + let sequenceOfInts = PublishSubject() - intOb1 - .subscribe { event in - print(event) + sequenceOfInts + .subscribe { + print($0) } - sendNext(intOb1, 1) - sendCompleted(intOb1) + sequenceOfInts.on(.Next(1)) + sequenceOfInts.on(.Completed) } /*: -There are several variants of the `subscribe` operator. They works over one posible event type: - +There are several variants of the `subscribe` operator. +*/ +/*: ### `subscribeNext` -Create an Disposable which listen only Next event from source Observable, the given closure take the Even's value and is responsible for the actions to perform only when the Next even is produced. */ example("subscribeNext") { - let intOb1 = PublishSubject() + let sequenceOfInts = PublishSubject() - intOb1 - .subscribeNext { int in - print(int) + sequenceOfInts + .subscribeNext { + print($0) } - sendNext(intOb1, 1) - sendCompleted(intOb1) + sequenceOfInts.on(.Next(1)) + sequenceOfInts.on(.Completed) } /*: - ### `subscribeCompleted` -Create an Disposable which listen only Completed event from source Observable, the given closure take the Even's value and is responsible for the actions to perform only when the Completed even is produced. */ example("subscribeCompleted") { - let intOb1 = PublishSubject() + let sequenceOfInts = PublishSubject() - intOb1 + sequenceOfInts .subscribeCompleted { print("It's completed") } - sendNext(intOb1, 1) - sendCompleted(intOb1) + sequenceOfInts.on(.Next(1)) + sequenceOfInts.on(.Completed) } /*: -### `subscribeError +### `subscribeError` -Create an Disposable which listen only Error event from source Observable, the given closure take the Even's value and is responsible for the actions to perform only when the Error even is produced */ example("subscribeError") { - let intOb1 = PublishSubject() + let sequenceOfInts = PublishSubject() - intOb1 + sequenceOfInts .subscribeError { error in print(error) } - sendNext(intOb1, 1) - sendError(intOb1, NSError(domain: "Examples", code: -1, userInfo: nil)) + sequenceOfInts.on(.Next(1)) + sequenceOfInts.on(.Error(NSError(domain: "Examples", code: -1, userInfo: nil))) } /*: ### `doOn` -Returns the same source Observable but the given closure responsible for the actions to perform when the even is produced. The gived closure obtain the event produced by the source observable +register an action to take upon a variety of Observable lifecycle events ![](https://raw.githubusercontent.com/kzaher/rxswiftcontent/master/MarbleDiagrams/png/do.png) [More info in reactive.io website]( http://reactivex.io/documentation/operators/do.html ) */ example("doOn") { - let intOb1 = PublishSubject() + let sequenceOfInts = PublishSubject() - let intOb2 = intOb1 - .doOn { event in - print("first \(event)") + sequenceOfInts + .doOn { + print("Intercepted event \($0)") } - - - intOb2 - .subscribeNext { int in - print("second \(int)") + .subscribe { + print($0) } - sendNext(intOb1, 1) + sequenceOfInts.on(.Next(1)) + sequenceOfInts.on(.Completed) } //: [Index](Index) - [Next >>](@next) diff --git a/Rx.playground/Pages/Subjects.xcplaygroundpage/Contents.swift b/Rx.playground/Pages/Subjects.xcplaygroundpage/Contents.swift index c42ca8f5..8a878cbb 100644 --- a/Rx.playground/Pages/Subjects.xcplaygroundpage/Contents.swift +++ b/Rx.playground/Pages/Subjects.xcplaygroundpage/Contents.swift @@ -2,10 +2,15 @@ import RxSwift -func writeSequenceToConsole(name: String, sequence: Observable) { +/*: + +A Subject is a sort of bridge or proxy that is available in some implementations of ReactiveX that acts both as an observer and as an Observable. Because it is an observer, it can subscribe to one or more Observables, and because it is an Observable, it can pass through the items it observes by reemitting them, and it can also emit new items. +*/ + +func writeSequenceToConsole(name: String, sequence: O) { sequence - .subscribeNext { - print("Subscription: \(name), value: \($0)") + .subscribe { e in + print("Subscription: \(name), event: \(e)") } } @@ -14,7 +19,7 @@ func writeSequenceToConsole(name: String, sequence: Observable) { ## PublishSubject -PublishSubject can begin emitting items immediately upon creation, but there is a risk that one or more items may be lost between the time the Subject is created and the observer subscribes to it. +`PublishSubject` emits to an observer only those items that are emitted by the source Observable(s) subsequent to the time of the subscription. ![](https://raw.githubusercontent.com/kzaher/rxswiftcontent/master/MarbleDiagrams/png/publishsubject.png) @@ -24,11 +29,11 @@ PublishSubject can begin emitting items immediately upon creation, but there is example("PublishSubject") { let subject = PublishSubject() writeSequenceToConsole("1", sequence: subject) - sendNext(subject, "a") - sendNext(subject, "b") + subject.on(.Next("a")) + subject.on(.Next("b")) writeSequenceToConsole("2", sequence: subject) - sendNext(subject, "c") - sendNext(subject, "d") + subject.on(.Next("c")) + subject.on(.Next("d")) } @@ -36,23 +41,25 @@ example("PublishSubject") { ## ReplaySubject -ReplaySubject emits to any observer all of the items, in the buffer, that were emitted by the source +`ReplaySubject` emits to any observer all of the items that were emitted by the source Observable(s), regardless of when the observer subscribes. + ![](https://raw.githubusercontent.com/kzaher/rxswiftcontent/master/MarbleDiagrams/png/replaysubject.png) */ example("ReplaySubject") { let subject = ReplaySubject.create(bufferSize: 1) + writeSequenceToConsole("1", sequence: subject) - sendNext(subject, "a") - sendNext(subject, "b") + subject.on(.Next("a")) + subject.on(.Next("b")) writeSequenceToConsole("2", sequence: subject) - sendNext(subject, "c") - sendNext(subject, "d") + subject.on(.Next("c")) + subject.on(.Next("d")) } /*: -## BehaviorSubject a.k.a. Variable +## BehaviorSubject When an observer subscribes to a `BehaviorSubject`, it begins by emitting the item most recently emitted by the source Observable (or a seed/default value if none has yet been emitted) and then continues to emit any other items emitted later by the source Observable(s). @@ -63,12 +70,29 @@ When an observer subscribes to a `BehaviorSubject`, it begins by emitting the it example("BehaviorSubject") { let subject = BehaviorSubject(value: "z") writeSequenceToConsole("1", sequence: subject) - sendNext(subject, "a") - sendNext(subject, "b") + subject.on(.Next("a")) + subject.on(.Next("b")) writeSequenceToConsole("2", sequence: subject) - sendNext(subject, "c") - sendNext(subject, "d") + subject.on(.Next("c")) + subject.on(.Next("d")) + subject.on(.Completed) } +/*: + +## Variable + +`Variable` wraps `BehaviorSubject`. Advantage of using variable over `BehaviorSubject` is that variable can never explicitly complete or error out, and `BehaviorSubject` can in case `Error` or `Completed` message is send to it. `Variable` will also automatically complete in case it's being deallocated. + +*/ +example("Variable") { + let variable = Variable("z") + writeSequenceToConsole("1", sequence: variable) + variable.sendNext("a") + variable.sendNext("b") + writeSequenceToConsole("2", sequence: variable) + variable.sendNext("c") + variable.sendNext("d") +} //: [Index](Index) - [Next >>](@next) diff --git a/Rx.playground/Pages/Transforming_Observables.xcplaygroundpage/Contents.swift b/Rx.playground/Pages/Transforming_Observables.xcplaygroundpage/Contents.swift index c26f560e..60ed7d24 100644 --- a/Rx.playground/Pages/Transforming_Observables.xcplaygroundpage/Contents.swift +++ b/Rx.playground/Pages/Transforming_Observables.xcplaygroundpage/Contents.swift @@ -6,8 +6,9 @@ import RxSwift ## Transforming Observables Operators that transform items that are emitted by an Observable. +*/ - +/*: ### `map` / `select` Transform the items emitted by an Observable by applying a function to each item @@ -18,21 +19,13 @@ Transform the items emitted by an Observable by applying a function to each item */ example("map") { - let observable1: Observable = create { observer in - sendNext(observer, Character("A")) - sendNext(observer, Character("B")) - sendNext(observer, Character("C")) + let originalSequence = sequenceOf(Character("A"), Character("B"), Character("C")) - return AnonymousDisposable {} - } - - observable1 + originalSequence .map { char in char.hashValue } - .subscribeNext { int in - print(int) - } + .subscribe { print($0) } } @@ -46,32 +39,17 @@ Transform the items emitted by an Observable into Observables, then flatten the [More info in reactive.io website]( http://reactivex.io/documentation/operators/flatmap.html ) */ example("flatMap") { - let observable1: Observable = create { observer in - sendNext(observer, 1) - sendNext(observer, 2) - sendNext(observer, 3) + let sequenceInt = sequenceOf(1, 2, 3) - return AnonymousDisposable {} - } + let sequenceString = sequenceOf("A", "B", "C", "D", "E", "F", "--") - let observable2: Observable = create { observer in - sendNext(observer, "A") - sendNext(observer, "B") - sendNext(observer, "C") - sendNext(observer, "D") - sendNext(observer, "F") - sendNext(observer, "--") - - return AnonymousDisposable {} - } - - observable1 + sequenceInt .flatMap { int in - observable2 + sequenceString } - .subscribeNext { + .subscribe { print($0) - } + } } @@ -85,24 +63,15 @@ Apply a function to each item emitted by an Observable, sequentially, and emit e [More info in reactive.io website]( http://reactivex.io/documentation/operators/scan.html ) */ example("scan") { - let observable: Observable = create { observer in - sendNext(observer, 0) - sendNext(observer, 1) - sendNext(observer, 2) - sendNext(observer, 3) - sendNext(observer, 4) - sendNext(observer, 5) + let sequenceToSum = sequenceOf(0, 1, 2, 3, 4, 5) - return AnonymousDisposable {} - } - - observable + sequenceToSum .scan(0) { acum, elem in acum + elem } - .subscribeNext { + .subscribe { print($0) - } + } } diff --git a/Rx.playground/contents.xcplayground b/Rx.playground/contents.xcplayground index c316d80f..a05e9e9e 100644 --- a/Rx.playground/contents.xcplayground +++ b/Rx.playground/contents.xcplayground @@ -4,7 +4,6 @@ -