refactor: using map instread of flatMap where appropriate, initializing ReactiveGestureReactor with UIGestureRecognizers

Author: almostintuitive

functional-reactive-intuition/Project/RFP/ReactiveGestureReactor.swift

@@ -8,56 +8,40 @@ class ReactiveGestureReactor: GestureReactor {
 
 	var delegate: GestureReactorDelegate?
 
-	private var timerCreator: ReactiveTimerCreator
+	private let timerCreator: ReactiveTimerCreator
 	private let disposeBag = DisposeBag()
 
-	private var panVariable: Variable<UIGestureRecognizerType?>
-	private var rotateVariable: Variable<UIGestureRecognizerType?>
+    private let panVariable: Variable<UIGestureRecognizerType>
+    private let rotateVariable: Variable<UIGestureRecognizerType>
 
-	init(timerCreator: ReactiveTimerCreator) {
+    init(timerCreator: ReactiveTimerCreator, gestureRecognizers: (UIGestureRecognizerType, UIGestureRecognizerType)) {
 		self.timerCreator = timerCreator
-		panVariable = Variable(nil)
-		rotateVariable = Variable(nil)
-				
+        self.panVariable = Variable(gestureRecognizers.0)
+        self.rotateVariable = Variable(gestureRecognizers.1)
 
         // FYI 
         // Passing on the UIGesture at this point is dodgy as it's a reference 
         // It's state will change and render our filter useless. 
         // We therefore keep just the state in our observable buffers [.Began,.Began,.Ended]
-        let rotateGesturesStartedEnded = rotateVariable.asObservable().filter { gesture in gesture?.state == .Began || gesture?.state == .Ended}.flatMap { (gesture) -> Observable<UIGestureRecognizerState> in
-            return Observable.just(gesture!.state)
-        }
 
-        let panGesturesStartedEnded = panVariable.asObservable().filter { gesture in gesture?.state == .Began || gesture?.state == .Ended}.flatMap { (gesture) -> Observable<UIGestureRecognizerState> in
-            return Observable.just(gesture!.state)
-        }
+        let rotateGesturesStartedEnded = rotateVariable.asObservable().map { $0.state }.filter { $0 != .Began || $0 != .Ended }
+        let panGesturesStartedEnded = panVariable.asObservable().map { $0.state }.filter { $0 != .Began || $0 != .Ended }
 
         // Combine our latest .Began and .Ended from both Pan and Rotate.
-        // If they are the same then return the same state. If not then return a Failed.
-        let combineStartEndGestures = Observable.combineLatest(panGesturesStartedEnded, rotateGesturesStartedEnded) { (panState, rotateState) -> Observable<UIGestureRecognizerState> in
-			
-			// If only one is .Ended, the result is .Ended too
-            var state = UIGestureRecognizerState.Ended
-            if panState == .Began && rotateState == .Began {
-                state = .Began
-            }
-            
-            return Observable.just(state)
-        }.switchLatest()
-		
-		// several .Began events in a row are to be treated the same as a single one, it has just meaning if a .Ended is in between
-		let distinceCombineStartEndGestures = combineStartEndGestures.distinctUntilChanged()
-
+        // If they are the same then return the same state. If not then return .Ended.
+        let combinedGesture = Observable
+            .combineLatest(rotateGesturesStartedEnded, panGesturesStartedEnded) { ($0, $1) }
+            .map { ($0.0 == .Began && $0.1 == .Began)
+                ? UIGestureRecognizerState.Began
+                : UIGestureRecognizerState.Ended
+            }.distinctUntilChanged()
+            // several .Began events in a row are to be treated the same as a single one, it has just meaning if a .Ended is in between
 
         // condition: when both pan and rotate has begun
-        let bothGesturesStarted = distinceCombineStartEndGestures.filter { (state) -> Bool in
-            state == .Began
-        }
+        let bothGesturesStarted = combinedGesture.filter { $0 == .Began }
 
         // condition: when both pan and rotate has Ended
-        let bothGesturesEnded = distinceCombineStartEndGestures.filter { (state) -> Bool in
-            state == .Ended
-        }
+        let bothGesturesEnded = combinedGesture.filter { $0 == .Ended }
 
 		// when bothGesturesStarted, do this:
 		bothGesturesStarted.subscribeNext { [unowned self] _ in

functional-reactive-intuition/Project/RFP/ReactiveViewController.swift

@@ -17,29 +17,30 @@ class ReactiveViewController: UIViewController, SetStatus, GestureReactorDelegat
   @IBOutlet weak var centerXConstraint: NSLayoutConstraint! //For updating the position of the box when dragging
   @IBOutlet weak var centerYConstraint: NSLayoutConstraint!
 
-  private var gestureReactor: GestureReactor = ReactiveGestureReactor(timerCreator: { interval in ReactiveTimerFactory.reactiveTimer(interval: interval) })
+  private var gestureReactor: GestureReactor!
 
   private let disposeBag = DisposeBag()
 
   override func viewDidLoad() {
     super.viewDidLoad()
 
-    gestureReactor.delegate = self
-
     let pan = UIPanGestureRecognizer(target: self, action: "handlePan:")
     pan.delegate = self
     let rotate = UIRotationGestureRecognizer(target: self, action: "handleRotate:")
     rotate.delegate = self
-    self.draggableView.gestureRecognizers = [pan, rotate]
+    draggableView.gestureRecognizers = [pan, rotate]
 
+    gestureReactor = ReactiveGestureReactor(timerCreator: { interval in ReactiveTimerFactory.reactiveTimer(interval: interval) }, gestureRecognizers: (pan, rotate))
+    gestureReactor.delegate = self
+
 
     ///
     ///
     /// Extra Code to manipulate move and rotate the subview.
     ///
     /// Uses custom infix on CGPoint to '-' or '+' two together.
 
-    let panLocation = pan.rx_event.map { $0.locationInView(self.view) - self.view.center }
+    let panLocation = pan.rx_event.map { [unowned self] in $0.locationInView(self.view) - self.view.center }
     panLocation.map { $0.x }
       .bindTo(self.centerXConstraint.rx_constant)
       .addDisposableTo(self.disposeBag)