Some useful extension to RAC4

ReactiveUI.swift

import UIKit
import ReactiveCocoa

// Bind property to any setter
func <~ <T> (left: T->Void , right: AnyProperty<T>) -> Disposable {
    return left <~ right.producer
}

// Bind signal producer to any setter
func <~ <T> (left: T->Void , right: SignalProducer<T, NoError>) -> Disposable {
    return right.startWithNext(left)
}

// Any object which have text property
protocol TextSlot: class {
    var text: String? { get set }
}

// Slot for text which is just text setter
extension TextSlot {
    var textSlot : String -> Void {
        return { [weak self] in self?.text = $0 }
    }
}

protocol EnabledSlot: class {
    var enabled: Bool {get set}
}

extension EnabledSlot {
    var enabledSlot : Bool -> Void {
        return { [weak self] in self?.enabled = $0 }
    }
}

protocol HiddenSlot: class {
    var hidden: Bool {get set}
}

extension HiddenSlot {
    var hiddenSlot : Bool -> Void {
        return { [weak self] in self?.hidden = $0 }
    }
    
    var visibleSlot : Bool -> Void {
        return { [weak self] in self?.hidden = !$0 }
    }
}

protocol AnimatedSlot: class {
    func startAnimating()
    func stopAnimating()
}

extension AnimatedSlot {
    var animatedSlot : Bool -> Void {
        return { [weak self] in
            if $0 { self?.startAnimating() } else { self?.stopAnimating() }
        }
    }
}

extension UIView: HiddenSlot {}
extension UIControl : EnabledSlot {}
extension UITextField : TextSlot {}
extension UILabel : TextSlot {}
extension UIActivityIndicatorView : AnimatedSlot {}

// Some useful extensions for properties
extension PropertyType where Self.Value == Bool {
    var whenTrue: SignalProducer<Void, NoError> {
        return self.producer.filter({ $0 }).map({ _ in Void() })
    }
    
    var whenFalse: SignalProducer<Void, NoError> {
        return self.producer.filter({ !$0 }).map({ _ in Void() })
    }
}

// Map for property
extension PropertyType {
    func map<U>(f: Self.Value -> U) -> AnyProperty<U> {
        return AnyProperty(initialValue: f(self.value), producer: self.producer.map(f))
    }
}

// MutableProperty to AnyProperty clearer
extension MutableProperty {
    var asAnyProperty: AnyProperty<Value> {
        return AnyProperty(self)
    }
}

extension SignalType where Value == Bool {
    func not() -> Signal<Self.Value, Self.Error> {
        return self.map { !$0 }
    }
}

extension SignalProducerType where Value == Bool {
    func not() -> SignalProducer<Self.Value, Self.Error> {
        return self.lift { $0.not() }
    }
}