RAC presentation

RAC.swift

import UIKit
import ReactiveCocoa

extension NSTimer {
    /**
    Creates and schedules a one-time `NSTimer` instance.
    
    :param: delay The delay before execution.
    :param: handler A closure to execute after `delay`.
    
    :returns: The newly-created `NSTimer` instance.
    */
    class func schedule(#delay: NSTimeInterval, handler: NSTimer! -> Void) -> NSTimer {
        let fireDate = delay + CFAbsoluteTimeGetCurrent()
        let timer = CFRunLoopTimerCreateWithHandler(kCFAllocatorDefault, fireDate, 0, 0, 0, handler)
        CFRunLoopAddTimer(CFRunLoopGetCurrent(), timer, kCFRunLoopCommonModes)
        return timer
    }
    
    /**
    Creates and schedules a repeating `NSTimer` instance.
    
    :param: repeatInterval The interval between each execution of `handler`. Note that individual calls may be delayed; subsequent calls to `handler` will be based on the time the `NSTimer` was created.
    :param: handler A closure to execute after `delay`.
    
    :returns: The newly-created `NSTimer` instance.
    */
    class func schedule(repeatInterval interval: NSTimeInterval, handler: NSTimer! -> Void) -> NSTimer {
        let fireDate = interval + CFAbsoluteTimeGetCurrent()
        let timer = CFRunLoopTimerCreateWithHandler(kCFAllocatorDefault, fireDate, interval, 0, 0, handler)
        CFRunLoopAddTimer(CFRunLoopGetCurrent(), timer, kCFRunLoopCommonModes)
        return timer
    }
}

class ViewController: UIViewController {
    
    
    
    
    func createSignal() -> Signal<String, NoError> {
        var count = 0
        return Signal { sink in
            
            NSTimer.schedule(repeatInterval: 1.0) { timer in
                sendNext(sink, "tick #\(count++)")
            }
            
            return nil
        }
    }
    
    
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        
        let signal = createSignal()
        //Events
        signal.observe(Signal.Observer { event in
            
            switch event {
                
            case let .Next(next):
                println("Next: \(next)")
                
            case let .Error(error):
                println("Error: \(error)")
                
            case .Completed:
                println("Completed")
                
            case .Interrupted:
                println("Interrupted")
            }
        })
        
        
//        signal.observe(
//            next: { next in
//                println("Next: \(next)")
//            }, error: { error in
//                println("Error: \(error)")
//            }, completed: {
//                println("Completed")
//            }, interrupted: {
//                println("Interrupted")
//        })
        
        
        
        
        
        
        
        
        
        
        //upper case matching
        let upperMapping: (Signal<String, NoError>) -> (Signal<String, NoError>) = map({
            value in
            return value.uppercaseString
        })
        
        
        
        
//        let newSignal = upperMapping(signal)
//        newSignal.observe(next: { println($0) })
        
        
        
        
        
        
        
        
        
        
        
        
        
        // |> operator
        let newSignal = signal
            |> map { $0.uppercaseString }
            |> filter { count($0) > 4 }
            |> observe(next: { println($0) } )
//        newSignal.observe(next: { println($0) })
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
//        signal
//            |> upperMapping
//            |> observe(next: { println($0) })
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
//        signal
//            |> map { $0.uppercaseString }
//            |> observe(next: { println($0) })
//        
//        
//        signal
//            |> map { count($0) }
//            |> filter { $0 > 5 }
//            |> observe(next: { println($0) })
//        
//        
        let textField = UITextField(frame: CGRectMake(10, 50, self.view.frame.width - 20, 50))
        textField.backgroundColor = UIColor.greenColor()
        view.addSubview(textField)
        
        
        let textSignalProducer = textField.rac_textSignal().toSignalProducer()
            |> map { text in text as! String } //need to cast:: objc bug
            |> map { count($0) > 5 }
//            |> filter { count($0) > 5 }
        
        textSignalProducer
            |> start(next: { textField.backgroundColor = $0 ? UIColor.greenColor() : UIColor.redColor() })
        
        
        
        
        
            
        
        
        
    }
 

}