 	/// `RACError.ActionNotEnabled`, and nothing will be sent upon `values` or
 	/// `errors` for that particular signal.
 	public func apply(input: Input) -> SignalProducer<Output> {
-		fatalError("TODO")
+		return SignalProducer { observer, disposable in
+			var startedExecuting = false
+
+			dispatch_sync(self.executingQueue) {
+				if self.dynamicType.shouldBeEnabled(userEnabled: self.userEnabled.value, executing: self._executing.value) {
+					self._executing.value = true
+					startedExecuting = true
+				}
+			}
+
+			if !startedExecuting {
+				sendError(observer, RACError.ActionNotEnabled.error)
+				return
+			}
+
+			self.executeClosure(input).startWithSignal { signal, signalDisposable in
+				disposable.addDisposable(signalDisposable)
+				signal.observe(observer)
+
+				signal.observe(next: { value in
+					sendNext(self.valuesObserver, value)
+				}, error: { error in
+					sendNext(self.errorsObserver, error)
+				})
+			}
+
+			disposable.addDisposable {
+				self._executing.value = false
+			}
+		}
 	}
 }

		return PropertyOf(_executing)
	}

	/// Whether the action is currently enabled.
	public var enabled: PropertyOf<Bool> {
		return PropertyOf(_enabled)
	}

	private let _executing: MutableProperty<Bool> = MutableProperty(false)
	private let _enabled: MutableProperty<Bool> = MutableProperty(true)

	/// Whether the action should be enabled for the given combination of user
	/// enabledness and executing status.
	private func shouldBeEnabled(#userEnabled: Bool, executing: Bool) -> Bool {
		return userEnabled && !executing
	}


	/// SignalProducer for each input.
	public init<P: PropertyType where P.Value == Bool>(enabledIf: P, _ execute: Input -> SignalProducer<Output>) {
		executeClosure = execute
		userEnabled = PropertyOf(enabledIf)

		let (vSig, vSink) = Signal<Output>.pipe()
		valuesObserver = vSink
