This is an introduction to reactive concepts using Swift specifically with ReactiveX’s implementation, RxSwift. ReactiveX is an API for asynchronous programming with observable streams originally implemented with .NET and LINQ. ReactiveX is a combination of the best ideas from the Observer pattern, the Iterator pattern, and functional programming.
You’ll learn about all the basic moving parts of RxSwift and why you want to use it in your application.
Original presented 23-Aug-2016 at 360iDev 2016 - Denver, CO.
6. WHAT IS RXSWIFT?
➤ Based on ReactiveX
➤ Many different ports: Java, JavaScript, .NET, Scala, Clojure, Swift, Kotlin, PHP, …
➤ Extends the Observer Pattern
➤ Related to Iterable Pattern
➤ Swift itself provides some protocols with equivalence
➤ SequenceType
➤ GeneratorType
14. GENERATORS
class CountdownGenerator: GeneratorType {
typealias Element = Int
var element: Element
init<T>(array: [T]) {
self.element = array.count
}
func next() -> Element? {
guard element > 0 else { return nil }
element -= 1
return element
}
}
let xs = ["A", "B", "C"]
let generator = CountdownGenerator(array: xs)
while let i = generator.next() {
print("Element (i) of the array is (xs[i])")
}
Element 2 of the array is C
Element 1 of the array is B
Element 0 of the array is A
16. SEQUENCES
class ReverseSequence<T>: SequenceType {
var array: [T]
init(array: [T]) {
self.array = array
}
func generate() -> CountdownGenerator {
return CountdownGenerator(array: array)
}
}
let reverseSequence = ReverseSequence(array: xs)
let reverseGenerator = reverseSequence.generate()
while let i = reverseGenerator.next() {
print("Index (i) is (xs[i])")
}
for i in ReverseSequence(array: xs) {
print("Index (i) is (xs[i])")
}
Index 2 is C
Index 1 is B
Index 0 is A
Index 2 is C
Index 1 is B
Index 0 is A
18. OBSERVERTYPE
public protocol ObserverType {
associatedtype E
func on(event: Event<E>)
}
public enum Event<Element> {
case Next(Element)
case Error(ErrorType)
case Completed
}
19. OBSERVABLETYPE
public protocol ObservableType : ObservableConvertibleType {
associatedtype E
func subscribe<O: ObserverType where O.E == E>(observer: O) -> Disposable
}
public protocol ObservableConvertibleType {
associatedtype E
func asObservable() -> Observable<E>
}
21. MAKING AN OBSERVABLE
let disposeBag = DisposeBag()
Observable.just("X")
.subscribe { event in
print(event)
}
.addDisposableTo(disposeBag)
22. MAKING AN OBSERVABLE
let disposeBag = DisposeBag()
Observable.of("W", "X", "Y", "X")
.subscribeNext { element in
print(element)
}
.addDisposableTo(disposeBag)
23. MAKING AN OBSERVABLE
let disposeBag = DisposeBag()
["W", "X", "Y", "Z"].toObservable()
.subscribeNext { print($0) }
.addDisposableTo(disposeBag)