   extension UIResponder: ObjCUIInjectedExecutionContext {
   }
   
-  /// UIControl improved with AsyncNinja
-  public extension UIControl {
-    /// Update of ActionChannel
-    typealias ActionChannelUpdate = (sender: AnyObject?, event: UIEvent)
-    
-    /// Channel that contains actions sent by the control
-    typealias ActionChannel = Channel<ActionChannelUpdate, Void>
-    
+  // MARK: - reactive properties for UIView
+  public extension ReactiveProperties where Object: UIView {
+    /// An `ProducerProxy` that refers to read-write property `UIView.alpha`
+    var alpha: ProducerProxy<CGFloat, Void> { return updatable(forKeyPath: "alpha", onNone: .drop) }
+
+    /// An `ProducerProxy` that refers to read-write property `UIView.tintColor`
+    var tintColor: ProducerProxy<UIColor, Void> { return updatable(forKeyPath: "tintColor", onNone: .drop) }
+
+    /// An `ProducerProxy` that refers to read-write property `UIView.isHidden`
+    var isHidden: ProducerProxy<Bool, Void> { return updatable(forKeyPath: "hidden", onNone: .drop) }
+
+    /// An `ProducerProxy` that refers to read-write property `UIView.isOpaque`
+    var isOpaque: ProducerProxy<Bool, Void> { return updatable(forKeyPath: "opaque", onNone: .drop) }
+
+    /// An `ProducerProxy` that refers to read-write property `UIView.isUserInteractionEnabled`
+    var isUserInteractionEnabled: ProducerProxy<Bool, Void> { return updatable(forKeyPath: "userInteractionEnabled", onNone: .drop) }
+  }
+  
+  // MARK: - reactive properties for UIControl
+  public extension ReactiveProperties where Object: UIControl {
     /// Makes channel that will have update value on each triggering of action
     ///
     /// - Parameter events: events that to listen for
     /// - Returns: unbuffered channel
-    func actionChannel(forEvents events: UIControlEvents = UIControlEvents.allEvents) -> ActionChannel {
-      let actionReceiver = UIControlActionReceiver(control: self)
-      self.addTarget(actionReceiver,
+    func actions(forEvents events: UIControlEvents = UIControlEvents.allEvents) -> Channel<(sender: AnyObject?, event: UIEvent), Void> {
+      let actionReceiver = UIControlActionReceiver(control: object)
+      object.addTarget(actionReceiver,
                      action: #selector(UIControlActionReceiver.asyncNinjaAction(sender:forEvent:)),
                      for: events)
-      self.notifyDeinit {
+      object.notifyDeinit {
         actionReceiver.producer.cancelBecauseOfDeallocatedContext(from: nil)
       }
-      
+
       return actionReceiver.producer
     }
-    
+
     /// Shortcut that binds block to UIControl event
     ///
     /// - Parameters:

      forEvents events: UIControlEvents = UIControlEvents.allEvents,
      context: C,
      _ block: @escaping (C, AnyObject?, UIEvent) -> Void) {
      
      self.actionChannel(forEvents: events)
        .onUpdate(context: context) { (context, update) in
          block(context, update.sender, update.event)
      }
    }
  }
  
  private class UIControlActionReceiver: NSObject {
    weak var control: UIControl?
    let producer = Producer<UIControl.ActionChannelUpdate, Void>(bufferSize: 0)
    
    init(control: UIControl) {
      self.control = control
    }
    
    dynamic func asyncNinjaAction(sender: AnyObject?, forEvent event: UIEvent) {
      let update: UIControl.ActionChannelUpdate = (
        sender: sender,
        event: event
      )
      self.producer.update(update, from: .main)
    }
  }

  private class ActionReceiver: NSObject {
    weak var object: NSObject?
    let producer = Producer<AnyObject?, Void>(bufferSize: 0)
    
    init(object: NSObject) {
      self.object = object
    }
    
    dynamic func asyncNinjaAction(sender: AnyObject?) {
      self.producer.update(sender, from: .main)
    }
  }

  // MARK: - reactive properties for UIView
  public extension ReactiveProperties where Object: UIView {
    /// An `ProducerProxy` that refers to read-write property `UIView.alpha`
    var alpha: ProducerProxy<CGFloat, Void> { return updatable(forKeyPath: "alpha", onNone: .drop) }

    /// An `ProducerProxy` that refers to read-write property `UIView.tintColor`
    var tintColor: ProducerProxy<UIColor, Void> { return updatable(forKeyPath: "tintColor", onNone: .drop) }

    /// An `ProducerProxy` that refers to read-write property `UIView.isHidden`
    var isHidden: ProducerProxy<Bool, Void> { return updatable(forKeyPath: "hidden", onNone: .drop) }

    /// An `ProducerProxy` that refers to read-write property `UIView.isOpaque`
    var isOpaque: ProducerProxy<Bool, Void> { return updatable(forKeyPath: "opaque", onNone: .drop) }

    /// An `ProducerProxy` that refers to read-write property `UIView.isUserInteractionEnabled`
    var isUserInteractionEnabled: ProducerProxy<Bool, Void> { return updatable(forKeyPath: "userInteractionEnabled", onNone: .drop) }
  }
  
  // MARK: - reactive properties for UIControl
  public extension ReactiveProperties where Object: UIControl {
    /// An `ProducerProxy` that refers to read-write property `UIControl.isEnabled`
    var isEnabled: ProducerProxy<Bool, Void> { return updatable(forKeyPath: "enabled", onNone: .drop) }

    /// An `ProducerProxy` that refers to read-write property `UIControl.isSelected`
    var isSelected: ProducerProxy<Bool, Void> { return updatable(forKeyPath: "selected", onNone: .drop) }

    /// An `Channel` that refers to read-only property `UIControl.state`
    var state: Channel<UIControlState, Void> { return updating(forKeyPath: "state", onNone: .drop) }
  }

  // MARK: - reactive properties for UILabel

    }
    #endif
  }

  private class UIBarButtonItemActionReceiver: NSObject {
    weak var object: UIBarButtonItem?
    let producer = Producer<AnyObject?, Void>(bufferSize: 0)

    init(object: UIBarButtonItem) {
      self.object = object
    }

    dynamic func asyncNinjaAction(sender: AnyObject?) {
      self.producer.update(sender, from: .main)
    }
  }

#if os(iOS)
  // MARK: - reactive properties for UIDatePicker
  public extension ReactiveProperties where Object: UIDatePicker {
