diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..bfcbe8a
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,417 @@
+# 2.0
+
+This release of ReactiveCocoa contains major breaking changes that we were
+unable to make after freezing the 1.0 API. All changes are focused on
+eliminating bad code and bad usage patterns, reducing confusion, and increasing
+flexibility in the framework.
+
+For a complete list of changes in ReactiveCocoa 2.0, see [the
+milestone](https://github.com/ReactiveCocoa/ReactiveCocoa/issues?milestone=3&state=closed).
+
+**[Breaking changes](#breaking-changes)**
+
+ 1. [Simplified and safer KVO](#simplified-and-safer-kvo)
+ 1. [Safer commands with less state](#safer-commands-with-less-state)
+ 1. [Fallback nil value for RAC macro](#fallback-nil-values-for-rac-macro)
+ 1. [Explicit schedulers for time-based operators](#explicit-schedulers-for-time-based-operators)
+ 1. [More powerful selector signals](#more-powerful-selector-signals)
+ 1. [Simpler two-way bindings](#simpler-two-way-bindings)
+ 1. [Better bindings for AppKit](#better-bindings-for-appkit)
+ 1. [More obvious sequencing operator](#more-obvious-sequencing-operator)
+ 1. [Renamed signal binding method](#renamed-signal-binding-method)
+ 1. [Consistent selector lifting](#consistent-selector-lifting)
+ 1. [Renamed scheduled signal constructors](#renamed-scheduled-signal-constructors)
+ 1. [Notification immediately before object deallocation](#notification-immediately-before-object-deallocation)
+ 1. [Extensible queue-based schedulers](#extensible-queue-based-schedulers)
+ 1. [GCD time values replaced with NSDate](#gcd-time-values-replaced-with-nsdate)
+ 1. [Windows and numbered buffers removed](#windows-and-numbered-buffers-removed)
+ 1. [NSTask extension removed](#nstask-extension-removed)
+ 1. [RACSubscriber class now private](#racsubscriber-class-now-private)
+
+**[Additions and improvements](#additions-and-improvements)**
+
+ 1. [Commands for UIButton](#commands-for-uibutton)
+ 1. [Signal for UIActionSheet button clicks](#signal-for-uiactionsheet-button-clicks)
+ 1. [Better documentation for asynchronous backtraces](#better-documentation-for-asynchronous-backtraces)
+ 1. [Fixed libextobjc duplicated symbols](#fixed-libextobjc-duplicated-symbols)
+ 1. [Bindings for UIKit classes](#bindings-for-uikit-classes)
+ 1. [Signal subscription side effects](#signal-subscription-side-effects)
+ 1. [Test scheduler](#test-scheduler)
+
+## Breaking changes
+
+### Simplified and safer KVO
+
+`RACAble` and `RACAbleWithStart` have been replaced with a single
+[RACObserve](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/601) macro.
+`RACObserve` always starts with the current value of the property, and will
+[notice the
+deallocation](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/678) of `weak`
+properties (unlike vanilla KVO).
+
+Unlike the previous macros, which only required one argument for key paths on
+`self`, `RACObserve` always requires two arguments.
+
+**To update:**
+
+ * Replace uses of `RACAbleWithStart(self.key)` with `RACObserve(self, key)`.
+ * Replace uses of `RACAble(self.key)` with `[RACObserve(self, key) skip:1]` (if
+   skipping the starting value is necessary).
+
+### Safer commands with less state
+
+`RACCommand` has been [completely
+refactored](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/733). It is no
+longer a `RACSignal`, and the behavior of `-addSignalBlock:` has been moved to
+the initializer, making the class almost entirely immutable.
+
+Reflecting the most common use case, KVO-notifying properties have been changed
+into signals instead. During the change, `canExecute` was also renamed to
+`enabled`, which should make its purpose more obvious for binding to the UI.
+
+In addition, changes to `executing`, `errors`, and `enabled` are now guaranteed
+to fire on the main thread, so UI observers no longer [run in the background
+unexpectedly](https://github.com/ReactiveCocoa/ReactiveCocoa/issues/533).
+
+All together, these improvements should make `RACCommand` more composable and
+less imperative, so it fits into the framework better.
+
+**To update:**
+
+ * Move execution logic from `-addSignalBlock:` or `-subscribeNext:` into the
+   `signalBlock` passed to the initializer.
+ * Instead of subscribing to the result of `-addSignalBlock:`, subscribe to
+   `executionSignals` or the result of `-execute:` instead.
+ * Replace uses of `RACAbleWithStart(command, executing)` with
+   `command.executing`.
+ * Replace uses of `RACAbleWithStart(command, canExecute)` with
+   `command.enabled`.
+ * Remove uses of `deliverOn:RACScheduler.mainThreadScheduler` on
+   `RACCommand` properties, as they are now unnecessary.
+
+### Fallback nil values for RAC macro
+
+The `RAC` macro now [always
+requires](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/670) two or three
+arguments:
+
+ 1. The object to bind to.
+ 1. The key path to set when new values are sent.
+ 1. (Optional) A value to set when `nil` is sent on the signal.
+
+This is necessary to avoid a `-setNilValueForKey:` exception when observing
+a primitive property _through_ an intermediate object which gets set to `nil`.
+
+This is not actually a change in key-value observing behavior — it's a caveat
+with KVO regardless — but `RACObserve` makes it more prominent, because the
+deallocation of `weak` properties will be considered a change to `nil`.
+
+**To update:**
+
+ * Replace uses of `RAC(self.objectProperty)` with `RAC(self, objectProperty)`.
+ * When binding a signal that might send nil (like a key path observation) to
+   a primitive property, provide a default value: `RAC(self, integerProperty, @5)`
+
+### Explicit schedulers for time-based operators
+
+`-bufferWithTime:`, `+interval:`, and `-timeout:` have been unintuitive and
+error-prone because of their implicit use of a background scheduler.
+
+All of the aforementioned methods now require [a scheduler
+argument](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/588), so that it's
+clear how events should be delivered.
+
+**To update:**
+
+ * To match the previous behavior exactly, pass in `[RACScheduler scheduler]`.
+   Note that this creates a _new_ background scheduler for events to arrive upon.
+ * If you were already using `-deliverOn:` to force one of the above operators
+   to deliver onto a specific scheduler, you can eliminate that hop and pass the
+   scheduler into the operator directly.
+
+### More powerful selector signals
+
+`-rac_signalForSelector:` has been [completely
+refactored](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/590) to support
+listening for invocations of existing methods, new and existing methods with
+multiple arguments, and existing methods with return values.
+
+`+rac_signalForSelector:` (the class method variant) was removed, because
+swizzling class methods is dangerous and difficult to do correctly.
+
+**To update:**
+
+ * Most existing uses of `-rac_signalForSelector:` shouldn't require
+   any changes. However, the `super` implementation (if available) of any targeted selector will
+   now be invoked, where it wasn't previously. Verify that existing uses can
+   handle this case.
+ * Replace uses of `+rac_signalForSelector:` by implementing the class method
+   and sending arguments onto a `RACSubject` instead.
+
+### Simpler two-way bindings
+
+`RACPropertySubject` and `RACBinding` have been
+[replaced](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/695) with
+`RACChannel` and `RACChannelTerminal`. Similarly, `RACObservablePropertySubject`
+has been replaced with `RACKVOChannel`.
+
+In addition to slightly better terminology and more obvious usage, channels only
+offer two-way bindings by default, which is a simplification over the previous N-way binding
+interface.
+
+Because of the sweeping conceptual changes, the old APIs have been completely
+removed without deprecation.
+
+**To update:**
+
+ * Instead of creating a `RACPropertySubject`, create a `RACChannel`. Replace
+   N-way property subjects (where N is greater than 2) with multiple
+   `RACChannel`s.
+ * Instead of creating a `RACObservablePropertySubject`, create
+   a `RACKVOChannel` or use the `RACChannelTo` macro.
+ * Replace uses of `RACBinding` with `RACChannelTerminal`.
+ * Replace uses of `RACBind(self.objectProperty)` with `RACChannelTo(self,
+   objectProperty)`. Add a default value for primitive properties:
+   `RACChannelTo(self, integerProperty, @5)`
+ * Replace uses of `-bindTo:` with the explicit subscription of two endpoints:
+
+```objc
+[binding1.followingEndpoint subscribe:binding2.leadingEndpoint];
+[[binding2.leadingEndpoint skip:1] subscribe:binding1.followingEndpoint];
+```
+
+### Better bindings for AppKit
+
+`-rac_bind:toObject:withKeyPath:` and related methods have been
+[replaced](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/638) with
+`-rac_channelToBinding:options:`, which returns a `RACChannelTerminal` that can be used as
+a two-way binding or a one-way signal.
+
+**To update:**
+
+ * If possible, refactor code to use the new `RACChannel` interface. This
+   bridges Cocoa Bindings with the full power of ReactiveCocoa.
+ * For a direct conversion, use `-bind:toObject:withKeyPath:options:` with the
+   following options:
+    1. `@{ NSContinuouslyUpdatesValueBindingOption: @YES }` for `-rac_bind:toObject:withKeyPath:`
+    1. `@{ NSContinuouslyUpdatesValueBindingOption: @YES, NSNullPlaceholderBindingOption: nilValue }` for `-rac_bind:toObject:withKeyPath:nilValue:`
+    1. `@{ NSContinuouslyUpdatesValueBindingOption: @YES, NSValueTransformerBindingOption: valueTransformer }` for `-rac_bind:toObject:withKeyPath:transform:`
+    1. `@{ NSContinuouslyUpdatesValueBindingOption: @YES, NSValueTransformerBindingOption: NSNegateBooleanTransformerName }` for `-rac_bind:toObject:withNegatedKeyPath:`
+
+### More obvious sequencing operator
+
+To make the sequencing and transformation operators less confusing,
+`-sequenceMany:` has been removed, and `-sequenceNext:` has been
+[renamed](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/635) to `-then:`.
+
+**To update:**
+
+ * Replace uses of `-sequenceMany:` with `-flattenMap:` and a block that doesn't
+   use its argument.
+ * Replace uses of `-sequenceNext:` with `-then:`.
+
+### Renamed signal binding method
+
+`-toProperty:onObject:` and `-[NSObject rac_deriveProperty:from:]` have been
+[combined](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/617) into a new
+`-[RACSignal setKeyPath:onObject:nilValue:]` method.
+
+The `nilValue` parameter was added in parallel with the
+[RAC](#fallback-nil-values-for-rac-macro) macro, but the semantics are otherwise
+identical.
+
+**To update:**
+
+ * Replace `-toProperty:onObject:` and `-rac_deriveProperty:from:` with
+   `-setKeyPath:onObject:`.
+ * When binding a signal that might send nil (like a key path observation) to
+   a primitive property, provide a default value: `[signal setKeyPath:@"integerProperty" onObject:self nilValue:@5]`
+
+### Consistent selector lifting
+
+In the interests of [parametricity](http://en.wikipedia.org/wiki/Parametricity),
+`-rac_liftSelector:withObjects:` has been
+[replaced](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/609) with
+`-rac_liftSelector:withSignals:`, which requires all arguments to be signals.
+This makes usage more consistent.
+
+`-rac_liftBlock:withArguments:` has been removed, because it's redundant with
+`RACSignal` operators.
+
+The `-rac_lift` proxy has also been removed, because there's no way to [make it
+consistent](https://github.com/ReactiveCocoa/ReactiveCocoa/issues/520) in the
+same way.
+
+**To update:**
+
+ * Wrap non-signal arguments with `+[RACSignal return:]` and add a nil
+   terminator.
+ * Replace block lifting with `+combineLatest:reduce:`.
+ * Replace uses of `-rac_lift` with `-rac_liftSelector:withSignals:`.
+
+### Renamed scheduled signal constructors
+
+`+start:`, `+startWithScheduler:block`, and `+startWithScheduler:subjectBlock:`
+have been combined into a single
+[+startEagerlyWithScheduler:block:](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/536)
+constructor.
+
+The key improvements here are a more intuitive name, a required `RACScheduler`
+to make it clear where the block is executed, and use of `<RACSubscriber>`
+instead of `RACSubject` to make it more obvious how to use the block argument.
+
+**To update:**
+
+ * Use `[RACScheduler scheduler]` to match the previous implicit scheduling
+   behavior of `+start:`.
+ * Refactor blocks that return values and set `success`/`error`, to send events
+   to the given `<RACSubscriber>` instead.
+
+### Notification immediately before object deallocation
+
+`-rac_didDeallocSignal` has been
+[removed](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/585) in favor of
+[-rac_willDeallocSignal](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/580),
+because most teardown should happen _before_ the object becomes invalid.
+
+`-rac_addDeallocDisposable:` has also been
+[removed](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/586) in favor of
+using the object's `rac_deallocDisposable` directly.
+
+**To update:**
+
+ * Replace uses of `-rac_didDeallocSignal` with `rac_willDeallocSignal`.
+ * Replace uses of `-rac_addDeallocDisposable:` by invoking `-addDisposable:` on
+   the object's `rac_deallocDisposable` instead.
+
+### Extensible queue-based schedulers
+
+`RACQueueScheduler` has been [exposed as a public
+class](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/561), so consumers can create
+their own scheduler implementations using GCD queues.
+
+The
+[RACTargetQueueScheduler](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/561)
+subclass replaces the `+schedulerWithQueue:name:` method.
+
+**To update:**
+
+Replace uses of `+schedulerWithQueue:name:` with `-[RACTargetQueueScheduler initWithName:targetQueue:]`.
+
+### GCD time values replaced with NSDate
+
+`NSDate` now [replaces](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/664)
+`dispatch_time_t` values in `RACScheduler`, because dates are easier to use, more
+convertible to other formats, and can be used to implement a [virtualized time
+scheduler](https://github.com/ReactiveCocoa/ReactiveCocoa/issues/171).
+
+**To update:**
+
+Replace `dispatch_time_t` calculations with `NSDate`.
+
+### Windows and numbered buffers removed
+
+`-windowWithStart:close:` and `-buffer:` have been
+[removed](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/616) because
+they're not well-tested, and their functionality can be achieved with other
+operators.
+
+`-bufferWithTime:` is still supported.
+
+**To update:**
+
+ * Refactor uses of `-windowWithStart:close:` with different patterns.
+ * Replace uses of `-buffer:` with [take, collect, and
+   repeat](https://github.com/ReactiveCocoa/ReactiveCocoa/issues/587).
+
+### NSTask extension removed
+
+`NSTask+RACSupport` has been
+[removed](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/556), because it
+was buggy and unsupported.
+
+**To update:**
+
+Use a vanilla `NSTask`, and send events onto `RACSubject`s instead.
+
+### RACSubscriber class now private
+
+The `RACSubscriber` class (not to be confused with the protocol) should never be
+used directly, so it has been
+[hidden](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/584).
+
+**To update:**
+
+Replace uses of `RACSubscriber` with `id<RACSubscriber>` or `RACSubject`.
+
+## Additions and improvements
+
+### Commands for UIButton
+
+`UIButton` now has a [rac_command
+property](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/558).
+
+Any command set will be executed when the button is tapped, and the button will
+be disabled whenever the command is unable to execute.
+
+### Signal for UIActionSheet button clicks
+
+`UIActionSheet` now has a [rac_buttonClickedSignal
+property](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/611), which will
+fire whenever one of the sheet's buttons is clicked.
+
+### Better documentation for asynchronous backtraces
+
+Documentation has been
+[added](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/680) to
+`RACBacktrace` explaining how to start collecting backtraces and print them out
+in the debugger.
+
+The `+captureBacktrace…` methods have been renamed to `+backtrace…`, and
+`+printBacktrace` has been removed in favor of using `po [RACBacktrace backtrace]`
+from the debugger.
+
+The `rac_` GCD functions which collect backtraces have also been exposed,
+primarily for use on iOS.
+
+### Fixed libextobjc duplicated symbols
+
+If [libextobjc](https://github.com/jspahrsummers/libextobjc) was used in
+a project that statically linked ReactiveCocoa, duplicate symbol errors could
+result.
+
+To avoid this issue, RAC now
+[renames](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/612) the
+libextobjc symbols that it uses.
+
+### Bindings for UIKit classes
+
+RACChannel interfaces have been [added](https://github.com/ReactiveCocoa/pull/686)
+to many UIKit classes, greatly simplifying glue code between your models and views.
+
+For example, assuming you want to bind a `person` model's `name` property:
+
+```objc
+UITextField *nameField = ...;
+RACChannelTerminal *nameTerminal = RACChannelTo(model, name);
+RACChannelTerminal *nameFieldTerminal = [nameField rac_newTextChannel];
+[nameTerminal subscribe:nameFieldTerminal];
+[nameFieldTerminal subscribe:nameTerminal];
+```
+
+You may also bind multiple controls to the same property, for example a UISlider for
+coarse editing and a UIStepper for fine-grained editing.
+
+### Signal subscription side effects
+
+`RACSignal` now has the
+[-initially:](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/685)
+operator, which executes a given block each time the signal is subscribed to.
+This is symmetric to `-finally:`.
+
+### Test scheduler
+
+`RACTestScheduler` is a [new kind](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/716) of scheduler that
+virtualizes time. Enqueued blocks can be stepped through at any pace, no matter
+how far in the future they're scheduled for, making it easy to test time-based
+behavior without actually waiting in unit tests.
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000..9956451
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,23 @@
+We love that you're interested in contributing to this project!
+
+To make the process as painless as possible, we have just a couple of guidelines
+that should make life easier for everyone involved.
+
+## Prefer Pull Requests
+
+If you know exactly how to implement the feature being suggested or fix the bug
+being reported, please open a pull request instead of an issue. Pull requests are easier than
+patches or inline code blocks for discussing and merging the changes.
+
+If you can't make the change yourself, please open an issue after making sure
+that one isn't already logged.
+
+## Contributing Code
+
+Fork this repository, make it awesomer (preferably in a branch named for the
+topic), send a pull request!
+
+All code contributions should match our [coding
+conventions](https://github.com/github/objective-c-conventions).
+
+Thanks for contributing! :boom::camel:
diff --git a/Documentation/BasicOperators.md b/Documentation/BasicOperators.md
new file mode 100644
index 0000000..03a4ca0
--- /dev/null
+++ b/Documentation/BasicOperators.md
@@ -0,0 +1,364 @@
+# Basic Operators
+
+This document explains some of the most common operators used in ReactiveCocoa,
+and includes examples demonstrating their use.
+
+Operators that apply to [sequences][Sequences] _and_ [signals][Signals] are
+known as [stream][Streams] operators.
+
+**[Performing side effects with signals](#performing-side-effects-with-signals)**
+
+ 1. [Subscription](#subscription)
+ 1. [Injecting effects](#injecting-effects)
+
+**[Transforming streams](#transforming-streams)**
+
+ 1. [Mapping](#mapping)
+ 1. [Filtering](#filtering)
+
+**[Combining streams](#combining-streams)**
+
+ 1. [Concatenating](#concatenating)
+ 1. [Flattening](#flattening)
+ 1. [Mapping and flattening](#mapping-and-flattening)
+
+**[Combining signals](#combining-signals)**
+
+ 1. [Sequencing](#sequencing)
+ 1. [Merging](#merging)
+ 1. [Combining latest values](#combining-latest-values)
+ 1. [Switching](#switching)
+
+## Performing side effects with signals
+
+Most signals start out "cold," which means that they will not do any work until
+[subscription](#subscription).
+
+Upon subscription, a signal or its [subscribers][Subscription] can perform _side
+effects_, like logging to the console, making a network request, updating the
+user interface, etc.
+
+Side effects can also be [injected](#injecting-effects) into a signal, where
+they won't be performed immediately, but will instead take effect with each
+subscription later.
+
+### Subscription
+
+The [-subscribe…][RACSignal] methods give you access to the current and future values in a signal:
+
+```objc
+RACSignal *letters = [@"A B C D E F G H I" componentsSeparatedByString:@" "].rac_sequence.signal;
+
+// Outputs: A B C D E F G H I
+[letters subscribeNext:^(NSString *x) {
+    NSLog(@"%@", x);
+}];
+```
+
+For a cold signal, side effects will be performed once _per subscription_:
+
+```objc
+__block unsigned subscriptions = 0;
+
+RACSignal *loggingSignal = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) {
+    subscriptions++;
+    [subscriber sendCompleted];
+    return nil;
+}];
+
+// Outputs:
+// subscription 1
+[loggingSignal subscribeCompleted:^{
+    NSLog(@"subscription %u", subscriptions);
+}];
+
+// Outputs:
+// subscription 2
+[loggingSignal subscribeCompleted:^{
+    NSLog(@"subscription %u", subscriptions);
+}];
+```
+
+This behavior can be changed using a [connection][Connections].
+
+### Injecting effects
+
+The [-do…][RACSignal+Operations] methods add side effects to a signal without actually
+subscribing to it:
+
+```objc
+__block unsigned subscriptions = 0;
+
+RACSignal *loggingSignal = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) {
+    subscriptions++;
+    [subscriber sendCompleted];
+    return nil;
+}];
+
+// Does not output anything yet
+loggingSignal = [loggingSignal doCompleted:^{
+    NSLog(@"about to complete subscription %u", subscriptions);
+}];
+
+// Outputs:
+// about to complete subscription 1
+// subscription 1
+[loggingSignal subscribeCompleted:^{
+    NSLog(@"subscription %u", subscriptions);
+}];
+```
+
+## Transforming streams
+
+These operators transform a single stream into a new stream.
+
+### Mapping
+
+The [-map:][RACStream] method is used to transform the values in a stream, and
+create a new stream with the results:
+
+```objc
+RACSequence *letters = [@"A B C D E F G H I" componentsSeparatedByString:@" "].rac_sequence;
+
+// Contains: AA BB CC DD EE FF GG HH II
+RACSequence *mapped = [letters map:^(NSString *value) {
+    return [value stringByAppendingString:value];
+}];
+```
+
+### Filtering
+
+The [-filter:][RACStream] method uses a block to test each value, including it
+into the resulting stream only if the test passes:
+
+```objc
+RACSequence *numbers = [@"1 2 3 4 5 6 7 8 9" componentsSeparatedByString:@" "].rac_sequence;
+
+// Contains: 2 4 6 8
+RACSequence *filtered = [numbers filter:^ BOOL (NSString *value) {
+    return (value.intValue % 2) == 0;
+}];
+```
+
+## Combining streams
+
+These operators combine multiple streams into a single new stream.
+
+### Concatenating
+
+The [-concat:][RACStream] method appends one stream's values to another:
+
+```objc
+RACSequence *letters = [@"A B C D E F G H I" componentsSeparatedByString:@" "].rac_sequence;
+RACSequence *numbers = [@"1 2 3 4 5 6 7 8 9" componentsSeparatedByString:@" "].rac_sequence;
+
+// Contains: A B C D E F G H I 1 2 3 4 5 6 7 8 9
+RACSequence *concatenated = [letters concat:numbers];
+```
+
+### Flattening
+
+The [-flatten][RACStream] operator is applied to a stream-of-streams, and
+combines their values into a single new stream.
+
+Sequences are [concatenated](#concatenating):
+
+```objc
+RACSequence *letters = [@"A B C D E F G H I" componentsSeparatedByString:@" "].rac_sequence;
+RACSequence *numbers = [@"1 2 3 4 5 6 7 8 9" componentsSeparatedByString:@" "].rac_sequence;
+RACSequence *sequenceOfSequences = @[ letters, numbers ].rac_sequence;
+
+// Contains: A B C D E F G H I 1 2 3 4 5 6 7 8 9
+RACSequence *flattened = [sequenceOfSequences flatten];
+```
+
+Signals are [merged](#merging):
+
+```objc
+RACSubject *letters = [RACSubject subject];
+RACSubject *numbers = [RACSubject subject];
+RACSignal *signalOfSignals = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) {
+    [subscriber sendNext:letters];
+    [subscriber sendNext:numbers];
+    [subscriber sendCompleted];
+    return nil;
+}];
+
+RACSignal *flattened = [signalOfSignals flatten];
+
+// Outputs: A 1 B C 2
+[flattened subscribeNext:^(NSString *x) {
+    NSLog(@"%@", x);
+}];
+
+[letters sendNext:@"A"];
+[numbers sendNext:@"1"];
+[letters sendNext:@"B"];
+[letters sendNext:@"C"];
+[numbers sendNext:@"2"];
+```
+
+### Mapping and flattening
+
+[Flattening](#flattening) isn't that interesting on its own, but understanding
+how it works is important for [-flattenMap:][RACStream].
+
+`-flattenMap:` is used to transform each of a stream's values into _a new
+stream_. Then, all of the streams returned will be flattened down into a single
+stream. In other words, it's [-map:](#mapping) followed by [-flatten](#flattening).
+
+This can be used to extend or edit sequences:
+
+```objc
+RACSequence *numbers = [@"1 2 3 4 5 6 7 8 9" componentsSeparatedByString:@" "].rac_sequence;
+
+// Contains: 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9
+RACSequence *extended = [numbers flattenMap:^(NSString *num) {
+    return @[ num, num ].rac_sequence;
+}];
+
+// Contains: 1_ 3_ 5_ 7_ 9_
+RACSequence *edited = [numbers flattenMap:^(NSString *num) {
+    if (num.intValue % 2 == 0) {
+        return [RACSequence empty];
+    } else {
+        NSString *newNum = [num stringByAppendingString:@"_"];
+        return [RACSequence return:newNum]; 
+    }
+}];
+```
+
+Or create multiple signals of work which are automatically recombined:
+
+```objc
+RACSignal *letters = [@"A B C D E F G H I" componentsSeparatedByString:@" "].rac_sequence.signal;
+
+[[letters
+    flattenMap:^(NSString *letter) {
+        return [database saveEntriesForLetter:letter];
+    }]
+    subscribeCompleted:^{
+        NSLog(@"All database entries saved successfully.");
+    }];
+```
+
+## Combining signals
+
+These operators combine multiple signals into a single new [RACSignal][].
+
+### Sequencing
+
+[-then:][RACSignal+Operations] starts the original signal,
+waits for it to complete, and then only forwards the values from a new signal:
+
+```objc
+RACSignal *letters = [@"A B C D E F G H I" componentsSeparatedByString:@" "].rac_sequence.signal;
+
+// The new signal only contains: 1 2 3 4 5 6 7 8 9
+//
+// But when subscribed to, it also outputs: A B C D E F G H I
+RACSignal *sequenced = [[letters
+    doNext:^(NSString *letter) {
+        NSLog(@"%@", letter);
+    }]
+    then:^{
+        return [@"1 2 3 4 5 6 7 8 9" componentsSeparatedByString:@" "].rac_sequence.signal;
+    }];
+```
+
+This is most useful for executing all the side effects of one signal, then
+starting another, and only returning the second signal's values.
+
+### Merging
+
+The [+merge:][RACSignal+Operations] method will forward the values from many
+signals into a single stream, as soon as those values arrive:
+
+```objc
+RACSubject *letters = [RACSubject subject];
+RACSubject *numbers = [RACSubject subject];
+RACSignal *merged = [RACSignal merge:@[ letters, numbers ]];
+
+// Outputs: A 1 B C 2
+[merged subscribeNext:^(NSString *x) {
+    NSLog(@"%@", x);
+}];
+
+[letters sendNext:@"A"];
+[numbers sendNext:@"1"];
+[letters sendNext:@"B"];
+[letters sendNext:@"C"];
+[numbers sendNext:@"2"];
+```
+
+### Combining latest values
+
+The [+combineLatest:][RACSignal+Operations] and `+combineLatest:reduce:` methods
+will watch multiple signals for changes, and then send the latest values from
+_all_ of them when a change occurs:
+
+```objc
+RACSubject *letters = [RACSubject subject];
+RACSubject *numbers = [RACSubject subject];
+RACSignal *combined = [RACSignal
+    combineLatest:@[ letters, numbers ]
+    reduce:^(NSString *letter, NSString *number) {
+        return [letter stringByAppendingString:number];
+    }];
+
+// Outputs: B1 B2 C2 C3
+[combined subscribeNext:^(id x) {
+    NSLog(@"%@", x);
+}];
+
+[letters sendNext:@"A"];
+[letters sendNext:@"B"];
+[numbers sendNext:@"1"];
+[numbers sendNext:@"2"];
+[letters sendNext:@"C"];
+[numbers sendNext:@"3"];
+```
+
+Note that the combined signal will only send its first value when all of the
+inputs have sent at least one. In the example above, `@"A"` was never
+forwarded because `numbers` had not sent a value yet.
+
+### Switching
+
+The [-switchToLatest][RACSignal+Operations] operator is applied to
+a signal-of-signals, and always forwards the values from the latest signal:
+
+```objc
+RACSubject *letters = [RACSubject subject];
+RACSubject *numbers = [RACSubject subject];
+RACSubject *signalOfSignals = [RACSubject subject];
+
+RACSignal *switched = [signalOfSignals switchToLatest];
+
+// Outputs: A B 1 D
+[switched subscribeNext:^(NSString *x) {
+    NSLog(@"%@", x);
+}];
+
+[signalOfSignals sendNext:letters];
+[letters sendNext:@"A"];
+[letters sendNext:@"B"];
+
+[signalOfSignals sendNext:numbers];
+[letters sendNext:@"C"];
+[numbers sendNext:@"1"];
+
+[signalOfSignals sendNext:letters];
+[numbers sendNext:@"2"];
+[letters sendNext:@"D"];
+```
+
+[Connections]: FrameworkOverview.md#connections
+[RACSequence]: ../ReactiveCocoaFramework/ReactiveCocoa/RACSequence.h
+[RACSignal]: ../ReactiveCocoaFramework/ReactiveCocoa/RACSignal.h
+[RACSignal+Operations]: ../ReactiveCocoaFramework/ReactiveCocoa/RACSignal+Operations.h
+[RACStream]: ../ReactiveCocoaFramework/ReactiveCocoa/RACStream.h
+[Sequences]: FrameworkOverview.md#sequences
+[Signals]: FrameworkOverview.md#signals
+[Streams]: FrameworkOverview.md#streams
+[Subscription]: FrameworkOverview.md#subscription
diff --git a/Documentation/DesignGuidelines.md b/Documentation/DesignGuidelines.md
new file mode 100644
index 0000000..106e845
--- /dev/null
+++ b/Documentation/DesignGuidelines.md
@@ -0,0 +1,751 @@
+# Design Guidelines
+
+This document contains guidelines for projects that want to make use of
+ReactiveCocoa. The content here is heavily inspired by the [Rx Design
+Guidelines](http://blogs.msdn.com/b/rxteam/archive/2010/10/28/rx-design-guidelines.aspx).
+
+This document assumes basic familiarity
+with the features of ReactiveCocoa. The [Framework Overview][] is a better
+resource for getting up to speed on the functionality provided by RAC.
+
+**[The RACSequence contract](#the-racsequence-contract)**
+
+ 1. [Evaluation occurs lazily by default](#evaluation-occurs-lazily-by-default)
+ 1. [Evaluation blocks the caller](#evaluation-blocks-the-caller)
+ 1. [Side effects occur only once](#side-effects-occur-only-once)
+
+**[The RACSignal contract](#the-racsignal-contract)**
+
+ 1. [Signal events are serialized](#signal-events-are-serialized)
+ 1. [Subscription will always occur on a scheduler](#subscription-will-always-occur-on-a-scheduler)
+ 1. [Errors are propagated immediately](#errors-are-propagated-immediately)
+ 1. [Side effects occur for each subscription](#side-effects-occur-for-each-subscription)
+ 1. [Subscriptions are automatically disposed upon completion or error](#subscriptions-are-automatically-disposed-upon-completion-or-error)
+ 1. [Disposal cancels in-progress work and cleans up resources](#disposal-cancels-in-progress-work-and-cleans-up-resources)
+
+**[Best practices](#best-practices)**
+
+ 1. [Use descriptive declarations for methods and properties that return a signal](#use-descriptive-declarations-for-methods-and-properties-that-return-a-signal)
+ 1. [Indent stream operations consistently](#indent-stream-operations-consistently)
+ 1. [Use the same type for all the values of a stream](#use-the-same-type-for-all-the-values-of-a-stream)
+ 1. [Avoid retaining streams for too long](#avoid-retaining-streams-for-too-long)
+ 1. [Process only as much of a stream as needed](#process-only-as-much-of-a-stream-as-needed)
+ 1. [Deliver signal events onto a known scheduler](#deliver-signal-events-onto-a-known-scheduler)
+ 1. [Switch schedulers in as few places as possible](#switch-schedulers-in-as-few-places-as-possible)
+ 1. [Make the side effects of a signal explicit](#make-the-side-effects-of-a-signal-explicit)
+ 1. [Share the side effects of a signal by multicasting](#share-the-side-effects-of-a-signal-by-multicasting)
+ 1. [Debug streams by giving them names](#debug-streams-by-giving-them-names)
+ 1. [Avoid explicit subscriptions and disposal](#avoid-explicit-subscriptions-and-disposal)
+ 1. [Avoid using subjects when possible](#avoid-using-subjects-when-possible)
+
+**[Implementing new operators](#implementing-new-operators)**
+
+ 1. [Prefer building on RACStream methods](#prefer-building-on-racstream-methods)
+ 1. [Compose existing operators when possible](#compose-existing-operators-when-possible)
+ 1. [Avoid introducing concurrency](#avoid-introducing-concurrency)
+ 1. [Cancel work and clean up all resources in a disposable](#cancel-work-and-clean-up-all-resources-in-a-disposable)
+ 1. [Do not block in an operator](#do-not-block-in-an-operator)
+ 1. [Avoid stack overflow from deep recursion](#avoid-stack-overflow-from-deep-recursion)
+
+## The RACSequence contract
+
+[RACSequence][] is a _pull-driven_ stream. Sequences behave similarly to
+built-in collections, but with a few unique twists.
+
+### Evaluation occurs lazily by default
+
+Sequences are evaluated lazily by default. For example, in this sequence:
+
+```objc
+NSArray *strings = @[ @"A", @"B", @"C" ];
+RACSequence *sequence = [strings.rac_sequence map:^(NSString *str) {
+    return [str stringByAppendingString:@"_"];
+}];
+```
+
+… no string appending is actually performed until the values of the sequence are
+needed. Accessing `sequence.head` will perform the concatenation of `A_`,
+accessing `sequence.tail.head` will perform the concatenation of `B_`, and so
+on.
+
+This generally avoids performing unnecessary work (since values that are never
+used are never calculated), but means that sequence processing [should be
+limited only to what's actually
+needed](#process-only-as-much-of-a-stream-as-needed).
+
+Once evaluated, the values in a sequence are memoized and do not need to be
+recalculated. Accessing `sequence.head` multiple times will only do the work of
+one string concatenation.
+
+If lazy evaluation is undesirable – for instance, because limiting memory usage
+is more important than avoiding unnecessary work – the
+[eagerSequence][RACSequence] property can be used to force a sequence (and any
+sequences derived from it afterward) to evaluate eagerly.
+
+### Evaluation blocks the caller
+
+Regardless of whether a sequence is lazy or eager, evaluation of any part of
+a sequence will block the calling thread until completed. This is necessary
+because values must be synchronously retrieved from a sequence.
+
+If evaluating a sequence is expensive enough that it might block the thread for
+a significant amount of time, consider creating a signal with
+[-signalWithScheduler:][RACSequence] and using that instead.
+
+### Side effects occur only once
+
+When the block passed to a sequence operator involves side effects, it is
+important to realize that those side effects will only occur once per value
+– namely, when the value is evaluated:
+
+```objc
+NSArray *strings = @[ @"A", @"B", @"C" ];
+RACSequence *sequence = [strings.rac_sequence map:^(NSString *str) {
+    NSLog(@"%@", str);
+    return [str stringByAppendingString:@"_"];
+}];
+
+// Logs "A" during this call.
+NSString *concatA = sequence.head;
+
+// Logs "B" during this call.
+NSString *concatB = sequence.tail.head;
+
+// Does not log anything.
+NSString *concatB2 = sequence.tail.head;
+
+RACSequence *derivedSequence = [sequence map:^(NSString *str) {
+    return [@"_" stringByAppendingString:str];
+}];
+
+// Still does not log anything, because "B_" was already evaluated, and the log
+// statement associated with it will never be re-executed.
+NSString *concatB3 = derivedSequence.tail.head;
+```
+
+## The RACSignal contract
+
+[RACSignal][] is a _push-driven_ stream with a focus on asynchronous event
+delivery through _subscriptions_. For more information about signals and
+subscriptions, see the [Framework Overview][].
+
+### Signal events are serialized
+
+A signal may choose to deliver its events on any thread. Consecutive events are
+even allowed to arrive on different threads or schedulers, unless explicitly
+[delivered onto a particular
+scheduler](#deliver-signal-events-onto-a-known-scheduler).
+
+However, RAC guarantees that no two signal events will ever arrive concurrently.
+While an event is being processed, no other events will be delivered. The
+senders of any other events will be forced to wait until the current event has
+been handled.
+
+Most notably, this means that the blocks passed to
+[-subscribeNext:error:completed:][RACSignal] do not need to be synchronized with
+respect to each other, because they will never be invoked simultaneously.
+
+### Subscription will always occur on a scheduler
+
+To ensure consistent behavior for the `+createSignal:` and `-subscribe:`
+methods, each [RACSignal][] subscription is guaranteed to take place on
+a valid [RACScheduler][].
+
+If the subscriber's thread already has a [+currentScheduler][RACScheduler],
+scheduling takes place immediately; otherwise, scheduling occurs as soon as
+possible on a background scheduler. Note that the main thread is always
+associated with the [+mainThreadScheduler][RACScheduler], so subscription will
+always be immediate there.
+
+See the documentation for [-subscribe:][RACSignal] for more information.
+
+### Errors are propagated immediately
+
+In RAC, `error` events have exception semantics. When an error is sent on
+a signal, it will be immediately forwarded to all dependent signals, causing the
+entire chain to terminate.
+
+[Operators][RACSignal+Operations] whose primary purpose is to change
+error-handling behavior – like `-catch:`, `-catchTo:`, or `-materialize` – are
+obviously not subject to this rule.
+
+### Side effects occur for each subscription
+
+Each new subscription to a [RACSignal][] will trigger its side effects. This
+means that any side effects will happen as many times as subscriptions to the
+signal itself.
+
+Consider this example:
+```objc
+__block int aNumber = 0;
+
+// Signal that will have the side effect of incrementing `aNumber` block 
+// variable for each subscription before sending it.
+RACSignal *aSignal = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) {
+	aNumber++;
+	[subscriber sendNext:@(aNumber)];
+	[subscriber sendCompleted];
+	return nil;
+}];
+
+// This will print "subscriber one: 1"
+[aSignal subscribeNext:^(id x) {
+	NSLog(@"subscriber one: %@", x);
+}];
+
+// This will print "subscriber two: 2"
+[aSignal subscribeNext:^(id x) {
+	NSLog(@"subscriber two: %@", x);
+}];
+```
+
+Side effects are repeated for each subscription. The same applies to
+[stream][RACStream] and [signal][RACSignal+Operations] operators:
+
+```objc
+__block int missilesToLaunch = 0;
+
+// Signal that will have the side effect of changing `missilesToLaunch` on
+// subscription.
+RACSignal *processedSignal = [[RACSignal
+    return:@"missiles"]
+	map:^(id x) {
+		missilesToLaunch++;
+		return [NSString stringWithFormat:@"will launch %d %@", missilesToLaunch, x];
+	}];
+
+// This will print "First will launch 1 missiles"
+[processedSignal subscribeNext:^(id x) {
+	NSLog(@"First %@", x);
+}];
+
+// This will print "Second will launch 2 missiles"
+[processedSignal subscribeNext:^(id x) {
+	NSLog(@"Second %@", x);
+}];
+```
+
+To suppress this behavior and have multiple subscriptions to a signal execute
+its side effects only once, a signal can be 
+[multicasted](#share-the-side-effects-of-a-signal-by-multicasting).
+
+Side effects can be insidious and produce problems that are difficult to
+diagnose. For this reason it is suggested to 
+[make side effects explicit](#make-the-side-effects-of-a-signal-explicit) when 
+possible.
+
+### Subscriptions are automatically disposed upon completion or error
+
+When a [subscriber][RACSubscriber] is sent a `completed` or `error` event, the
+associated subscription will automatically be disposed. This behavior usually
+eliminates the need to manually dispose of subscriptions.
+
+See the [Memory Management][] document for more information about signal
+lifetime.
+
+### Disposal cancels in-progress work and cleans up resources
+
+When a subscription is disposed, manually or automatically, any in-progress or
+outstanding work associated with that subscription is gracefully cancelled as
+soon as possible, and any resources associated with the subscription are cleaned
+up.
+
+Disposing of the subscription to a signal representing a file upload, for
+example, would cancel any in-flight network request, and free the file data from
+memory.
+
+## Best practices
+
+The following recommendations are intended to help keep RAC-based code
+predictable, understandable, and performant.
+
+They are, however, only guidelines. Use best judgement when determining whether
+to apply the recommendations here to a given piece of code.
+
+### Use descriptive declarations for methods and properties that return a signal
+
+When a method or property has a return type of [RACSignal][], it can be
+difficult to understand the signal's semantics at a glance.
+
+There are three key questions that can inform a declaration:
+
+ 1. Is the signal _hot_ (already activated by the time it's returned to the
+    caller) or _cold_ (activated when subscribed to)?
+ 1. Will the signal include zero, one, or more values?
+ 1. Does the signal have side effects?
+
+**Hot signals without side effects** should typically be properties instead of
+methods. The use of a property indicates that no initialization is needed before
+subscribing to the signal's events, and that additional subscribers will not
+change the semantics. Signal properties should usually be named after events
+(e.g., `textChanged`).
+
+**Cold signals without side effects** should be returned from methods that have
+noun-like names (e.g., `-currentText`). A method declaration indicates that the
+signal might not be kept around, hinting that work is performed at the time of
+subscription. If the signal sends multiple values, the noun should be pluralized
+(e.g., `-currentModels`).
+
+**Signals with side effects** should be returned from methods that have
+verb-like names (e.g., `-logIn`). The verb indicates that the method is not
+idempotent and that callers must be careful to call it only when the side
+effects are desired. If the signal will send one or more values, include a noun
+that describes them (e.g., `-loadConfiguration`, `-fetchLatestEvents`).
+
+### Indent stream operations consistently
+
+It's easy for stream-heavy code to become very dense and confusing if not
+properly formatted. Use consistent indentation to highlight where chains of
+streams begin and end.
+
+When invoking a single method upon a stream, no additional indentation is
+necessary (block arguments aside):
+
+```objc
+RACStream *result = [stream startWith:@0];
+
+RACStream *result2 = [stream map:^(NSNumber *value) {
+    return @(value.integerValue + 1);
+}];
+```
+
+When transforming the same stream multiple times, ensure that all of the
+steps are aligned. Complex operators like [+zip:reduce:][RACStream] or
+[+combineLatest:reduce:][RACSignal+Operations] may be split over multiple lines
+for readability:
+
+```objc
+RACStream *result = [[[RACStream
+    zip:@[ firstStream, secondStream ]
+    reduce:^(NSNumber *first, NSNumber *second) {
+        return @(first.integerValue + second.integerValue);
+    }]
+    filter:^ BOOL (NSNumber *value) {
+        return value.integerValue >= 0;
+    }]
+    map:^(NSNumber *value) {
+        return @(value.integerValue + 1);
+    }];
+```
+
+Of course, streams nested within block arguments should start at the natural
+indentation of the block:
+
+```objc
+[[signal
+    then:^{
+        @strongify(self);
+
+        return [[self
+            doSomethingElse]
+            catch:^(NSError *error) {
+                @strongify(self);
+                [self presentError:error];
+
+                return [RACSignal empty];
+            }];
+    }]
+    subscribeCompleted:^{
+        NSLog(@"All done.");
+    }];
+```
+
+### Use the same type for all the values of a stream
+
+[RACStream][] (and, by extension, [RACSignal][] and [RACSequence][]) allows
+streams to be composed of heterogenous objects, just like Cocoa collections do.
+However, using different object types within the same stream complicates the use
+of operators and
+puts an additional burden on any consumers of that stream, who must be careful to
+only invoke supported methods.
+
+Whenever possible, streams should only contain objects of the same type.
+
+### Avoid retaining streams for too long
+
+Retaining any [RACStream][] longer than it's needed will cause any dependencies
+to be retained as well, potentially keeping memory usage much higher than it
+would be otherwise.
+
+A [RACSequence][] should be retained only for as long as the `head` of the
+sequence is needed. If the head will no longer be used, retain the `tail` of the
+node instead of the node itself.
+
+See the [Memory Management][] guide for more information on object lifetime.
+
+### Process only as much of a stream as needed
+
+As well as [consuming additional
+memory](#avoid-retaining-streams-for-too-long), unnecessarily
+keeping a stream or [RACSignal][] subscription alive can result in increased CPU
+usage, as unnecessary work is performed for results that will never be used.
+
+If only a certain number of values are needed from a stream, the
+[-take:][RACStream] operator can be used to retrieve only that many values, and
+then automatically terminate the stream immediately thereafter.
+
+Operators like `-take:` and [-takeUntil:][RACSignal+Operations] automatically propagate cancellation
+up the stack as well. If nothing else needs the rest of the values, any
+dependencies will be terminated too, potentially saving a significant amount of
+work.
+
+### Deliver signal events onto a known scheduler
+
+When a signal is returned from a method, or combined with such a signal, it can
+be difficult to know which thread events will be delivered upon. Although
+events are [guaranteed to be serial](#signal-events-are-serialized), sometimes
+stronger guarantees are needed, like when performing UI updates (which must
+occur on the main thread).
+
+Whenever such a guarantee is important, the [-deliverOn:][RACSignal+Operations]
+operator should be used to force a signal's events to arrive on a specific
+[RACScheduler][].
+
+### Switch schedulers in as few places as possible
+
+Notwithstanding the above, events should only be delivered to a specific
+[scheduler][RACScheduler] when absolutely necessary. Switching schedulers can
+introduce unnecessary delays and cause an increase in CPU load.
+
+Generally, the use of [-deliverOn:][RACSignal+Operations] should be restricted
+to the end of a signal chain – e.g., before subscription, or before the values
+are bound to a property.
+
+### Make the side effects of a signal explicit
+
+As much as possible, [RACSignal][] side effects should be avoided, because
+subscribers may find the [behavior of side
+effects](#side-effects-occur-for-each-subscription) unexpected.
+
+However, because Cocoa is predominantly imperative, it is sometimes useful to
+perform side effects when signal events occur. Although most [RACStream][] and
+[RACSignal][RACSignal+Operations] operators accept arbitrary blocks (which can
+contain side effects), the use of `-doNext:`, `-doError:`, and `-doCompleted:`
+will make side effects more explicit and self-documenting:
+
+```objc
+NSMutableArray *nexts = [NSMutableArray array];
+__block NSError *receivedError = nil;
+__block BOOL success = NO;
+
+RACSignal *bookkeepingSignal = [[[valueSignal
+    doNext:^(id x) {
+        [nexts addObject:x];
+    }]
+    doError:^(NSError *error) {
+        receivedError = error;
+    }]
+    doCompleted:^{
+        success = YES;
+    }];
+
+RAC(self, value) = bookkeepingSignal;
+```
+
+### Share the side effects of a signal by multicasting
+
+[Side effects occur for each
+subscription](#side-effects-occur-for-each-subscription) by default, but there
+are certain situations where side effects should only occur once – for example,
+a network request typically should not be repeated when a new subscriber is
+added.
+
+The `-publish` and `-multicast:` operators of [RACSignal][RACSignal+Operations]
+allow a single subscription to be shared to any number of subscribers by using
+a [RACMulticastConnection][]:
+
+```objc
+// This signal starts a new request on each subscription.
+RACSignal *networkRequest = [RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+    AFHTTPRequestOperation *operation = [client
+        HTTPRequestOperationWithRequest:request
+        success:^(AFHTTPRequestOperation *operation, id response) {
+            [subscriber sendNext:response];
+            [subscriber sendCompleted];
+        }
+        failure:^(AFHTTPRequestOperation *operation, NSError *error) {
+            [subscriber sendError:error];
+        }];
+
+    [client enqueueHTTPRequestOperation:operation];
+    return [RACDisposable disposableWithBlock:^{
+        [operation cancel];
+    }];
+}];
+
+// Starts a single request, no matter how many subscriptions `connection.signal`
+// gets. This is equivalent to the -replay operator, or similar to
+// +startEagerlyWithScheduler:block:.
+RACMulticastConnection *connection = [networkRequest multicast:[RACReplaySubject subject]];
+[connection connect];
+
+[connection.signal subscribeNext:^(id response) {
+    NSLog(@"subscriber one: %@", response);
+}];
+
+[connection.signal subscribeNext:^(id response) {
+    NSLog(@"subscriber two: %@", response);
+}];
+```
+
+### Debug streams by giving them names
+
+Every [RACStream][] has a `name` property to assist with debugging. A stream's
+`-description` includes its name, and all operators provided by RAC will
+automatically add to the name. This usually makes it possible to identify
+a stream from its default name alone.
+
+For example, this snippet:
+
+```objc
+RACSignal *signal = [[[RACObserve(self, username) 
+    distinctUntilChanged] 
+    take:3] 
+    filter:^(NSString *newUsername) {
+        return [newUsername isEqualToString:@"joshaber"];
+    }];
+
+NSLog(@"%@", signal);
+```
+
+… would log a name similar to `[[[RACObserve(self, username)] -distinctUntilChanged]
+-take: 3] -filter:`.
+
+Names can also be manually applied by using [-setNameWithFormat:][RACStream].
+
+[RACSignal][] also offers `-logNext`, `-logError`,
+`-logCompleted`, and `-logAll` methods, which will automatically log signal
+events as they occur, and include the name of the signal in the messages. This
+can be used to conveniently inspect a signal in real-time.
+
+### Avoid explicit subscriptions and disposal
+
+Although [-subscribeNext:error:completed:][RACSignal] and its variants are the
+most basic way to process a signal, their use can complicate code by
+being less declarative, encouraging the use of side effects, and potentially
+duplicating built-in functionality.
+
+Likewise, explicit use of the [RACDisposable][] class can quickly lead to
+a rat's nest of resource management and cleanup code.
+
+There are almost always higher-level patterns that can be used instead of manual
+subscriptions and disposal:
+
+ * The [RAC()][RAC] or [RACChannelTo()][RACChannelTo] macros can be used to bind
+   a signal to a property, instead of performing manual updates when changes
+   occur.
+ * The [-rac_liftSelector:withSignals:][NSObject+RACLifting] method can be used
+   to automatically invoke a selector when one or more signals fire.
+ * Operators like [-takeUntil:][RACSignal+Operations] can be used to
+   automatically dispose of a subscription when an event occurs (like a "Cancel"
+   button being pressed in the UI).
+
+Generally, the use of built-in [stream][RACStream] and
+[signal][RACSignal+Operations] operators will lead to simpler and less
+error-prone code than replicating the same behaviors in a subscription callback.
+
+### Avoid using subjects when possible
+
+[Subjects][] are a powerful tool for bridging imperative code
+into the world of signals, but, as the "mutable variables" of RAC, they can
+quickly lead to complexity when overused.
+
+Since they can be manipulated from anywhere, at any time, subjects often break
+the linear flow of stream processing and make logic much harder to follow. They
+also don't support meaningful
+[disposal](#disposal-cancels-in-progress-work-and-cleans-up-resources), which
+can result in unnecessary work.
+
+Subjects can usually be replaced with other patterns from ReactiveCocoa:
+
+ * Instead of feeding initial values into a subject, consider generating the
+   values in a [+createSignal:][RACSignal] block instead.
+ * Instead of delivering intermediate results to a subject, try combining the
+   output of multiple signals with operators like
+   [+combineLatest:][RACSignal+Operations] or [+zip:][RACStream].
+ * Instead of using subjects to share results with multiple subscribers,
+   [multicast](#share-the-side-effects-of-a-signal-by-multicasting) a base
+   signal instead.
+ * Instead of implementing an action method which simply controls a subject, use
+   a [command][RACCommand] or
+   [-rac_signalForSelector:][NSObject+RACSelectorSignal] instead.
+
+When subjects _are_ necessary, they should almost always be the "base" input
+for a signal chain, not used in the middle of one.
+
+## Implementing new operators
+
+RAC provides a long list of built-in operators for [streams][RACStream] and
+[signals][RACSignal+Operations] that should cover most use cases; however, RAC
+is not a closed system. It's entirely valid to implement additional operators
+for specialized uses, or for consideration in ReactiveCocoa itself.
+
+Implementing a new operator requires a careful attention to detail and a focus
+on simplicity, to avoid introducing bugs into the calling code.
+
+These guidelines cover some of the common pitfalls and help preserve the
+expected API contracts.
+
+### Prefer building on RACStream methods
+
+[RACStream][] offers a simpler interface than [RACSequence][] and [RACSignal][],
+and all stream operators are automatically applicable to sequences and signals
+as well.
+
+For these reasons, new operators should be implemented using only [RACStream][]
+methods whenever possible. The minimal required methods of the class, including
+`-bind:`, `+zipWith:`, and `-concat:`, are quite powerful, and many tasks can
+be accomplished without needing anything else.
+
+If a new [RACSignal][] operator needs to handle `error` and `completed` events,
+consider using the [-materialize][RACSignal+Operations] method to bring the
+events into the stream. All of the events of a materialized signal can be
+manipulated by stream operators, which helps minimize the use of non-stream
+operators.
+
+### Compose existing operators when possible
+
+Considerable thought has been put into the operators provided by RAC, and they
+have been validated through automated tests and through their real world use in
+other projects. An operator that has been written from scratch may not be as
+robust, or might not handle a special case that the built-in operators are aware
+of.
+
+To minimize duplication and possible bugs, use the provided operators as much as
+possible in a custom operator implementation. Generally, there should be very
+little code written from scratch.
+
+### Avoid introducing concurrency
+
+Concurrency is an extremely common source of bugs in programming. To minimize
+the potential for deadlocks and race conditions, operators should not
+concurrently perform their work.
+
+Callers always have the ability to subscribe or deliver events on a specific
+[RACScheduler][], and RAC offers powerful ways to [parallelize
+work][Parallelizing Independent Work] without making operators unnecessarily
+complex.
+
+### Cancel work and clean up all resources in a disposable
+
+When implementing a signal with the [+createSignal:][RACSignal] method, the
+provided block is expected to return a [RACDisposable][]. This disposable
+should:
+
+ * As soon as it is convenient, gracefully cancel any in-progress work that was
+   started by the signal.
+ * Immediately dispose of any subscriptions to other signals, thus triggering
+   their cancellation and cleanup code as well.
+ * Release any memory or other resources that were allocated by the signal.
+
+This helps fulfill [the RACSignal
+contract](#disposal-cancels-in-progress-work-and-cleans-up-resources).
+
+### Do not block in an operator
+
+Stream operators should return a new stream more-or-less immediately. Any work
+that the operator needs to perform should be part of evaluating the new stream,
+_not_ part of the operator invocation itself.
+
+```objc
+// WRONG!
+- (RACSequence *)map:(id (^)(id))block {
+    RACSequence *result = [RACSequence empty];
+    for (id obj in self) {
+        id mappedObj = block(obj);
+        result = [result concat:[RACSequence return:mappedObj]];
+    }
+
+    return result;
+}
+
+// Right!
+- (RACSequence *)map:(id (^)(id))block {
+    return [self flattenMap:^(id obj) {
+        id mappedObj = block(obj);
+        return [RACSequence return:mappedObj];
+    }];
+}
+```
+
+This guideline can be safely ignored when the purpose of an operator is to
+synchronously retrieve one or more values from a stream (like
+[-first][RACSignal+Operations]).
+
+### Avoid stack overflow from deep recursion
+
+Any operator that might recurse indefinitely should use the
+`-scheduleRecursiveBlock:` method of [RACScheduler][]. This method will
+transform recursion into iteration instead, preventing a stack overflow.
+
+For example, this would be an incorrect implementation of
+[-repeat][RACSignal+Operations], due to its potential to overflow the call stack
+and cause a crash:
+
+```objc
+- (RACSignal *)repeat {
+    return [RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+        RACCompoundDisposable *compoundDisposable = [RACCompoundDisposable compoundDisposable];
+
+        __block void (^resubscribe)(void) = ^{
+            RACDisposable *disposable = [self subscribeNext:^(id x) {
+                [subscriber sendNext:x];
+            } error:^(NSError *error) {
+                [subscriber sendError:error];
+            } completed:^{
+                resubscribe();
+            }];
+
+            [compoundDisposable addDisposable:disposable];
+        };
+
+        return compoundDisposable;
+    }];
+}
+```
+
+By contrast, this version will avoid a stack overflow:
+
+```objc
+- (RACSignal *)repeat {
+    return [RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+        RACCompoundDisposable *compoundDisposable = [RACCompoundDisposable compoundDisposable];
+
+        RACScheduler *scheduler = RACScheduler.currentScheduler ?: [RACScheduler scheduler];
+        RACDisposable *disposable = [scheduler scheduleRecursiveBlock:^(void (^reschedule)(void)) {
+            RACDisposable *disposable = [self subscribeNext:^(id x) {
+                [subscriber sendNext:x];
+            } error:^(NSError *error) {
+                [subscriber sendError:error];
+            } completed:^{
+                reschedule();
+            }];
+
+            [compoundDisposable addDisposable:disposable];
+        }];
+
+        [compoundDisposable addDisposable:disposable];
+        return compoundDisposable;
+    }];
+}
+```
+
+[Framework Overview]: FrameworkOverview.md
+[Memory Management]: MemoryManagement.md
+[NSObject+RACLifting]: ../ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACLifting.h
+[NSObject+RACSelectorSignal]: ../ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACSelectorSignal.h
+[RAC]: ../ReactiveCocoaFramework/ReactiveCocoa/RACSubscriptingAssignmentTrampoline.h
+[RACChannelTo]: ../ReactiveCocoaFramework/ReactiveCocoa/RACKVOChannel.h
+[RACCommand]: ../ReactiveCocoaFramework/ReactiveCocoa/RACCommand.h
+[RACDisposable]: ../ReactiveCocoaFramework/ReactiveCocoa/RACDisposable.h
+[RACEvent]: ../ReactiveCocoaFramework/ReactiveCocoa/RACEvent.h
+[RACMulticastConnection]: ../ReactiveCocoaFramework/ReactiveCocoa/RACMulticastConnection.h
+[RACObserve]: ../ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACPropertySubscribing.h
+[RACScheduler]: ../ReactiveCocoaFramework/ReactiveCocoa/RACScheduler.h
+[RACSequence]: ../ReactiveCocoaFramework/ReactiveCocoa/RACSequence.h
+[RACSignal]: ../ReactiveCocoaFramework/ReactiveCocoa/RACSignal.h
+[RACSignal+Operations]: ../ReactiveCocoaFramework/ReactiveCocoa/RACSignal+Operations.h
+[RACStream]: ../ReactiveCocoaFramework/ReactiveCocoa/RACStream.h
+[RACSubscriber]: ../ReactiveCocoaFramework/ReactiveCocoa/RACSubscriber.h
+[Subjects]: FrameworkOverview.md#subjects
+[Parallelizing Independent Work]: ../README.md#parallelizing-independent-work
diff --git a/Documentation/DifferencesFromRx.md b/Documentation/DifferencesFromRx.md
new file mode 100644
index 0000000..6e94e64
--- /dev/null
+++ b/Documentation/DifferencesFromRx.md
@@ -0,0 +1,59 @@
+# Differences from Rx
+
+ReactiveCocoa (RAC) is significantly inspired by .NET's [Reactive
+Extensions](http://msdn.microsoft.com/en-us/data/gg577609.aspx) (Rx), but it is not
+a direct port. Some concepts or interfaces presented in RAC may be initially
+confusing to a developer already familiar with Rx, but it's usually possible to
+express the same algorithms.
+
+Some of the differences, like the naming of methods and classes, are meant to
+keep RAC in line with existing Cocoa conventions. Other differences are intended
+as improvements over Rx, or may be inspired by other functional reactive
+programming paradigms (like the [Elm programming
+language](http://elm-lang.org)).
+
+Here, we'll attempt to document the high-level differences between RAC and Rx.
+
+## Interfaces
+
+RAC does not offer protocols that correspond to the `IEnumerable` and
+`IObservable` interfaces in .NET. Instead, the functionality is covered by three
+main classes:
+
+ * **[RACStream](https://github.com/ReactiveCocoa/ReactiveCocoa/blob/master/ReactiveCocoaFramework/ReactiveCocoa/RACStream.h)**
+   is an abstract class that implements stream operations using a few basic
+   primitives. The equivalents to generic LINQ operators can generally be found
+   on this class.
+ * **[RACSignal](https://github.com/ReactiveCocoa/ReactiveCocoa/blob/master/ReactiveCocoaFramework/ReactiveCocoa/RACSignal.h)**
+   is a concrete subclass of `RACStream` that implements a _push-driven_ stream,
+   much like `IObservable`. Time-based operators, or methods dealing with the
+   `completed` and `error` events, can be found on this class or in the
+   [RACSignal+Operations](https://github.com/ReactiveCocoa/ReactiveCocoa/blob/master/ReactiveCocoaFramework/ReactiveCocoa/RACSignal%2BOperations.h)
+   category upon it.
+ * **[RACSequence](https://github.com/ReactiveCocoa/ReactiveCocoa/blob/master/ReactiveCocoaFramework/ReactiveCocoa/RACSequence.h)**
+   is a concrete subclass of `RACStream` that implements a _pull-driven_ stream,
+   much like `IEnumerable`.
+
+## Names of Stream Operations
+
+RAC generally uses LINQ-style naming for its stream methods. Most of the
+exceptions are inspired by significantly better alternatives in Haskell or Elm.
+
+Notable differences include:
+
+ * `-map:` instead of `Select`
+ * `-filter:` instead of `Where`
+ * `-flatten` instead of `Merge`
+ * `-flattenMap:` instead of `SelectMany`
+
+LINQ operators that go by different names in RAC (but behave more or less
+equivalently) will be referenced from method documentation, like so:
+
+```objc
+// Maps `block` across the values in the receiver.
+//
+// This corresponds to the `Select` method in Rx.
+//
+// Returns a new stream with the mapped values.
+- (instancetype)map:(id (^)(id value))block;
+```
diff --git a/Documentation/FrameworkOverview.md b/Documentation/FrameworkOverview.md
new file mode 100644
index 0000000..174303d
--- /dev/null
+++ b/Documentation/FrameworkOverview.md
@@ -0,0 +1,216 @@
+# Framework Overview
+
+This document contains a high-level description of the different components
+within the ReactiveCocoa framework, and an attempt to explain how they work
+together and divide responsibilities. This is meant to be a starting point for
+learning about new modules and finding more specific documentation.
+
+For examples and help understanding how to use RAC, see the [README][] or
+the [Design Guidelines][].
+
+## Streams
+
+A **stream**, represented by the [RACStream][] abstract class, is any series of
+object values.
+
+Values may be available immediately or in the future, but must be retrieved
+sequentially. There is no way to retrieve the second value of a stream without
+evaluating or waiting for the first value.
+
+Streams are [monads][]. Among other things, this allows complex operations to be
+built on a few basic primitives (`-bind:` in particular). [RACStream][] also
+implements the equivalent of the [Monoid][] and [MonadZip][] typeclasses from
+[Haskell][].
+
+[RACStream][] isn't terribly useful on its own. Most streams are treated as
+[signals](#signals) or [sequences](#sequences) instead.
+
+## Signals
+
+A **signal**, represented by the [RACSignal][] class, is a _push-driven_
+[stream](#streams).
+
+Signals generally represent data that will be delivered in the future. As work
+is performed or data is received, values are _sent_ on the signal, which pushes
+them out to any subscribers. Users must [subscribe](#subscription) to a signal
+in order to access its values.
+
+Signals send three different types of events to their subscribers:
+
+ * The **next** event provides a new value from the stream. [RACStream][]
+   methods only operate on events of this type. Unlike Cocoa collections, it is
+   completely valid for a signal to include `nil`.
+ * The **error** event indicates that an error occurred before the signal could
+   finish. The event may include an `NSError` object that indicates what went
+   wrong. Errors must be handled specially – they are not included in the
+   stream's values.
+ * The **completed** event indicates that the signal finished successfully, and
+   that no more values will be added to the stream. Completion must be handled
+   specially – it is not included in the stream of values.
+
+The lifetime of a signal consists of any number of `next` events, followed by
+one `error` or `completed` event (but not both).
+
+### Subscription
+
+A **subscriber** is anything that is waiting or capable of waiting for events
+from a [signal](#signals). Within RAC, a subscriber is represented as any object
+that conforms to the [RACSubscriber][] protocol.
+
+A **subscription** is created through any call to
+[-subscribeNext:error:completed:][RACSignal], or one of the corresponding
+convenience methods. Technically, most [RACStream][] and
+[RACSignal][RACSignal+Operations] operators create subscriptions as well, but
+these intermediate subscriptions are usually an implementation detail.
+
+Subscriptions [retain their signals][Memory Management], and are automatically
+disposed of when the signal completes or errors. Subscriptions can also be
+[disposed of manually](#disposables).
+
+### Subjects
+
+A **subject**, represented by the [RACSubject][] class, is a [signal](#signals)
+that can be manually controlled.
+
+Subjects can be thought of as the "mutable" variant of a signal, much like
+`NSMutableArray` is for `NSArray`. They are extremely useful for bridging
+non-RAC code into the world of signals.
+
+For example, instead of handling application logic in block callbacks, the
+blocks can simply send events to a shared subject instead. The subject can then
+be returned as a [RACSignal][], hiding the implementation detail of the
+callbacks.
+
+Some subjects offer additional behaviors as well. In particular,
+[RACReplaySubject][] can be used to buffer events for future
+[subscribers](#subscription), like when a network request finishes before
+anything is ready to handle the result.
+
+### Commands
+
+A **command**, represented by the [RACCommand][] class, creates and subscribes
+to a signal in response to some action. This makes it easy to perform
+side-effecting work as the user interacts with the app.
+
+Usually the action triggering a command is UI-driven, like when a button is
+clicked. Commands can also be automatically disabled based on a signal, and this
+disabled state can be represented in a UI by disabling any controls associated
+with the command.
+
+On OS X, RAC adds a `rac_command` property to
+[NSButton][NSButton+RACCommandSupport] for setting up these behaviors
+automatically.
+
+### Connections
+
+A **connection**, represented by the [RACMulticastConnection][] class, is
+a [subscription](#subscription) that is shared between any number of
+subscribers.
+
+[Signals](#signals) are _cold_ by default, meaning that they start doing work
+_each_ time a new subscription is added. This behavior is usually desirable,
+because it means that data will be freshly recalculated for each subscriber, but
+it can be problematic if the signal has side effects or the work is expensive
+(for example, sending a network request).
+
+A connection is created through the `-publish` or `-multicast:` methods on
+[RACSignal][RACSignal+Operations], and ensures that only one underlying
+subscription is created, no matter how many times the connection is subscribed
+to. Once connected, the connection's signal is said to be _hot_, and the
+underlying subscription will remain active until _all_ subscriptions to the
+connection are [disposed](#disposables).
+
+## Sequences
+
+A **sequence**, represented by the [RACSequence][] class, is a _pull-driven_
+[stream](#streams).
+
+Sequences are a kind of collection, similar in purpose to `NSArray`. Unlike
+an array, the values in a sequence are evaluated _lazily_ (i.e., only when they
+are needed) by default, potentially improving performance if only part of
+a sequence is used. Just like Cocoa collections, sequences cannot contain `nil`.
+
+Sequences are similar to [Clojure's sequences][seq] ([lazy-seq][] in particular), or
+the [List][] type in [Haskell][].
+
+RAC adds a `-rac_sequence` method to most of Cocoa's collection classes,
+allowing them to be used as [RACSequences][RACSequence] instead.
+
+## Disposables
+
+The **[RACDisposable][]** class is used for cancellation and resource cleanup.
+
+Disposables are most commonly used to unsubscribe from a [signal](#signals).
+When a [subscription](#subscription) is disposed, the corresponding subscriber
+will not receive _any_ further events from the signal. Additionally, any work
+associated with the subscription (background processing, network requests, etc.)
+will be cancelled, since the results are no longer needed.
+
+For more information about cancellation, see the RAC [Design Guidelines][].
+
+## Schedulers
+
+A **scheduler**, represented by the [RACScheduler][] class, is a serial
+execution queue for [signals](#signals) to perform work or deliver their results upon.
+
+Schedulers are similar to Grand Central Dispatch queues, but schedulers support
+cancellation (via [disposables](#disposables)), and always execute serially.
+With the exception of the [+immediateScheduler][RACScheduler], schedulers do not
+offer synchronous execution. This helps avoid deadlocks, and encourages the use
+of [signal operators][RACSignal+Operations] instead of blocking work.
+
+[RACScheduler][] is also somewhat similar to `NSOperationQueue`, but schedulers
+do not allow tasks to be reordered or depend on one another.
+
+## Value types
+
+RAC offers a few miscellaneous classes for conveniently representing values in
+a [stream](#streams):
+
+ * **[RACTuple][]** is a small, constant-sized collection that can contain
+   `nil` (represented by `RACTupleNil`). It is generally used to represent
+   the combined values of multiple streams.
+ * **[RACUnit][]** is a singleton "empty" value. It is used as a value in
+   a stream for those times when more meaningful data doesn't exist.
+ * **[RACEvent][]** represents any [signal event](#signals) as a single value.
+   It is primarily used by the `-materialize` method of
+   [RACSignal][RACSignal+Operations].
+
+## Asynchronous Backtraces
+
+Because RAC-based code often involves asynchronous work and queue-hopping, the
+framework supports [capturing asynchronous backtraces][RACBacktrace] to make debugging
+easier.
+
+On OS X, backtraces can be automatically captured from any code, including
+system libraries.
+
+On iOS, only queue hops from within RAC and your project will be captured (but
+the information is still valuable).
+
+[Design Guidelines]: DesignGuidelines.md
+[Haskell]: http://www.haskell.org
+[lazy-seq]: http://clojure.github.com/clojure/clojure.core-api.html#clojure.core/lazy-seq
+[List]: http://www.haskell.org/ghc/docs/latest/html/libraries/base-4.6.0.1/Data-List.html
+[Memory Management]: MemoryManagement.md
+[monads]: http://en.wikipedia.org/wiki/Monad_(functional_programming)
+[Monoid]: http://www.haskell.org/ghc/docs/latest/html/libraries/base-4.6.0.1/Data-Monoid.html#t:Monoid
+[MonadZip]: http://www.haskell.org/ghc/docs/latest/html/libraries/base-4.6.0.1/Control-Monad-Zip.html#t:MonadZip
+[NSButton+RACCommandSupport]: ../ReactiveCocoaFramework/ReactiveCocoa/NSButton+RACCommandSupport.h
+[RACBacktrace]: ../ReactiveCocoaFramework/ReactiveCocoa/RACBacktrace.h
+[RACCommand]: ../ReactiveCocoaFramework/ReactiveCocoa/RACCommand.h
+[RACDisposable]: ../ReactiveCocoaFramework/ReactiveCocoa/RACDisposable.h
+[RACEvent]: ../ReactiveCocoaFramework/ReactiveCocoa/RACEvent.h
+[RACMulticastConnection]: ../ReactiveCocoaFramework/ReactiveCocoa/RACMulticastConnection.h
+[RACReplaySubject]: ../ReactiveCocoaFramework/ReactiveCocoa/RACReplaySubject.h
+[RACScheduler]: ../ReactiveCocoaFramework/ReactiveCocoa/RACScheduler.h
+[RACSequence]: ../ReactiveCocoaFramework/ReactiveCocoa/RACSequence.h
+[RACSignal]: ../ReactiveCocoaFramework/ReactiveCocoa/RACSignal.h
+[RACSignal+Operations]: ../ReactiveCocoaFramework/ReactiveCocoa/RACSignal+Operations.h
+[RACStream]: ../ReactiveCocoaFramework/ReactiveCocoa/RACStream.h
+[RACSubject]: ../ReactiveCocoaFramework/ReactiveCocoa/RACSubject.h
+[RACSubscriber]: ../ReactiveCocoaFramework/ReactiveCocoa/RACSubscriber.h
+[RACTuple]: ../ReactiveCocoaFramework/ReactiveCocoa/RACTuple.h
+[RACUnit]: ../ReactiveCocoaFramework/ReactiveCocoa/RACUnit.h
+[README]: ../README.md
+[seq]: http://clojure.org/sequences
diff --git a/Documentation/MemoryManagement.md b/Documentation/MemoryManagement.md
new file mode 100644
index 0000000..e442b1f
--- /dev/null
+++ b/Documentation/MemoryManagement.md
@@ -0,0 +1,139 @@
+# Memory Management
+
+ReactiveCocoa's memory management is quite complex, but the end result is that
+**you don't need to retain signals in order to process them**.
+
+If the framework required you to retain every signal, it'd be much more unwieldy
+to use, especially for one-shot signals that are used like futures (e.g.,
+network requests). You'd have to save any long-lived signal into a property, and
+then also make sure to clear it out when you're done with it. Not fun.
+
+## Subscribers
+
+Before going any further, it's worth noting that
+`subscribeNext:error:completed:` (and all variants thereof) create an _implicit_
+subscriber using the given blocks. Any objects referenced from those blocks will
+therefore be retained as part of the subscription. Just like any other object,
+`self` won't be retained without a direct or indirect reference to it.
+
+## Finite or Short-Lived Signals
+
+The most important guideline to RAC memory management is that a **subscription
+is automatically terminated upon completion or error, and the subscriber
+removed**.
+
+For example, if you have some code like this in your view controller:
+
+```objc
+self.disposable = [signal subscribeCompleted:^{
+    doSomethingPossiblyInvolving(self);
+}];
+```
+
+… the memory management will look something like the following:
+
+```
+view controller -> RACDisposable -> RACSignal -> RACSubscriber -> view controller
+```
+
+However, the `RACSignal -> RACSubscriber` relationship is torn down as soon as
+`signal` finishes, breaking the retain cycle.
+
+**This is often all you need**, because the lifetime of the `RACSignal` in
+memory will naturally match the logical lifetime of the event stream.
+
+## Infinite Signals
+
+Infinite signals (or signals that live so long that they might as well be
+infinite), however, will never tear down naturally. This is where disposables
+shine.
+
+**Disposing of a subscription will remove the associated subscriber**, and just
+generally clean up any resources associated with that subscription. To that one
+subscriber, it's just as if the signal had completed or errored, except no final
+event is sent on the signal. All other subscribers will remain intact.
+
+However, as a general rule of thumb, if you have to manually manage
+a subscription's lifecycle, [there's probably a better way to do what you want][avoid-explicit-subscriptions-and-disposal].
+
+## Signals Derived from `self`
+
+There's still a bit of a tricky middle case here, though. Any time a signal's
+lifetime is tied to the calling scope, you'll have a much harder cycle to break.
+
+This commonly occurs when using `RACObserve()` on a key
+path that's relative to `self`, and then applying a block that needs to capture
+`self`.
+
+The easiest answer here is just to **capture `self` weakly**:
+
+```objc
+__weak id weakSelf = self;
+[RACObserve(self, username) subscribeNext:^(NSString *username) {
+    id strongSelf = weakSelf;
+    [strongSelf validateUsername];
+}];
+```
+
+Or, after importing the included
+[EXTScope.h](https://github.com/jspahrsummers/libextobjc/blob/master/extobjc/EXTScope.h)
+header:
+
+```objc
+@weakify(self);
+[RACObserve(self, username) subscribeNext:^(NSString *username) {
+    @strongify(self);
+    [self validateUsername];
+}];
+```
+
+*(Replace `__weak` or `@weakify` with `__unsafe_unretained` or `@unsafeify`,
+respectively, if the object doesn't support weak references.)*
+
+However, [there's probably a better pattern you could use instead][avoid-explicit-subscriptions-and-disposal]. For
+example, the above sample could perhaps be written like:
+
+```objc
+[self rac_liftSelector:@selector(validateUsername:) withSignals:RACObserve(self, username), nil];
+```
+
+or:
+
+```objc
+RACSignal *validated = [RACObserve(self, username) map:^(NSString *username) {
+    // Put validation logic here.
+    return @YES;
+}];
+```
+
+As with infinite signals, there are generally ways you can avoid referencing
+`self` (or any object) from blocks in a signal chain.
+
+----
+
+The above information is really all you should need in order to use
+ReactiveCocoa effectively. However, there's one more point to address, just for
+the technically curious or for anyone interested in contributing to RAC.
+
+The design goal of "no retaining necessary" begs the question: how do we know
+when a signal should be deallocated? What if it was just created, escaped an
+autorelease pool, and hasn't been retained yet?
+
+The real answer is _we don't_, BUT we can usually assume that the caller will
+retain the signal within the current run loop iteration if they want to keep it.
+
+Consequently:
+
+ 1. A created signal is automatically added to a global set of active signals.
+ 2. The signal will wait for a single pass of the main run loop, and then remove
+    itself from the active set _if it has no subscribers_. Unless the signal was
+    retained somehow, it would deallocate at this point.
+ 3. If something did subscribe in that run loop iteration, the signal stays in
+    the set.
+ 4. Later, when all the subscribers are gone, step 2 is triggered again.
+
+This could backfire if the run loop is spun recursively (like in a modal event
+loop on OS X), but it makes the life of the framework consumer much easier for
+most or all other cases.
+
+[avoid-explicit-subscriptions-and-disposal]: DesignGuidelines.md#avoid-explicit-subscriptions-and-disposal
diff --git a/Documentation/README.md b/Documentation/README.md
new file mode 100644
index 0000000..4e0d4ed
--- /dev/null
+++ b/Documentation/README.md
@@ -0,0 +1,2 @@
+This folder contains conceptual documentation and design guidelines that don't
+fit well on a single class or in any specific header file.
diff --git a/Instruments/Disposable Growth.tracetemplate b/Instruments/Disposable Growth.tracetemplate
new file mode 100644
index 0000000..24dc61c
--- /dev/null
+++ b/Instruments/Disposable Growth.tracetemplate
Binary files differ
diff --git a/Instruments/README.md b/Instruments/README.md
new file mode 100644
index 0000000..e2f1d4a
--- /dev/null
+++ b/Instruments/README.md
@@ -0,0 +1,14 @@
+This folder contains Instruments templates to make it easier to debug
+code using ReactiveCocoa.
+
+To get started with a template, simply double-click it.
+
+### Signal Names
+
+The `name` property of `RACSignal` requires that the `RAC_DEBUG_SIGNAL_NAMES`
+environment variable be set, which means that you won't have access to
+meaningful names in Instruments by default.
+
+To add signal names, open your application's scheme in Xcode, select the Profile
+action, and add `RAC_DEBUG_SIGNAL_NAMES` with a value of `1` to the list of
+environment variables.
diff --git a/Instruments/Signal Events.tracetemplate b/Instruments/Signal Events.tracetemplate
new file mode 100644
index 0000000..4c90d88
--- /dev/null
+++ b/Instruments/Signal Events.tracetemplate
Binary files differ
diff --git a/LICENSE.md b/LICENSE.md
new file mode 100644
index 0000000..56cda91
--- /dev/null
+++ b/LICENSE.md
@@ -0,0 +1,19 @@
+**Copyright (c) 2012 - 2014, GitHub, Inc.**
+**All rights reserved.**
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..c919c15
--- /dev/null
+++ b/README.md
@@ -0,0 +1,562 @@
+# ReactiveCocoa
+
+ReactiveCocoa (RAC) is an Objective-C framework for [Functional Reactive
+Programming][]. It provides APIs for **composing and transforming streams of
+values**.
+
+If you're already familiar with functional reactive programming or know the basic
+premise of ReactiveCocoa, check out the [Documentation][] folder for a framework
+overview and more in-depth information about how it all works in practice.
+
+## New to ReactiveCocoa?
+
+ReactiveCocoa is documented like crazy, and there's a wealth of introductory
+material available to explain what RAC is and how you can use it.
+
+If you want to learn more, we recommend these resources, roughly in order:
+
+ 1. [Introduction](#introduction)
+ 1. [When to use ReactiveCocoa](#when-to-use-reactivecocoa)
+ 1. [Framework Overview][]
+ 1. [Basic Operators][]
+ 1. [Header documentation](ReactiveCocoaFramework/ReactiveCocoa)
+ 1. Previously answered [Stack Overflow](https://github.com/ReactiveCocoa/ReactiveCocoa/wiki)
+    questions and [GitHub issues](https://github.com/ReactiveCocoa/ReactiveCocoa/issues?labels=question&state=closed)
+ 1. The rest of the [Documentation][] folder
+ 1. [Functional Reactive Programming on iOS](https://leanpub.com/iosfrp/) 
+    (eBook)
+ 
+If you have any further questions, please feel free to [file an issue](https://github.com/ReactiveCocoa/ReactiveCocoa/issues/new). 
+
+## Introduction
+
+ReactiveCocoa is an implementation of [functional reactive
+programming](http://blog.maybeapps.com/post/42894317939/input-and-output).
+Rather than using mutable variables which are replaced and modified in-place,
+RAC provides signals (represented by `RACSignal`) that capture present and
+future values.
+
+By chaining, combining, and reacting to signals, software can be written
+declaratively, without the need for code that continually observes and updates
+values.
+
+For example, a text field can be bound to the latest time, even as it changes,
+instead of using additional code that watches the clock and updates the
+text field every second.  It works much like KVO, but with blocks instead of
+overriding `-observeValueForKeyPath:ofObject:change:context:`.
+
+Signals can also represent asynchronous operations, much like [futures and
+promises][]. This greatly simplifies asynchronous software, including networking
+code.
+
+One of the major advantages of RAC is that it provides a single, unified
+approach to dealing with asynchronous behaviors, including delegate methods,
+callback blocks, target-action mechanisms, notifications, and KVO.
+
+Here's a simple example:
+
+```objc
+// When self.username changes, log the new name to the console.
+//
+// RACObserve(self, username) creates a new RACSignal that sends the current
+// value of self.username, then the new value whenever it changes.
+// -subscribeNext: will execute the block whenever the signal sends a value.
+[RACObserve(self, username) subscribeNext:^(NSString *newName) {
+	NSLog(@"%@", newName);
+}];
+```
+
+But unlike KVO notifications, signals can be chained together and operated on:
+
+```objc
+// Only log names that start with "j".
+//
+// -filter returns a new RACSignal that only sends a new value when its block
+// returns YES.
+[[RACObserve(self, username)
+	filter:^(NSString *newName) {
+		return [newName hasPrefix:@"j"];
+	}]
+	subscribeNext:^(NSString *newName) {
+		NSLog(@"%@", newName);
+	}];
+```
+
+Signals can also be used to derive state. Instead of observing properties and
+setting other properties in response to the new values, RAC makes it possible to
+express properties in terms of signals and operations:
+
+```objc
+// Create a one-way binding so that self.createEnabled will be
+// true whenever self.password and self.passwordConfirmation
+// are equal.
+//
+// RAC() is a macro that makes the binding look nicer.
+// 
+// +combineLatest:reduce: takes an array of signals, executes the block with the
+// latest value from each signal whenever any of them changes, and returns a new
+// RACSignal that sends the return value of that block as values.
+RAC(self, createEnabled) = [RACSignal 
+	combineLatest:@[ RACObserve(self, password), RACObserve(self, passwordConfirmation) ] 
+	reduce:^(NSString *password, NSString *passwordConfirm) {
+		return @([passwordConfirm isEqualToString:password]);
+	}];
+```
+
+Signals can be built on any stream of values over time, not just KVO. For
+example, they can also represent button presses:
+
+```objc
+// Log a message whenever the button is pressed.
+//
+// RACCommand creates signals to represent UI actions. Each signal can
+// represent a button press, for example, and have additional work associated
+// with it.
+//
+// -rac_command is an addition to NSButton. The button will send itself on that
+// command whenever it's pressed.
+self.button.rac_command = [[RACCommand alloc] initWithSignalBlock:^(id _) {
+	NSLog(@"button was pressed!");
+	return [RACSignal empty];
+}]
+```
+
+Or asynchronous network operations:
+
+```objc
+// Hook up a "Log in" button to log in over the network.
+//
+// This block will be run whenever the login command is executed, starting
+// the login process.
+self.loginCommand = [[RACCommand alloc] initWithSignalBlock:^(id sender) {
+	// The hypothetical -logIn method returns a signal that sends a value when
+	// the network request finishes.
+	return [client logIn];
+}];
+
+// -executionSignals returns a signal that includes the signals returned from
+// the above block, one for each time the command is executed.
+[self.loginCommand.executionSignals subscribeNext:^(RACSignal *loginSignal) {
+	// Log a message whenever we log in successfully.
+	[loginSignal subscribeCompleted:^ {
+		NSLog(@"Logged in successfully!");
+	}];
+}];
+
+// Execute the login command when the button is pressed.
+self.loginButton.rac_command = self.loginCommand;
+```
+
+Signals can also represent timers, other UI events, or anything else that
+changes over time.
+
+Using signals for asynchronous operations makes it possible to build up more
+complex behavior by chaining and transforming those signals. Work can easily be
+trigged after a group of operations completes:
+
+```objc
+// Perform 2 network operations and log a message to the console when they are
+// both completed.
+//
+// +merge: takes an array of signals and returns a new RACSignal that passes
+// through the values of all of the signals and completes when all of the
+// signals complete.
+//
+// -subscribeCompleted: will execute the block when the signal completes.
+[[RACSignal 
+	merge:@[ [client fetchUserRepos], [client fetchOrgRepos] ]] 
+	subscribeCompleted:^{
+		NSLog(@"They're both done!");
+	}];
+```
+
+Signals can be chained to sequentially execute asynchronous operations, instead
+of nesting callbacks with blocks. This is similar to how [futures and promises][]
+are usually used:
+
+```objc
+// Log in the user, then load any cached messages, then fetch the remaining
+// messages from the server. After that's all done, log a message to the
+// console.
+//
+// The hypothetical -logInUser methods returns a signal that completes after
+// logging in.
+//
+// -flattenMap: will execute its block whenever the signal sends a value, and
+// return a new RACSignal that merges all of the signals returned from the block
+// into a single signal.
+[[[[client 
+	logInUser] 
+	flattenMap:^(User *user) {
+		// Return a signal that loads cached messages for the user.
+		return [client loadCachedMessagesForUser:user];
+	}]
+	flattenMap:^(NSArray *messages) {
+		// Return a signal that fetches any remaining messages.
+		return [client fetchMessagesAfterMessage:messages.lastObject];
+	}]
+	subscribeNext:^(NSArray *newMessages) {
+		NSLog(@"New messages: %@", newMessages);
+	} completed:^{
+		NSLog(@"Fetched all messages.");
+	}];
+```
+
+RAC even makes it easy to bind to the result of an asynchronous operation:
+
+```objc
+// Create a one-way binding so that self.imageView.image will be set the user's
+// avatar as soon as it's downloaded.
+//
+// The hypothetical -fetchUserWithUsername: method returns a signal which sends
+// the user.
+//
+// -deliverOn: creates new signals that will do their work on other queues. In
+// this example, it's used to move work to a background queue and then back to the main thread.
+//
+// -map: calls its block with each user that's fetched and returns a new
+// RACSignal that sends values returned from the block.
+RAC(self.imageView, image) = [[[[client 
+	fetchUserWithUsername:@"joshaber"]
+	deliverOn:[RACScheduler scheduler]]
+	map:^(User *user) {
+		// Download the avatar (this is done on a background queue).
+		return [[NSImage alloc] initWithContentsOfURL:user.avatarURL];
+	}]
+	// Now the assignment will be done on the main thread.
+	deliverOn:RACScheduler.mainThreadScheduler];
+```
+
+That demonstrates some of what RAC can do, but it doesn't demonstrate why RAC is
+so powerful. It's hard to appreciate RAC from README-sized examples, but it
+makes it possible to write code with less state, less boilerplate, better code
+locality, and better expression of intent.
+
+For more sample code, check out [C-41][] or [GroceryList][], which are real iOS
+apps written using ReactiveCocoa. Additional information about RAC can be found
+in the [Documentation][] folder.
+
+## When to use ReactiveCocoa
+
+Upon first glance, ReactiveCocoa is very abstract, and it can be difficult to
+understand how to apply it to concrete problems.
+
+Here are some of the use cases that RAC excels at.
+
+### Handling asynchronous or event-driven data sources
+
+Much of Cocoa programming is focused on reacting to user events or changes in
+application state. Code that deals with such events can quickly become very
+complex and spaghetti-like, with lots of callbacks and state variables to handle
+ordering issues.
+
+Patterns that seem superficially different, like UI callbacks, network
+responses, and KVO notifications, actually have a lot in common. [RACSignal][]
+unifies all these different APIs so that they can be composed together and
+manipulated in the same way.
+
+For example, the following code:
+
+```objc
+
+static void *ObservationContext = &ObservationContext;
+
+- (void)viewDidLoad {
+	[super viewDidLoad];
+
+	[LoginManager.sharedManager addObserver:self forKeyPath:@"loggingIn" options:NSKeyValueObservingOptionInitial context:&ObservationContext];
+	[NSNotificationCenter.defaultCenter addObserver:self selector:@selector(loggedOut:) name:UserDidLogOutNotification object:LoginManager.sharedManager];
+
+	[self.usernameTextField addTarget:self action:@selector(updateLogInButton) forControlEvents:UIControlEventEditingChanged];
+	[self.passwordTextField addTarget:self action:@selector(updateLogInButton) forControlEvents:UIControlEventEditingChanged];
+	[self.logInButton addTarget:self action:@selector(logInPressed:) forControlEvents:UIControlEventTouchUpInside];
+}
+
+- (void)dealloc {
+	[LoginManager.sharedManager removeObserver:self forKeyPath:@"loggingIn" context:ObservationContext];
+	[NSNotificationCenter.defaultCenter removeObserver:self];
+}
+
+- (void)updateLogInButton {
+	BOOL textFieldsNonEmpty = self.usernameTextField.text.length > 0 && self.passwordTextField.text.length > 0;
+	BOOL readyToLogIn = !LoginManager.sharedManager.isLoggingIn && !self.loggedIn;
+	self.logInButton.enabled = textFieldsNonEmpty && readyToLogIn;
+}
+
+- (IBAction)logInPressed:(UIButton *)sender {
+	[[LoginManager sharedManager]
+		logInWithUsername:self.usernameTextField.text
+		password:self.passwordTextField.text
+		success:^{
+			self.loggedIn = YES;
+		} failure:^(NSError *error) {
+			[self presentError:error];
+		}];
+}
+
+- (void)loggedOut:(NSNotification *)notification {
+	self.loggedIn = NO;
+}
+
+- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context {
+	if (context == ObservationContext) {
+		[self updateLogInButton];
+	} else {
+		[super observeValueForKeyPath:keyPath ofObject:object change:change context:context];
+	}
+}
+```
+
+… could be expressed in RAC like so:
+
+```objc
+- (void)viewDidLoad {
+	[super viewDidLoad];
+
+	@weakify(self);
+
+	RAC(self.logInButton, enabled) = [RACSignal
+		combineLatest:@[
+			self.usernameTextField.rac_textSignal,
+			self.passwordTextField.rac_textSignal,
+			RACObserve(LoginManager.sharedManager, loggingIn),
+			RACObserve(self, loggedIn)
+		] reduce:^(NSString *username, NSString *password, NSNumber *loggingIn, NSNumber *loggedIn) {
+			return @(username.length > 0 && password.length > 0 && !loggingIn.boolValue && !loggedIn.boolValue);
+		}];
+
+	[[self.logInButton rac_signalForControlEvents:UIControlEventTouchUpInside] subscribeNext:^(UIButton *sender) {
+		@strongify(self);
+
+		RACSignal *loginSignal = [LoginManager.sharedManager
+			logInWithUsername:self.usernameTextField.text
+			password:self.passwordTextField.text];
+
+			[loginSignal subscribeError:^(NSError *error) {
+				@strongify(self);
+				[self presentError:error];
+			} completed:^{
+				@strongify(self);
+				self.loggedIn = YES;
+			}];
+	}];
+
+	RAC(self, loggedIn) = [[NSNotificationCenter.defaultCenter
+		rac_addObserverForName:UserDidLogOutNotification object:nil]
+		mapReplace:@NO];
+}
+```
+
+### Chaining dependent operations
+
+Dependencies are most often found in network requests, where a previous request
+to the server needs to complete before the next one can be constructed, and so
+on:
+
+```objc
+[client logInWithSuccess:^{
+	[client loadCachedMessagesWithSuccess:^(NSArray *messages) {
+		[client fetchMessagesAfterMessage:messages.lastObject success:^(NSArray *nextMessages) {
+			NSLog(@"Fetched all messages.");
+		} failure:^(NSError *error) {
+			[self presentError:error];
+		}];
+	} failure:^(NSError *error) {
+		[self presentError:error];
+	}];
+} failure:^(NSError *error) {
+	[self presentError:error];
+}];
+```
+
+ReactiveCocoa makes this pattern particularly easy:
+
+```objc
+[[[[client logIn]
+	then:^{
+		return [client loadCachedMessages];
+	}]
+	flattenMap:^(NSArray *messages) {
+		return [client fetchMessagesAfterMessage:messages.lastObject];
+	}]
+	subscribeError:^(NSError *error) {
+		[self presentError:error];
+	} completed:^{
+		NSLog(@"Fetched all messages.");
+	}];
+```
+
+### Parallelizing independent work
+
+Working with independent data sets in parallel and then combining them into
+a final result is non-trivial in Cocoa, and often involves a lot of
+synchronization:
+
+```objc
+__block NSArray *databaseObjects;
+__block NSArray *fileContents;
+ 
+NSOperationQueue *backgroundQueue = [[NSOperationQueue alloc] init];
+NSBlockOperation *databaseOperation = [NSBlockOperation blockOperationWithBlock:^{
+	databaseObjects = [databaseClient fetchObjectsMatchingPredicate:predicate];
+}];
+
+NSBlockOperation *filesOperation = [NSBlockOperation blockOperationWithBlock:^{
+	NSMutableArray *filesInProgress = [NSMutableArray array];
+	for (NSString *path in files) {
+		[filesInProgress addObject:[NSData dataWithContentsOfFile:path]];
+	}
+
+	fileContents = [filesInProgress copy];
+}];
+ 
+NSBlockOperation *finishOperation = [NSBlockOperation blockOperationWithBlock:^{
+	[self finishProcessingDatabaseObjects:databaseObjects fileContents:fileContents];
+	NSLog(@"Done processing");
+}];
+ 
+[finishOperation addDependency:databaseOperation];
+[finishOperation addDependency:filesOperation];
+[backgroundQueue addOperation:databaseOperation];
+[backgroundQueue addOperation:filesOperation];
+[backgroundQueue addOperation:finishOperation];
+```
+
+The above code can be cleaned up and optimized by simply composing signals:
+
+```objc
+RACSignal *databaseSignal = [[databaseClient
+	fetchObjectsMatchingPredicate:predicate]
+	subscribeOn:[RACScheduler scheduler]];
+
+RACSignal *fileSignal = [RACSignal startEagerlyWithScheduler:[RACScheduler scheduler] block:^(id<RACSubscriber> subscriber) {
+	NSMutableArray *filesInProgress = [NSMutableArray array];
+	for (NSString *path in files) {
+		[filesInProgress addObject:[NSData dataWithContentsOfFile:path]];
+	}
+
+	[subscriber sendNext:[filesInProgress copy]];
+	[subscriber sendCompleted];
+}];
+
+[[RACSignal
+	combineLatest:@[ databaseSignal, fileSignal ]
+	reduce:^ id (NSArray *databaseObjects, NSArray *fileContents) {
+		[self finishProcessingDatabaseObjects:databaseObjects fileContents:fileContents];
+		return nil;
+	}]
+	subscribeCompleted:^{
+		NSLog(@"Done processing");
+	}];
+```
+
+### Simplifying collection transformations
+
+Higher-order functions like `map`, `filter`, `fold`/`reduce` are sorely missing
+from Foundation, leading to loop-focused code like this:
+
+```objc
+NSMutableArray *results = [NSMutableArray array];
+for (NSString *str in strings) {
+	if (str.length < 2) {
+		continue;
+	}
+
+	NSString *newString = [str stringByAppendingString:@"foobar"];
+	[results addObject:newString];
+}
+```
+
+[RACSequence][] allows any Cocoa collection to be manipulated in a uniform and
+declarative way:
+
+```objc
+RACSequence *results = [[strings.rac_sequence
+	filter:^ BOOL (NSString *str) {
+		return str.length >= 2;
+	}]
+	map:^(NSString *str) {
+		return [str stringByAppendingString:@"foobar"];
+	}];
+```
+
+## System Requirements
+
+ReactiveCocoa supports OS X 10.7+ and iOS 5.0+.
+
+## Importing ReactiveCocoa
+
+To add RAC to your application:
+
+ 1. Add the ReactiveCocoa repository as a submodule of your application's
+    repository.
+ 1. Run `script/bootstrap` from within the ReactiveCocoa folder.
+ 1. Drag and drop `ReactiveCocoaFramework/ReactiveCocoa.xcodeproj` into your
+    application's Xcode project or workspace.
+ 1. On the "Build Phases" tab of your application target, add RAC to the "Link
+    Binary With Libraries" phase.
+    * **On iOS**, add `libReactiveCocoa-iOS.a`.
+    * **On OS X**, add `ReactiveCocoa.framework`. RAC must also be added to any
+      "Copy Frameworks" build phase. If you don't already have one, simply add
+      a "Copy Files" build phase and target the "Frameworks" destination.
+ 1. Add `"$(BUILD_ROOT)/../IntermediateBuildFilesPath/UninstalledProducts/include"
+    $(inherited)` to the "Header Search Paths" build setting (this is only
+    necessary for archive builds, but it has no negative effect otherwise).
+ 1. **For iOS targets**, add `-ObjC` to the "Other Linker Flags" build setting.
+ 1. **If you added RAC to a project (not a workspace)**, you will also need to
+    add the appropriate RAC target to the "Target Dependencies" of your
+    application.
+
+If you would prefer to use [CocoaPods](http://cocoapods.org), there are some
+[ReactiveCocoa
+podspecs](https://github.com/CocoaPods/Specs/tree/master/ReactiveCocoa) that
+have been generously contributed by third parties.
+
+To see a project already set up with RAC, check out [C-41][] or [GroceryList][],
+which are real iOS apps written using ReactiveCocoa.
+
+## Standalone Development
+
+If you’re working on RAC in isolation instead of integrating it into another project, you’ll want to open `ReactiveCocoaFramework/ReactiveCocoa.xcworkspace` and not the `.xcodeproj`.
+
+## More Info
+
+ReactiveCocoa is based on .NET's [Reactive
+Extensions](http://msdn.microsoft.com/en-us/data/gg577609) (Rx). Most of the
+principles of Rx apply to RAC as well. There are some really good Rx resources
+out there:
+
+* [Reactive Extensions MSDN entry](http://msdn.microsoft.com/en-us/library/hh242985.aspx)
+* [Reactive Extensions for .NET Introduction](http://leecampbell.blogspot.com/2010/08/reactive-extensions-for-net.html)
+* [Rx - Channel 9 videos](http://channel9.msdn.com/tags/Rx/)
+* [Reactive Extensions wiki](http://rxwiki.wikidot.com/)
+* [101 Rx Samples](http://rxwiki.wikidot.com/101samples)
+* [Programming Reactive Extensions and LINQ](http://www.amazon.com/Programming-Reactive-Extensions-Jesse-Liberty/dp/1430237473)
+
+RAC and Rx are both implementations of functional reactive programming. Here are
+some more resources for learning about FRP:
+
+* [What is FRP? - Elm Language](http://elm-lang.org/learn/What-is-FRP.elm)
+* [What is Functional Reactive Programming - Stack Overflow](http://stackoverflow.com/questions/1028250/what-is-functional-reactive-programming/1030631#1030631)
+* [Escape from Callback Hell](http://elm-lang.org/learn/Escape-from-Callback-Hell.elm)
+* [Principles of Reactive Programming on Coursera](https://www.coursera.org/course/reactive)
+
+[Basic Operators]: Documentation/BasicOperators.md
+[Documentation]: Documentation
+[Framework Overview]: Documentation/FrameworkOverview.md
+[Functional Reactive Programming]: http://en.wikipedia.org/wiki/Functional_reactive_programming
+[GroceryList]:  https://github.com/jspahrsummers/GroceryList
+[Memory Management]: Documentation/MemoryManagement.md
+[NSObject+RACLifting]: ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACLifting.h
+[RACDisposable]: ReactiveCocoaFramework/ReactiveCocoa/RACDisposable.h
+[RACEvent]: ReactiveCocoaFramework/ReactiveCocoa/RACEvent.h
+[RACMulticastConnection]: ReactiveCocoaFramework/ReactiveCocoa/RACMulticastConnection.h
+[RACScheduler]: ReactiveCocoaFramework/ReactiveCocoa/RACScheduler.h
+[RACSequence]: ReactiveCocoaFramework/ReactiveCocoa/RACSequence.h
+[RACSignal+Operations]: ReactiveCocoaFramework/ReactiveCocoa/RACSignal+Operations.h
+[RACSignal]: ReactiveCocoaFramework/ReactiveCocoa/RACSignal.h
+[RACStream]: ReactiveCocoaFramework/ReactiveCocoa/RACStream.h
+[RACSubscriber]: ReactiveCocoaFramework/ReactiveCocoa/RACSubscriber.h
+[RAC]: ReactiveCocoaFramework/ReactiveCocoa/RACSubscriptingAssignmentTrampoline.h
+[futures and promises]: http://en.wikipedia.org/wiki/Futures_and_promises
+[C-41]: https://github.com/AshFurrow/C-41
diff --git a/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/project.pbxproj b/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/project.pbxproj
new file mode 100644
index 0000000..58014f0
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/project.pbxproj
@@ -0,0 +1,3128 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 46;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		1646747B17FFA0610036E30B /* UICollectionReusableView+RACSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 1668027817FE75E900C724B4 /* UICollectionReusableView+RACSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		1668028017FE75F900C724B4 /* UICollectionReusableView+RACSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 1668027917FE75E900C724B4 /* UICollectionReusableView+RACSignalSupport.m */; };
+		1668028317FE775200C724B4 /* UICollectionReusableViewRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 1668028117FE774800C724B4 /* UICollectionReusableViewRACSupportSpec.m */; };
+		1860F414177C91B500C7B3C9 /* UIKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 1860F413177C91B500C7B3C9 /* UIKit.framework */; };
+		1860F416177C91B500C7B3C9 /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 1860F415177C91B500C7B3C9 /* Foundation.framework */; };
+		1860F418177C91B500C7B3C9 /* CoreGraphics.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 1860F417177C91B500C7B3C9 /* CoreGraphics.framework */; };
+		1860F41E177C91B500C7B3C9 /* InfoPlist.strings in Resources */ = {isa = PBXBuildFile; fileRef = 1860F41C177C91B500C7B3C9 /* InfoPlist.strings */; };
+		1860F420177C91B500C7B3C9 /* main.m in Sources */ = {isa = PBXBuildFile; fileRef = 1860F41F177C91B500C7B3C9 /* main.m */; };
+		1860F424177C91B500C7B3C9 /* RACAppDelegate.m in Sources */ = {isa = PBXBuildFile; fileRef = 1860F423177C91B500C7B3C9 /* RACAppDelegate.m */; };
+		1860F426177C91B500C7B3C9 /* Default.png in Resources */ = {isa = PBXBuildFile; fileRef = 1860F425177C91B500C7B3C9 /* Default.png */; };
+		1860F428177C91B500C7B3C9 /* Default@2x.png in Resources */ = {isa = PBXBuildFile; fileRef = 1860F427177C91B500C7B3C9 /* Default@2x.png */; };
+		1860F42A177C91B500C7B3C9 /* Default-568h@2x.png in Resources */ = {isa = PBXBuildFile; fileRef = 1860F429177C91B500C7B3C9 /* Default-568h@2x.png */; };
+		1860F432177C91B500C7B3C9 /* SenTestingKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 1860F431177C91B500C7B3C9 /* SenTestingKit.framework */; };
+		1860F433177C91B500C7B3C9 /* UIKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 1860F413177C91B500C7B3C9 /* UIKit.framework */; };
+		1860F434177C91B500C7B3C9 /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 1860F415177C91B500C7B3C9 /* Foundation.framework */; };
+		1860F43C177C91B500C7B3C9 /* InfoPlist.strings in Resources */ = {isa = PBXBuildFile; fileRef = 1860F43A177C91B500C7B3C9 /* InfoPlist.strings */; };
+		1860F44F177C958300C7B3C9 /* UITextFieldRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D0C55CD817758A73008CDDCA /* UITextFieldRACSupportSpec.m */; };
+		1860F450177C958900C7B3C9 /* UITextViewRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D0C55CDE17758C2A008CDDCA /* UITextViewRACSupportSpec.m */; };
+		1E893381171647A5009071B0 /* NSObjectRACPropertySubscribingExamples.m in Sources */ = {isa = PBXBuildFile; fileRef = 1E893380171647A5009071B0 /* NSObjectRACPropertySubscribingExamples.m */; };
+		1EC06B17173CB04000365258 /* UIGestureRecognizer+RACSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 1EC06B15173CB04000365258 /* UIGestureRecognizer+RACSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		1EC06B18173CB04000365258 /* UIGestureRecognizer+RACSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 1EC06B16173CB04000365258 /* UIGestureRecognizer+RACSignalSupport.m */; };
+		27A887D11703DC6800040001 /* UIBarButtonItem+RACCommandSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 27A887C81703DB4F00040001 /* UIBarButtonItem+RACCommandSupport.m */; };
+		27A887D21703DDEB00040001 /* UIBarButtonItem+RACCommandSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 27A887C71703DB4F00040001 /* UIBarButtonItem+RACCommandSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		4925E806181BCC71000B2FEE /* NSControllerRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 4925E805181BCC71000B2FEE /* NSControllerRACSupportSpec.m */; };
+		554D9E5D181064E200F21262 /* UIRefreshControl+RACCommandSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 554D9E5B181064E200F21262 /* UIRefreshControl+RACCommandSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		554D9E5E181064E200F21262 /* UIRefreshControl+RACCommandSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 554D9E5C181064E200F21262 /* UIRefreshControl+RACCommandSupport.m */; };
+		5564537F18107203002BD2E4 /* RACControlCommandExamples.m in Sources */ = {isa = PBXBuildFile; fileRef = D075A72917BCB7E100C24FB7 /* RACControlCommandExamples.m */; };
+		5564542418107275002BD2E4 /* UIRefreshControlRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 5564542318107275002BD2E4 /* UIRefreshControlRACSupportSpec.m */; };
+		557A4B5A177648C7008EF796 /* UIActionSheet+RACSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 557A4B58177648C7008EF796 /* UIActionSheet+RACSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		557A4B5B177648C7008EF796 /* UIActionSheet+RACSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 557A4B59177648C7008EF796 /* UIActionSheet+RACSignalSupport.m */; };
+		55C39DE417F1EC6E006DC60C /* NSData+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 88442C8816090C1500636B49 /* NSData+RACSupport.m */; };
+		55C39DE517F1EC6E006DC60C /* NSFileHandle+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 88442C8A16090C1500636B49 /* NSFileHandle+RACSupport.m */; };
+		55C39DE617F1EC6E006DC60C /* NSNotificationCenter+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 88442C8C16090C1500636B49 /* NSNotificationCenter+RACSupport.m */; };
+		55C39DE717F1EC6E006DC60C /* NSString+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 88442C8E16090C1500636B49 /* NSString+RACSupport.m */; };
+		55C39DE817F1EC6E006DC60C /* NSData+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 88442C8816090C1500636B49 /* NSData+RACSupport.m */; };
+		55C39DE917F1EC6E006DC60C /* NSFileHandle+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 88442C8A16090C1500636B49 /* NSFileHandle+RACSupport.m */; };
+		55C39DEA17F1EC6E006DC60C /* NSNotificationCenter+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 88442C8C16090C1500636B49 /* NSNotificationCenter+RACSupport.m */; };
+		55C39DEB17F1EC6E006DC60C /* NSString+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 88442C8E16090C1500636B49 /* NSString+RACSupport.m */; };
+		55C39DEC17F1EC84006DC60C /* NSData+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 88442C8716090C1500636B49 /* NSData+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		55C39DED17F1EC84006DC60C /* NSFileHandle+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 88442C8916090C1500636B49 /* NSFileHandle+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		55C39DEE17F1EC84006DC60C /* NSNotificationCenter+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 88442C8B16090C1500636B49 /* NSNotificationCenter+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		55C39DEF17F1EC84006DC60C /* NSString+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 88442C8D16090C1500636B49 /* NSString+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		55C39DF017F1EC84006DC60C /* NSData+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 88442C8716090C1500636B49 /* NSData+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		55C39DF117F1EC84006DC60C /* NSFileHandle+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 88442C8916090C1500636B49 /* NSFileHandle+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		55C39DF217F1EC84006DC60C /* NSNotificationCenter+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 88442C8B16090C1500636B49 /* NSNotificationCenter+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		55C39DF317F1EC84006DC60C /* NSString+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 88442C8D16090C1500636B49 /* NSString+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		5EE9A7931760D61300EAF5A2 /* UIButton+RACCommandSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 5EE9A7911760D61300EAF5A2 /* UIButton+RACCommandSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		5EE9A7941760D61300EAF5A2 /* UIButton+RACCommandSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 5EE9A7921760D61300EAF5A2 /* UIButton+RACCommandSupport.m */; };
+		5EE9A79B1760D88500EAF5A2 /* UIButtonRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 5EE9A79A1760D88500EAF5A2 /* UIButtonRACSupportSpec.m */; };
+		5F016DF717B10AA8002EEC69 /* UIControl+RACSignalSupportPrivate.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F016DF317B10AA8002EEC69 /* UIControl+RACSignalSupportPrivate.m */; };
+		5F2447AD167E87C50062180C /* RACKVOChannelSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F2447AC167E87C50062180C /* RACKVOChannelSpec.m */; };
+		5F45A885168CFA3E00B58A2B /* RACKVOChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 5F45A883168CFA3E00B58A2B /* RACKVOChannel.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		5F45A886168CFA3E00B58A2B /* RACKVOChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 5F45A883168CFA3E00B58A2B /* RACKVOChannel.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		5F45A887168CFA3E00B58A2B /* RACKVOChannel.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F45A884168CFA3E00B58A2B /* RACKVOChannel.m */; };
+		5F45A888168CFA3E00B58A2B /* RACKVOChannel.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F45A884168CFA3E00B58A2B /* RACKVOChannel.m */; };
+		5F6FE8531692568A00A8D7A6 /* RACChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 5F6FE8511692568A00A8D7A6 /* RACChannel.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		5F6FE8541692568A00A8D7A6 /* RACChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 5F6FE8511692568A00A8D7A6 /* RACChannel.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		5F6FE8551692568A00A8D7A6 /* RACChannel.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F6FE8521692568A00A8D7A6 /* RACChannel.m */; };
+		5F6FE8561692568A00A8D7A6 /* RACChannel.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F6FE8521692568A00A8D7A6 /* RACChannel.m */; };
+		5F70B2AF17AB1829009AEDF9 /* UIDatePicker+RACSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 5F70B2AD17AB1829009AEDF9 /* UIDatePicker+RACSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		5F70B2B017AB1829009AEDF9 /* UIDatePicker+RACSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F70B2AE17AB1829009AEDF9 /* UIDatePicker+RACSignalSupport.m */; };
+		5F70B2BE17AB1857009AEDF9 /* UISegmentedControl+RACSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 5F70B2B617AB1856009AEDF9 /* UISegmentedControl+RACSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		5F70B2BF17AB1857009AEDF9 /* UISegmentedControl+RACSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F70B2B717AB1856009AEDF9 /* UISegmentedControl+RACSignalSupport.m */; };
+		5F70B2C017AB1857009AEDF9 /* UISlider+RACSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 5F70B2B817AB1856009AEDF9 /* UISlider+RACSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		5F70B2C117AB1857009AEDF9 /* UISlider+RACSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F70B2B917AB1856009AEDF9 /* UISlider+RACSignalSupport.m */; };
+		5F70B2C217AB1857009AEDF9 /* UIStepper+RACSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 5F70B2BA17AB1857009AEDF9 /* UIStepper+RACSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		5F70B2C317AB1857009AEDF9 /* UIStepper+RACSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F70B2BB17AB1857009AEDF9 /* UIStepper+RACSignalSupport.m */; };
+		5F70B2C417AB1857009AEDF9 /* UISwitch+RACSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 5F70B2BC17AB1857009AEDF9 /* UISwitch+RACSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		5F70B2C517AB1857009AEDF9 /* UISwitch+RACSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F70B2BD17AB1857009AEDF9 /* UISwitch+RACSignalSupport.m */; };
+		5F773DEA169B46670023069D /* NSEnumerator+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = 5F773DE8169B46670023069D /* NSEnumerator+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		5F773DEB169B46670023069D /* NSEnumerator+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = 5F773DE8169B46670023069D /* NSEnumerator+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		5F773DEC169B46670023069D /* NSEnumerator+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F773DE9169B46670023069D /* NSEnumerator+RACSequenceAdditions.m */; };
+		5F773DED169B46670023069D /* NSEnumerator+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F773DE9169B46670023069D /* NSEnumerator+RACSequenceAdditions.m */; };
+		5F773DF0169B48830023069D /* NSEnumeratorRACSequenceAdditionsSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F773DEF169B48830023069D /* NSEnumeratorRACSequenceAdditionsSpec.m */; };
+		5F7EFECF168FBC4B0037E500 /* RACChannelExamples.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F7EFECD168FBC4B0037E500 /* RACChannelExamples.m */; };
+		5F7EFED0168FBC4B0037E500 /* RACChannelSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F7EFECE168FBC4B0037E500 /* RACChannelSpec.m */; };
+		5F9743F91694A2460024EB82 /* RACEagerSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F9743F61694A2460024EB82 /* RACEagerSequence.m */; };
+		5F9743FA1694A2460024EB82 /* RACEagerSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F9743F61694A2460024EB82 /* RACEagerSequence.m */; };
+		5FAF5224174D4C2000CAC810 /* SenTestingKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 88CDF7DD15000FCF00163A9F /* SenTestingKit.framework */; };
+		5FAF523E174D4D3200CAC810 /* NSEnumeratorRACSequenceAdditionsSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F773DEF169B48830023069D /* NSEnumeratorRACSequenceAdditionsSpec.m */; };
+		5FAF523F174D4D3600CAC810 /* NSNotificationCenterRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D0700F4B1672994D00D7CD30 /* NSNotificationCenterRACSupportSpec.m */; };
+		5FAF5240174D4D5600CAC810 /* NSObjectRACDeallocatingSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 6E58405E16F3414200F588A6 /* NSObjectRACDeallocatingSpec.m */; };
+		5FAF5241174D4D5600CAC810 /* NSObjectRACLiftingSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 8801E7501644BDE200A155FE /* NSObjectRACLiftingSpec.m */; };
+		5FAF5242174D4D5600CAC810 /* NSObjectRACPropertySubscribingExamples.m in Sources */ = {isa = PBXBuildFile; fileRef = 1E893380171647A5009071B0 /* NSObjectRACPropertySubscribingExamples.m */; };
+		5FAF5243174D4D5600CAC810 /* NSObjectRACPropertySubscribingSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 8851A38A16161D500050D47F /* NSObjectRACPropertySubscribingSpec.m */; };
+		5FAF5244174D4D5600CAC810 /* NSStringRACKeyPathUtilitiesSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 5FDC350E1736F81800792E52 /* NSStringRACKeyPathUtilitiesSpec.m */; };
+		5FAF5246174D4D5600CAC810 /* RACBacktraceSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D0870C6E16884A0600D0E11D /* RACBacktraceSpec.m */; };
+		5FAF5247174D4D5600CAC810 /* RACBlockTrampolineSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 886CEACC163DE669007632D1 /* RACBlockTrampolineSpec.m */; };
+		5FAF5248174D4D5600CAC810 /* RACCommandSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 882CCA1D15F1564D00937D6E /* RACCommandSpec.m */; };
+		5FAF5249174D4D5600CAC810 /* RACCompoundDisposableSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 881E86B91669350B00667F7B /* RACCompoundDisposableSpec.m */; };
+		5FAF524A174D4D5600CAC810 /* RACEventSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D077A171169B79A900057BB1 /* RACEventSpec.m */; };
+		5FAF524B174D4D5600CAC810 /* RACKVOWrapperSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D041376815D2281C004BBF80 /* RACKVOWrapperSpec.m */; };
+		5FAF524C174D4D5600CAC810 /* RACMulticastConnectionSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 88C5A02816924BFC0045EF05 /* RACMulticastConnectionSpec.m */; };
+		5FAF524D174D4D5600CAC810 /* RACKVOChannelSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F2447AC167E87C50062180C /* RACKVOChannelSpec.m */; };
+		5FAF524E174D4D5600CAC810 /* RACPropertySignalExamples.m in Sources */ = {isa = PBXBuildFile; fileRef = D0EDE76616968AB10072A780 /* RACPropertySignalExamples.m */; };
+		5FAF524F174D4D5600CAC810 /* RACChannelExamples.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F7EFECD168FBC4B0037E500 /* RACChannelExamples.m */; };
+		5FAF5250174D4D5600CAC810 /* RACChannelSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F7EFECE168FBC4B0037E500 /* RACChannelSpec.m */; };
+		5FAF5251174D4D5600CAC810 /* RACSchedulerSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 8803C010166732BA00C36839 /* RACSchedulerSpec.m */; };
+		5FAF5252174D4D5600CAC810 /* RACSequenceAdditionsSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D0C70F8F164337A2007027B4 /* RACSequenceAdditionsSpec.m */; };
+		5FAF5253174D4D5600CAC810 /* RACSequenceExamples.m in Sources */ = {isa = PBXBuildFile; fileRef = D0C70F92164337E3007027B4 /* RACSequenceExamples.m */; };
+		5FAF5254174D4D5600CAC810 /* RACSequenceSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D0D487051642651400DD7605 /* RACSequenceSpec.m */; };
+		5FAF5255174D4D5600CAC810 /* RACSignalSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 8820937B1501C8A600796685 /* RACSignalSpec.m */; };
+		5FAF5256174D4D5600CAC810 /* RACStreamExamples.m in Sources */ = {isa = PBXBuildFile; fileRef = D0487AB2164314430085D890 /* RACStreamExamples.m */; };
+		5FAF5257174D4D5600CAC810 /* RACSubjectSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 889D0A7F15974B2A00F833E3 /* RACSubjectSpec.m */; };
+		5FAF5258174D4D5600CAC810 /* RACSubscriberExamples.m in Sources */ = {isa = PBXBuildFile; fileRef = D0C70EC516659333005AAD03 /* RACSubscriberExamples.m */; };
+		5FAF5259174D4D5600CAC810 /* RACSubscriberSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D0C70EC7166595AD005AAD03 /* RACSubscriberSpec.m */; };
+		5FAF525A174D4D5600CAC810 /* RACSubscriptingAssignmentTrampolineSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 88FC735A16114FFB00F8A774 /* RACSubscriptingAssignmentTrampolineSpec.m */; };
+		5FAF525B174D4D5600CAC810 /* RACTestObject.m in Sources */ = {isa = PBXBuildFile; fileRef = 88442A331608A9AD00636B49 /* RACTestObject.m */; };
+		5FAF525C174D4D5600CAC810 /* RACTupleSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D02221611678910900DBD031 /* RACTupleSpec.m */; };
+		5FAF525D174D4D5600CAC810 /* NSObjectRACSelectorSignalSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 880D7A6516F7BB1A004A3361 /* NSObjectRACSelectorSignalSpec.m */; };
+		5FAF525E174D4D5600CAC810 /* RACSubclassObject.m in Sources */ = {isa = PBXBuildFile; fileRef = 880D7A6816F7BCC7004A3361 /* RACSubclassObject.m */; };
+		5FAF5262174D4D8F00CAC810 /* UIBarButtonItemRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 5FAF5261174D4D8E00CAC810 /* UIBarButtonItemRACSupportSpec.m */; };
+		5FAF5265174D500D00CAC810 /* libReactiveCocoa-iOS.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 88F440AB153DAC820097B4C3 /* libReactiveCocoa-iOS.a */; };
+		5FAF5289174E9CD300CAC810 /* CoreGraphics.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 5FAF5288174E9CD200CAC810 /* CoreGraphics.framework */; };
+		5FD7DC7A174F9EAF008710B4 /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 88CDF7C415000FCE00163A9F /* Foundation.framework */; };
+		5FD7DC7C174F9EEB008710B4 /* UIKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 5FD7DC7B174F9EEB008710B4 /* UIKit.framework */; };
+		5FD7DC7F174F9FC8008710B4 /* UIKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 5FD7DC7B174F9EEB008710B4 /* UIKit.framework */; };
+		5FDC35051736F54700792E52 /* NSString+RACKeyPathUtilities.m in Sources */ = {isa = PBXBuildFile; fileRef = 5FDC35021736F54700792E52 /* NSString+RACKeyPathUtilities.m */; };
+		5FDC35061736F54700792E52 /* NSString+RACKeyPathUtilities.m in Sources */ = {isa = PBXBuildFile; fileRef = 5FDC35021736F54700792E52 /* NSString+RACKeyPathUtilities.m */; };
+		5FDC350F1736F81900792E52 /* NSStringRACKeyPathUtilitiesSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 5FDC350E1736F81800792E52 /* NSStringRACKeyPathUtilitiesSpec.m */; };
+		6E58405516F22D7500F588A6 /* NSObject+RACDeallocating.h in Headers */ = {isa = PBXBuildFile; fileRef = 6E58405316F22D7500F588A6 /* NSObject+RACDeallocating.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		6E58405616F22D7500F588A6 /* NSObject+RACDeallocating.m in Sources */ = {isa = PBXBuildFile; fileRef = 6E58405416F22D7500F588A6 /* NSObject+RACDeallocating.m */; };
+		6E58405D16F22F7800F588A6 /* NSObject+RACDeallocating.m in Sources */ = {isa = PBXBuildFile; fileRef = 6E58405416F22D7500F588A6 /* NSObject+RACDeallocating.m */; };
+		6E58405F16F3414200F588A6 /* NSObjectRACDeallocatingSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 6E58405E16F3414200F588A6 /* NSObjectRACDeallocatingSpec.m */; };
+		6EA0C08216F4AEC1006EBEB2 /* NSObject+RACDeallocating.h in Headers */ = {isa = PBXBuildFile; fileRef = 6E58405316F22D7500F588A6 /* NSObject+RACDeallocating.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		7479F6E8186177D200575CDB /* RACIndexSetSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = 7479F6E4186177D200575CDB /* RACIndexSetSequence.m */; };
+		7479F6E9186177D200575CDB /* RACIndexSetSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = 7479F6E4186177D200575CDB /* RACIndexSetSequence.m */; };
+		7479F6EA186177D200575CDB /* RACIndexSetSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = 7479F6E4186177D200575CDB /* RACIndexSetSequence.m */; };
+		74F17318186024A900BC937C /* NSIndexSet+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = 74F17316186024A900BC937C /* NSIndexSet+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		74F17319186024A900BC937C /* NSIndexSet+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = 74F17316186024A900BC937C /* NSIndexSet+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		74F1731A186024A900BC937C /* NSIndexSet+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = 74F17316186024A900BC937C /* NSIndexSet+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		74F1731B186024A900BC937C /* NSIndexSet+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = 74F17317186024A900BC937C /* NSIndexSet+RACSequenceAdditions.m */; };
+		74F1731C186024A900BC937C /* NSIndexSet+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = 74F17317186024A900BC937C /* NSIndexSet+RACSequenceAdditions.m */; };
+		74F1731D186024A900BC937C /* NSIndexSet+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = 74F17317186024A900BC937C /* NSIndexSet+RACSequenceAdditions.m */; };
+		8801E7511644BDE200A155FE /* NSObjectRACLiftingSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 8801E7501644BDE200A155FE /* NSObjectRACLiftingSpec.m */; };
+		88037F8415056328001A5B19 /* Cocoa.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 88CDF7BF15000FCE00163A9F /* Cocoa.framework */; };
+		88037FB81505645C001A5B19 /* ReactiveCocoa.h in Headers */ = {isa = PBXBuildFile; fileRef = 88037F8C15056328001A5B19 /* ReactiveCocoa.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		88037FBB1505646C001A5B19 /* NSObject+RACPropertySubscribing.h in Headers */ = {isa = PBXBuildFile; fileRef = 88CDF82C15008C0500163A9F /* NSObject+RACPropertySubscribing.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		88037FBC1505646C001A5B19 /* RACSignal.h in Headers */ = {isa = PBXBuildFile; fileRef = 88CDF80415001CA800163A9F /* RACSignal.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		88037FBE1505646C001A5B19 /* RACSubscriber.h in Headers */ = {isa = PBXBuildFile; fileRef = 88CDF7FA150019CA00163A9F /* RACSubscriber.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		88037FC11505646C001A5B19 /* RACCommand.h in Headers */ = {isa = PBXBuildFile; fileRef = 882093E91501E6EE00796685 /* RACCommand.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		88037FC21505646C001A5B19 /* NSControl+RACCommandSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 882093E61501E6CB00796685 /* NSControl+RACCommandSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		88037FC71505647E001A5B19 /* NSObject+RACKVOWrapper.m in Sources */ = {isa = PBXBuildFile; fileRef = 88CDF82915008BB900163A9F /* NSObject+RACKVOWrapper.m */; };
+		88037FC91505648C001A5B19 /* RACSubscriber.m in Sources */ = {isa = PBXBuildFile; fileRef = 88CDF7FB150019CA00163A9F /* RACSubscriber.m */; };
+		88037FCC1505648C001A5B19 /* RACCommand.m in Sources */ = {isa = PBXBuildFile; fileRef = 882093EA1501E6EE00796685 /* RACCommand.m */; };
+		88037FCD1505648C001A5B19 /* NSControl+RACCommandSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 882093E71501E6CB00796685 /* NSControl+RACCommandSupport.m */; };
+		88037FD9150564D9001A5B19 /* ReactiveCocoa.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 88037F8315056328001A5B19 /* ReactiveCocoa.framework */; };
+		8803C011166732BA00C36839 /* RACSchedulerSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 8803C010166732BA00C36839 /* RACSchedulerSpec.m */; };
+		880B9176150B09190008488E /* RACSubject.h in Headers */ = {isa = PBXBuildFile; fileRef = 880B9174150B09190008488E /* RACSubject.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		880B9177150B09190008488E /* RACSubject.m in Sources */ = {isa = PBXBuildFile; fileRef = 880B9175150B09190008488E /* RACSubject.m */; };
+		880D7A5A16F7B351004A3361 /* NSObject+RACSelectorSignal.h in Headers */ = {isa = PBXBuildFile; fileRef = 880D7A5816F7B351004A3361 /* NSObject+RACSelectorSignal.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		880D7A5B16F7B351004A3361 /* NSObject+RACSelectorSignal.h in Headers */ = {isa = PBXBuildFile; fileRef = 880D7A5816F7B351004A3361 /* NSObject+RACSelectorSignal.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		880D7A5C16F7B351004A3361 /* NSObject+RACSelectorSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = 880D7A5916F7B351004A3361 /* NSObject+RACSelectorSignal.m */; };
+		880D7A5D16F7B351004A3361 /* NSObject+RACSelectorSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = 880D7A5916F7B351004A3361 /* NSObject+RACSelectorSignal.m */; };
+		880D7A6616F7BB1A004A3361 /* NSObjectRACSelectorSignalSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 880D7A6516F7BB1A004A3361 /* NSObjectRACSelectorSignalSpec.m */; };
+		880D7A6916F7BCC7004A3361 /* RACSubclassObject.m in Sources */ = {isa = PBXBuildFile; fileRef = 880D7A6816F7BCC7004A3361 /* RACSubclassObject.m */; };
+		881B37CC152260BF0079220B /* RACUnit.h in Headers */ = {isa = PBXBuildFile; fileRef = 881B37CA152260BF0079220B /* RACUnit.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		881B37CD152260BF0079220B /* RACUnit.m in Sources */ = {isa = PBXBuildFile; fileRef = 881B37CB152260BF0079220B /* RACUnit.m */; };
+		881E86A21669304800667F7B /* RACCompoundDisposable.h in Headers */ = {isa = PBXBuildFile; fileRef = 881E86A01669304700667F7B /* RACCompoundDisposable.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		881E86A41669304800667F7B /* RACCompoundDisposable.m in Sources */ = {isa = PBXBuildFile; fileRef = 881E86A11669304700667F7B /* RACCompoundDisposable.m */; };
+		881E86A51669304800667F7B /* RACCompoundDisposable.m in Sources */ = {isa = PBXBuildFile; fileRef = 881E86A11669304700667F7B /* RACCompoundDisposable.m */; };
+		881E86BA1669350B00667F7B /* RACCompoundDisposableSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 881E86B91669350B00667F7B /* RACCompoundDisposableSpec.m */; };
+		881E87AC16695C5600667F7B /* RACQueueScheduler.h in Headers */ = {isa = PBXBuildFile; fileRef = 881E87AA16695C5600667F7B /* RACQueueScheduler.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		881E87AE16695C5600667F7B /* RACQueueScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = 881E87AB16695C5600667F7B /* RACQueueScheduler.m */; };
+		881E87AF16695C5600667F7B /* RACQueueScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = 881E87AB16695C5600667F7B /* RACQueueScheduler.m */; };
+		881E87B416695EDF00667F7B /* RACImmediateScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = 881E87B116695EDF00667F7B /* RACImmediateScheduler.m */; };
+		881E87B516695EDF00667F7B /* RACImmediateScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = 881E87B116695EDF00667F7B /* RACImmediateScheduler.m */; };
+		881E87C41669636000667F7B /* RACSubscriptionScheduler.h in Headers */ = {isa = PBXBuildFile; fileRef = 881E87C21669635F00667F7B /* RACSubscriptionScheduler.h */; };
+		881E87C61669636000667F7B /* RACSubscriptionScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = 881E87C31669636000667F7B /* RACSubscriptionScheduler.m */; };
+		881E87C71669636000667F7B /* RACSubscriptionScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = 881E87C31669636000667F7B /* RACSubscriptionScheduler.m */; };
+		8820937C1501C8A600796685 /* RACSignalSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 8820937B1501C8A600796685 /* RACSignalSpec.m */; };
+		882CCA1E15F1564D00937D6E /* RACCommandSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 882CCA1D15F1564D00937D6E /* RACCommandSpec.m */; };
+		882D071917614FA7009EDA69 /* RACTargetQueueScheduler.h in Headers */ = {isa = PBXBuildFile; fileRef = 882D071717614FA7009EDA69 /* RACTargetQueueScheduler.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		882D071A17614FA7009EDA69 /* RACTargetQueueScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = 882D071817614FA7009EDA69 /* RACTargetQueueScheduler.m */; };
+		882D071F17615139009EDA69 /* RACTargetQueueScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = 882D071817614FA7009EDA69 /* RACTargetQueueScheduler.m */; };
+		882D072117615381009EDA69 /* RACQueueScheduler+Subclass.h in Headers */ = {isa = PBXBuildFile; fileRef = 882D07201761521B009EDA69 /* RACQueueScheduler+Subclass.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		88302BFD1762A9E6003633BD /* RACTestExampleScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = 88302BFC1762A9E6003633BD /* RACTestExampleScheduler.m */; };
+		88302BFE1762A9E6003633BD /* RACTestExampleScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = 88302BFC1762A9E6003633BD /* RACTestExampleScheduler.m */; };
+		88302C2E1762C180003633BD /* RACTargetQueueSchedulerSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 88302C2D1762C180003633BD /* RACTargetQueueSchedulerSpec.m */; };
+		88302C2F1762C180003633BD /* RACTargetQueueSchedulerSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 88302C2D1762C180003633BD /* RACTargetQueueSchedulerSpec.m */; };
+		88302C961762EC79003633BD /* RACQueueScheduler.h in Headers */ = {isa = PBXBuildFile; fileRef = 881E87AA16695C5600667F7B /* RACQueueScheduler.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		88302C9B1762EC7E003633BD /* RACQueueScheduler+Subclass.h in Headers */ = {isa = PBXBuildFile; fileRef = 882D07201761521B009EDA69 /* RACQueueScheduler+Subclass.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		88302CA21762F62D003633BD /* RACTargetQueueScheduler.h in Headers */ = {isa = PBXBuildFile; fileRef = 882D071717614FA7009EDA69 /* RACTargetQueueScheduler.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		8837EA1816A5A33300FC3CDF /* RACKVOTrampoline.m in Sources */ = {isa = PBXBuildFile; fileRef = 8837EA1516A5A33300FC3CDF /* RACKVOTrampoline.m */; };
+		8837EA1916A5A33300FC3CDF /* RACKVOTrampoline.m in Sources */ = {isa = PBXBuildFile; fileRef = 8837EA1516A5A33300FC3CDF /* RACKVOTrampoline.m */; };
+		883A84DA1513964B006DB4C7 /* RACBehaviorSubject.h in Headers */ = {isa = PBXBuildFile; fileRef = 883A84D81513964B006DB4C7 /* RACBehaviorSubject.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		883A84DB1513964B006DB4C7 /* RACBehaviorSubject.m in Sources */ = {isa = PBXBuildFile; fileRef = 883A84D91513964B006DB4C7 /* RACBehaviorSubject.m */; };
+		883A84DF1513B5EC006DB4C7 /* RACDisposable.h in Headers */ = {isa = PBXBuildFile; fileRef = 883A84DD1513B5EC006DB4C7 /* RACDisposable.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		883A84E01513B5EC006DB4C7 /* RACDisposable.m in Sources */ = {isa = PBXBuildFile; fileRef = 883A84DE1513B5EC006DB4C7 /* RACDisposable.m */; };
+		88442A341608A9AD00636B49 /* RACTestObject.m in Sources */ = {isa = PBXBuildFile; fileRef = 88442A331608A9AD00636B49 /* RACTestObject.m */; };
+		884476E4152367D100958F44 /* RACScopedDisposable.h in Headers */ = {isa = PBXBuildFile; fileRef = 884476E2152367D100958F44 /* RACScopedDisposable.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		884476E5152367D100958F44 /* RACScopedDisposable.m in Sources */ = {isa = PBXBuildFile; fileRef = 884476E3152367D100958F44 /* RACScopedDisposable.m */; };
+		884848B615F658B800B11BD0 /* NSControlRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 884848B515F658B800B11BD0 /* NSControlRACSupportSpec.m */; };
+		8851A38B16161D500050D47F /* NSObjectRACPropertySubscribingSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 8851A38A16161D500050D47F /* NSObjectRACPropertySubscribingSpec.m */; };
+		886678711518DCD800DE77EC /* NSObject+RACPropertySubscribing.m in Sources */ = {isa = PBXBuildFile; fileRef = 886678701518DCD800DE77EC /* NSObject+RACPropertySubscribing.m */; };
+		886CEACD163DE669007632D1 /* RACBlockTrampolineSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 886CEACC163DE669007632D1 /* RACBlockTrampolineSpec.m */; };
+		886CEAE2163DE942007632D1 /* NSObject+RACLifting.h in Headers */ = {isa = PBXBuildFile; fileRef = 886CEAE0163DE942007632D1 /* NSObject+RACLifting.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		886CEAE4163DE942007632D1 /* NSObject+RACLifting.m in Sources */ = {isa = PBXBuildFile; fileRef = 886CEAE1163DE942007632D1 /* NSObject+RACLifting.m */; };
+		886CEAE5163DE942007632D1 /* NSObject+RACLifting.m in Sources */ = {isa = PBXBuildFile; fileRef = 886CEAE1163DE942007632D1 /* NSObject+RACLifting.m */; };
+		886F702A1551CF920045D68B /* RACGroupedSignal.h in Headers */ = {isa = PBXBuildFile; fileRef = 886F70281551CF920045D68B /* RACGroupedSignal.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		886F702B1551CF920045D68B /* RACGroupedSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = 886F70291551CF920045D68B /* RACGroupedSignal.m */; };
+		886F702C1551CF9D0045D68B /* RACGroupedSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = 886F70291551CF920045D68B /* RACGroupedSignal.m */; };
+		887ACDA9165878A8009190AD /* NSInvocation+RACTypeParsing.m in Sources */ = {isa = PBXBuildFile; fileRef = 887ACDA6165878A7009190AD /* NSInvocation+RACTypeParsing.m */; };
+		887ACDAA165878A8009190AD /* NSInvocation+RACTypeParsing.m in Sources */ = {isa = PBXBuildFile; fileRef = 887ACDA6165878A7009190AD /* NSInvocation+RACTypeParsing.m */; };
+		8882D4601673B0450080E7CD /* RACBlockTrampoline.m in Sources */ = {isa = PBXBuildFile; fileRef = 888439A21634E10D00DED0DB /* RACBlockTrampoline.m */; };
+		8884DD651756ACF600F6C379 /* RACSignalStartExamples.m in Sources */ = {isa = PBXBuildFile; fileRef = 8884DD641756ACF600F6C379 /* RACSignalStartExamples.m */; };
+		8884DD6B1756B65300F6C379 /* RACSignalStartExamples.m in Sources */ = {isa = PBXBuildFile; fileRef = 8884DD641756ACF600F6C379 /* RACSignalStartExamples.m */; };
+		88977C3E1512914A00A09EC5 /* RACSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = 88977C3D1512914A00A09EC5 /* RACSignal.m */; };
+		889D0A8015974B2A00F833E3 /* RACSubjectSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 889D0A7F15974B2A00F833E3 /* RACSubjectSpec.m */; };
+		88A0B6D2165B2B09005DE8F3 /* RACBlockTrampoline.m in Sources */ = {isa = PBXBuildFile; fileRef = 888439A21634E10D00DED0DB /* RACBlockTrampoline.m */; };
+		88A0B6D3165B2B77005DE8F3 /* RACSubscriptingAssignmentTrampoline.h in Headers */ = {isa = PBXBuildFile; fileRef = 88FC735316114F9C00F8A774 /* RACSubscriptingAssignmentTrampoline.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		88B76F8E153726B00053EAE2 /* RACTuple.h in Headers */ = {isa = PBXBuildFile; fileRef = 88B76F8C153726B00053EAE2 /* RACTuple.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		88B76F8F153726B00053EAE2 /* RACTuple.m in Sources */ = {isa = PBXBuildFile; fileRef = 88B76F8D153726B00053EAE2 /* RACTuple.m */; };
+		88C5A0241692460A0045EF05 /* RACMulticastConnection.h in Headers */ = {isa = PBXBuildFile; fileRef = 88C5A0231692460A0045EF05 /* RACMulticastConnection.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		88C5A026169246140045EF05 /* RACMulticastConnection.m in Sources */ = {isa = PBXBuildFile; fileRef = 88C5A025169246140045EF05 /* RACMulticastConnection.m */; };
+		88C5A027169246140045EF05 /* RACMulticastConnection.m in Sources */ = {isa = PBXBuildFile; fileRef = 88C5A025169246140045EF05 /* RACMulticastConnection.m */; };
+		88C5A02916924BFC0045EF05 /* RACMulticastConnectionSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 88C5A02816924BFC0045EF05 /* RACMulticastConnectionSpec.m */; };
+		88CDF7DE15000FCF00163A9F /* SenTestingKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 88CDF7DD15000FCF00163A9F /* SenTestingKit.framework */; };
+		88CDF7DF15000FCF00163A9F /* Cocoa.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 88CDF7BF15000FCE00163A9F /* Cocoa.framework */; };
+		88CDF7E715000FCF00163A9F /* InfoPlist.strings in Resources */ = {isa = PBXBuildFile; fileRef = 88CDF7E515000FCF00163A9F /* InfoPlist.strings */; };
+		88D4AB3E1510F6C30011494F /* RACReplaySubject.h in Headers */ = {isa = PBXBuildFile; fileRef = 88D4AB3C1510F6C30011494F /* RACReplaySubject.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		88D4AB3F1510F6C30011494F /* RACReplaySubject.m in Sources */ = {isa = PBXBuildFile; fileRef = 88D4AB3D1510F6C30011494F /* RACReplaySubject.m */; };
+		88DA309815071CBA00C19D0F /* RACValueTransformer.m in Sources */ = {isa = PBXBuildFile; fileRef = 88DA309615071CBA00C19D0F /* RACValueTransformer.m */; };
+		88E2C6B4153C771C00C7493C /* RACScheduler.h in Headers */ = {isa = PBXBuildFile; fileRef = 88E2C6B2153C771C00C7493C /* RACScheduler.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		88E2C6B5153C771C00C7493C /* RACScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = 88E2C6B3153C771C00C7493C /* RACScheduler.m */; };
+		88F440BA153DAD570097B4C3 /* RACCommand.m in Sources */ = {isa = PBXBuildFile; fileRef = 882093EA1501E6EE00796685 /* RACCommand.m */; };
+		88F440BC153DAD5A0097B4C3 /* RACSubscriber.m in Sources */ = {isa = PBXBuildFile; fileRef = 88CDF7FB150019CA00163A9F /* RACSubscriber.m */; };
+		88F440BD153DAD5C0097B4C3 /* RACSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = 88977C3D1512914A00A09EC5 /* RACSignal.m */; };
+		88F440C0153DAD630097B4C3 /* RACSubject.m in Sources */ = {isa = PBXBuildFile; fileRef = 880B9175150B09190008488E /* RACSubject.m */; };
+		88F440C1153DAD640097B4C3 /* RACReplaySubject.m in Sources */ = {isa = PBXBuildFile; fileRef = 88D4AB3D1510F6C30011494F /* RACReplaySubject.m */; };
+		88F440C3153DAD690097B4C3 /* RACBehaviorSubject.m in Sources */ = {isa = PBXBuildFile; fileRef = 883A84D91513964B006DB4C7 /* RACBehaviorSubject.m */; };
+		88F440C5153DAD6C0097B4C3 /* RACDisposable.m in Sources */ = {isa = PBXBuildFile; fileRef = 883A84DE1513B5EC006DB4C7 /* RACDisposable.m */; };
+		88F440C6153DAD6E0097B4C3 /* RACScopedDisposable.m in Sources */ = {isa = PBXBuildFile; fileRef = 884476E3152367D100958F44 /* RACScopedDisposable.m */; };
+		88F440C9153DAD740097B4C3 /* RACUnit.m in Sources */ = {isa = PBXBuildFile; fileRef = 881B37CB152260BF0079220B /* RACUnit.m */; };
+		88F440CA153DAD760097B4C3 /* RACTuple.m in Sources */ = {isa = PBXBuildFile; fileRef = 88B76F8D153726B00053EAE2 /* RACTuple.m */; };
+		88F440CB153DAD780097B4C3 /* RACScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = 88E2C6B3153C771C00C7493C /* RACScheduler.m */; };
+		88F440CE153DAD830097B4C3 /* NSObject+RACKVOWrapper.m in Sources */ = {isa = PBXBuildFile; fileRef = 88CDF82915008BB900163A9F /* NSObject+RACKVOWrapper.m */; };
+		88F440CF153DAD850097B4C3 /* NSObject+RACPropertySubscribing.m in Sources */ = {isa = PBXBuildFile; fileRef = 886678701518DCD800DE77EC /* NSObject+RACPropertySubscribing.m */; };
+		88F440D3153DADEA0097B4C3 /* NSObject+RACAppKitBindings.h in Headers */ = {isa = PBXBuildFile; fileRef = 88F440D1153DADEA0097B4C3 /* NSObject+RACAppKitBindings.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		88F440D4153DADEA0097B4C3 /* NSObject+RACAppKitBindings.m in Sources */ = {isa = PBXBuildFile; fileRef = 88F440D2153DADEA0097B4C3 /* NSObject+RACAppKitBindings.m */; };
+		88F44263153DC2C70097B4C3 /* UIControl+RACSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 88F44260153DC0450097B4C3 /* UIControl+RACSignalSupport.m */; };
+		88F44267153DCAC50097B4C3 /* UITextField+RACSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 88F44265153DCAC50097B4C3 /* UITextField+RACSignalSupport.m */; };
+		88FC735716114F9C00F8A774 /* RACSubscriptingAssignmentTrampoline.m in Sources */ = {isa = PBXBuildFile; fileRef = 88FC735416114F9C00F8A774 /* RACSubscriptingAssignmentTrampoline.m */; };
+		88FC735816114F9C00F8A774 /* RACSubscriptingAssignmentTrampoline.m in Sources */ = {isa = PBXBuildFile; fileRef = 88FC735416114F9C00F8A774 /* RACSubscriptingAssignmentTrampoline.m */; };
+		88FC735B16114FFB00F8A774 /* RACSubscriptingAssignmentTrampolineSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 88FC735A16114FFB00F8A774 /* RACSubscriptingAssignmentTrampolineSpec.m */; };
+		A1FCC27715666AA3008C9686 /* UITextView+RACSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = A1FCC27315666AA3008C9686 /* UITextView+RACSignalSupport.m */; };
+		A1FCC374156754A7008C9686 /* RACObjCRuntime.m in Sources */ = {isa = PBXBuildFile; fileRef = A1FCC371156754A7008C9686 /* RACObjCRuntime.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+		A1FCC375156754A7008C9686 /* RACObjCRuntime.m in Sources */ = {isa = PBXBuildFile; fileRef = A1FCC371156754A7008C9686 /* RACObjCRuntime.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+		A1FCC37B1567DED0008C9686 /* RACDelegateProxy.m in Sources */ = {isa = PBXBuildFile; fileRef = A1FCC3771567DED0008C9686 /* RACDelegateProxy.m */; };
+		AC65FD52176DECB1005ED22B /* UIAlertViewRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = AC65FD51176DECB1005ED22B /* UIAlertViewRACSupportSpec.m */; };
+		ACB0EAF31797DDD400942FFC /* UIAlertView+RACSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = ACB0EAF11797DDD400942FFC /* UIAlertView+RACSignalSupport.m */; };
+		ACB0EAF41797DDD400942FFC /* UIAlertView+RACSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = ACB0EAF21797DDD400942FFC /* UIAlertView+RACSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		BE527E9318636F7F006349E8 /* NSUserDefaults+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = BE527E9118636F7F006349E8 /* NSUserDefaults+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		BE527E9418636F7F006349E8 /* NSUserDefaults+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = BE527E9118636F7F006349E8 /* NSUserDefaults+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		BE527E9518636F7F006349E8 /* NSUserDefaults+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = BE527E9118636F7F006349E8 /* NSUserDefaults+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		BE527E9618636F7F006349E8 /* NSUserDefaults+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = BE527E9218636F7F006349E8 /* NSUserDefaults+RACSupport.m */; };
+		BE527E9718636F7F006349E8 /* NSUserDefaults+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = BE527E9218636F7F006349E8 /* NSUserDefaults+RACSupport.m */; };
+		BE527E9818636F7F006349E8 /* NSUserDefaults+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = BE527E9218636F7F006349E8 /* NSUserDefaults+RACSupport.m */; };
+		BE527E9F1863705B006349E8 /* NSUserDefaultsRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = BE527E9E1863705B006349E8 /* NSUserDefaultsRACSupportSpec.m */; };
+		BE527EA01863706B006349E8 /* NSUserDefaultsRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = BE527E9E1863705B006349E8 /* NSUserDefaultsRACSupportSpec.m */; };
+		CD11C6F318714CD0007C7CFD /* UITableViewHeaderFooterView+RACSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = CD11C6F118714CD0007C7CFD /* UITableViewHeaderFooterView+RACSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		CD11C6F418714CD0007C7CFD /* UITableViewHeaderFooterView+RACSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = CD11C6F218714CD0007C7CFD /* UITableViewHeaderFooterView+RACSignalSupport.m */; };
+		CD11C6FF18714F00007C7CFD /* RACTestTableViewController.m in Sources */ = {isa = PBXBuildFile; fileRef = CD11C6FD18714DFB007C7CFD /* RACTestTableViewController.m */; };
+		CD11C700187151AE007C7CFD /* UITableViewHeaderFooterViewRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = CD11C6F918714DC1007C7CFD /* UITableViewHeaderFooterViewRACSupportSpec.m */; };
+		D004BC9C177E1A2B00A5B8C5 /* UIActionSheetRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D004BC9B177E1A2B00A5B8C5 /* UIActionSheetRACSupportSpec.m */; };
+		D005A259169A3B7D00A9D2DB /* RACBacktrace.h in Headers */ = {isa = PBXBuildFile; fileRef = D02538A115E2D7FB005BACB8 /* RACBacktrace.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D00930791788AB7B00EE7E8B /* RACTestScheduler.h in Headers */ = {isa = PBXBuildFile; fileRef = D00930771788AB7B00EE7E8B /* RACTestScheduler.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D009307A1788AB7B00EE7E8B /* RACTestScheduler.h in Headers */ = {isa = PBXBuildFile; fileRef = D00930771788AB7B00EE7E8B /* RACTestScheduler.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D009307B1788AB7B00EE7E8B /* RACTestScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = D00930781788AB7B00EE7E8B /* RACTestScheduler.m */; };
+		D009307C1788AB7B00EE7E8B /* RACTestScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = D00930781788AB7B00EE7E8B /* RACTestScheduler.m */; };
+		D011F9D01782AFD400EE7E38 /* NSObjectRACAppKitBindingsSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D011F9CF1782AFD400EE7E38 /* NSObjectRACAppKitBindingsSpec.m */; };
+		D013A3D91807B5ED0072B6CE /* RACErrorSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = D013A3D51807B5ED0072B6CE /* RACErrorSignal.m */; };
+		D013A3DA1807B5ED0072B6CE /* RACErrorSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = D013A3D51807B5ED0072B6CE /* RACErrorSignal.m */; };
+		D013A3DB1807B5ED0072B6CE /* RACErrorSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = D013A3D51807B5ED0072B6CE /* RACErrorSignal.m */; };
+		D013A3E11807B7450072B6CE /* RACEmptySignal.m in Sources */ = {isa = PBXBuildFile; fileRef = D013A3DD1807B7450072B6CE /* RACEmptySignal.m */; };
+		D013A3E21807B7450072B6CE /* RACEmptySignal.m in Sources */ = {isa = PBXBuildFile; fileRef = D013A3DD1807B7450072B6CE /* RACEmptySignal.m */; };
+		D013A3E31807B7450072B6CE /* RACEmptySignal.m in Sources */ = {isa = PBXBuildFile; fileRef = D013A3DD1807B7450072B6CE /* RACEmptySignal.m */; };
+		D013A3E91807B7C30072B6CE /* RACReturnSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = D013A3E51807B7C30072B6CE /* RACReturnSignal.m */; };
+		D013A3EA1807B7C30072B6CE /* RACReturnSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = D013A3E51807B7C30072B6CE /* RACReturnSignal.m */; };
+		D013A3EB1807B7C30072B6CE /* RACReturnSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = D013A3E51807B7C30072B6CE /* RACReturnSignal.m */; };
+		D013A3F21807B9690072B6CE /* RACDynamicSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = D013A3EE1807B9690072B6CE /* RACDynamicSignal.m */; };
+		D013A3F31807B9690072B6CE /* RACDynamicSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = D013A3EE1807B9690072B6CE /* RACDynamicSignal.m */; };
+		D013A3F41807B9690072B6CE /* RACDynamicSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = D013A3EE1807B9690072B6CE /* RACDynamicSignal.m */; };
+		D020F3DB17F6A3E40092BED2 /* RACCompoundDisposableProvider.d in Sources */ = {isa = PBXBuildFile; fileRef = D020F3DA17F6A3E40092BED2 /* RACCompoundDisposableProvider.d */; };
+		D020F3DC17F6A3E40092BED2 /* RACCompoundDisposableProvider.d in Sources */ = {isa = PBXBuildFile; fileRef = D020F3DA17F6A3E40092BED2 /* RACCompoundDisposableProvider.d */; };
+		D02221621678910900DBD031 /* RACTupleSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D02221611678910900DBD031 /* RACTupleSpec.m */; };
+		D028DB74179E53CB00D1042F /* RACSerialDisposable.h in Headers */ = {isa = PBXBuildFile; fileRef = D028DB72179E53CB00D1042F /* RACSerialDisposable.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D028DB75179E53CB00D1042F /* RACSerialDisposable.h in Headers */ = {isa = PBXBuildFile; fileRef = D028DB72179E53CB00D1042F /* RACSerialDisposable.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D028DB76179E53CB00D1042F /* RACSerialDisposable.m in Sources */ = {isa = PBXBuildFile; fileRef = D028DB73179E53CB00D1042F /* RACSerialDisposable.m */; };
+		D028DB77179E53CB00D1042F /* RACSerialDisposable.m in Sources */ = {isa = PBXBuildFile; fileRef = D028DB73179E53CB00D1042F /* RACSerialDisposable.m */; };
+		D028DB7D179E591E00D1042F /* RACSerialDisposableSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D028DB7C179E591E00D1042F /* RACSerialDisposableSpec.m */; };
+		D028DB7E179E591E00D1042F /* RACSerialDisposableSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D028DB7C179E591E00D1042F /* RACSerialDisposableSpec.m */; };
+		D028DB87179E616700D1042F /* UITableViewCell+RACSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = D028DB85179E616700D1042F /* UITableViewCell+RACSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D028DB88179E616700D1042F /* UITableViewCell+RACSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = D028DB86179E616700D1042F /* UITableViewCell+RACSignalSupport.m */; };
+		D0307EDF1731AAE100D83211 /* RACTupleSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0307EDC1731AAE100D83211 /* RACTupleSequence.m */; };
+		D0307EE01731AAE100D83211 /* RACTupleSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0307EDC1731AAE100D83211 /* RACTupleSequence.m */; };
+		D03525D417E2EBC90099CBAB /* RACSignalProvider.d in Sources */ = {isa = PBXBuildFile; fileRef = D03525D317E2EBC90099CBAB /* RACSignalProvider.d */; };
+		D03525D917E2FAAD0099CBAB /* RACSignalProvider.d in Sources */ = {isa = PBXBuildFile; fileRef = D03525D317E2EBC90099CBAB /* RACSignalProvider.d */; };
+		D041376915D2281C004BBF80 /* RACKVOWrapperSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D041376815D2281C004BBF80 /* RACKVOWrapperSpec.m */; };
+		D0487AB3164314430085D890 /* RACStreamExamples.m in Sources */ = {isa = PBXBuildFile; fileRef = D0487AB2164314430085D890 /* RACStreamExamples.m */; };
+		D049804217F91F42001EE042 /* EXTRuntimeExtensions.m in Sources */ = {isa = PBXBuildFile; fileRef = D05F9D3417984EC000FD7982 /* EXTRuntimeExtensions.m */; };
+		D05AD39617F2D5700080895B /* Cocoa.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = D05AD39517F2D5700080895B /* Cocoa.framework */; };
+		D05AD3BF17F2DA2A0080895B /* RACSubscriber.m in Sources */ = {isa = PBXBuildFile; fileRef = 88CDF7FB150019CA00163A9F /* RACSubscriber.m */; };
+		D05AD3C017F2DA300080895B /* RACSubscriber.h in Headers */ = {isa = PBXBuildFile; fileRef = 88CDF7FA150019CA00163A9F /* RACSubscriber.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD3C117F2DB100080895B /* RACPassthroughSubscriber.m in Sources */ = {isa = PBXBuildFile; fileRef = D0A0E22D176A8CD6007273ED /* RACPassthroughSubscriber.m */; };
+		D05AD3C217F2DB100080895B /* RACBlockTrampoline.m in Sources */ = {isa = PBXBuildFile; fileRef = 888439A21634E10D00DED0DB /* RACBlockTrampoline.m */; };
+		D05AD3C317F2DB100080895B /* RACUnit.h in Headers */ = {isa = PBXBuildFile; fileRef = 881B37CA152260BF0079220B /* RACUnit.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD3C417F2DB100080895B /* RACUnit.m in Sources */ = {isa = PBXBuildFile; fileRef = 881B37CB152260BF0079220B /* RACUnit.m */; };
+		D05AD3C517F2DB100080895B /* RACTuple.h in Headers */ = {isa = PBXBuildFile; fileRef = 88B76F8C153726B00053EAE2 /* RACTuple.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD3C617F2DB100080895B /* RACTuple.m in Sources */ = {isa = PBXBuildFile; fileRef = 88B76F8D153726B00053EAE2 /* RACTuple.m */; };
+		D05AD3C717F2DB100080895B /* RACBacktrace.h in Headers */ = {isa = PBXBuildFile; fileRef = D02538A115E2D7FB005BACB8 /* RACBacktrace.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD3C817F2DB100080895B /* RACBacktrace.m in Sources */ = {isa = PBXBuildFile; fileRef = D0DFBCCD15DD6D40009DADB3 /* RACBacktrace.m */; };
+		D05AD3C917F2DB100080895B /* RACSubscriptingAssignmentTrampoline.h in Headers */ = {isa = PBXBuildFile; fileRef = 88FC735316114F9C00F8A774 /* RACSubscriptingAssignmentTrampoline.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD3CA17F2DB100080895B /* RACSubscriptingAssignmentTrampoline.m in Sources */ = {isa = PBXBuildFile; fileRef = 88FC735416114F9C00F8A774 /* RACSubscriptingAssignmentTrampoline.m */; };
+		D05AD3CB17F2DB100080895B /* NSObject+RACDeallocating.h in Headers */ = {isa = PBXBuildFile; fileRef = 6E58405316F22D7500F588A6 /* NSObject+RACDeallocating.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD3CC17F2DB100080895B /* NSObject+RACDeallocating.m in Sources */ = {isa = PBXBuildFile; fileRef = 6E58405416F22D7500F588A6 /* NSObject+RACDeallocating.m */; };
+		D05AD3CD17F2DB100080895B /* NSObject+RACLifting.h in Headers */ = {isa = PBXBuildFile; fileRef = 886CEAE0163DE942007632D1 /* NSObject+RACLifting.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD3CE17F2DB100080895B /* NSObject+RACLifting.m in Sources */ = {isa = PBXBuildFile; fileRef = 886CEAE1163DE942007632D1 /* NSObject+RACLifting.m */; };
+		D05AD3CF17F2DB100080895B /* NSInvocation+RACTypeParsing.m in Sources */ = {isa = PBXBuildFile; fileRef = 887ACDA6165878A7009190AD /* NSInvocation+RACTypeParsing.m */; };
+		D05AD3D017F2DB100080895B /* RACStream.h in Headers */ = {isa = PBXBuildFile; fileRef = D0D486FF1642550100DD7605 /* RACStream.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD3D117F2DB100080895B /* RACStream.m in Sources */ = {isa = PBXBuildFile; fileRef = D0D487001642550100DD7605 /* RACStream.m */; };
+		D05AD3D217F2DB1D0080895B /* RACSignal.h in Headers */ = {isa = PBXBuildFile; fileRef = 88CDF80415001CA800163A9F /* RACSignal.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD3D317F2DB1D0080895B /* RACSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = 88977C3D1512914A00A09EC5 /* RACSignal.m */; };
+		D05AD3D417F2DB1D0080895B /* RACSignal+Operations.h in Headers */ = {isa = PBXBuildFile; fileRef = D0D910CC15F915BD00AD2DDA /* RACSignal+Operations.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD3D517F2DB1D0080895B /* RACSignal+Operations.m in Sources */ = {isa = PBXBuildFile; fileRef = D0D910CD15F915BD00AD2DDA /* RACSignal+Operations.m */; };
+		D05AD3D617F2DB1D0080895B /* RACEvent.h in Headers */ = {isa = PBXBuildFile; fileRef = D077A16B169B740200057BB1 /* RACEvent.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD3D717F2DB1D0080895B /* RACEvent.m in Sources */ = {isa = PBXBuildFile; fileRef = D077A16C169B740200057BB1 /* RACEvent.m */; };
+		D05AD3D817F2DB1D0080895B /* RACMulticastConnection.h in Headers */ = {isa = PBXBuildFile; fileRef = 88C5A0231692460A0045EF05 /* RACMulticastConnection.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD3D917F2DB1D0080895B /* RACMulticastConnection.m in Sources */ = {isa = PBXBuildFile; fileRef = 88C5A025169246140045EF05 /* RACMulticastConnection.m */; };
+		D05AD3DA17F2DB1D0080895B /* RACGroupedSignal.h in Headers */ = {isa = PBXBuildFile; fileRef = 886F70281551CF920045D68B /* RACGroupedSignal.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD3DB17F2DB1D0080895B /* RACGroupedSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = 886F70291551CF920045D68B /* RACGroupedSignal.m */; };
+		D05AD3DC17F2DB1D0080895B /* RACSubject.h in Headers */ = {isa = PBXBuildFile; fileRef = 880B9174150B09190008488E /* RACSubject.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD3DD17F2DB1D0080895B /* RACSubject.m in Sources */ = {isa = PBXBuildFile; fileRef = 880B9175150B09190008488E /* RACSubject.m */; };
+		D05AD3DE17F2DB1D0080895B /* RACReplaySubject.h in Headers */ = {isa = PBXBuildFile; fileRef = 88D4AB3C1510F6C30011494F /* RACReplaySubject.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD3DF17F2DB1D0080895B /* RACReplaySubject.m in Sources */ = {isa = PBXBuildFile; fileRef = 88D4AB3D1510F6C30011494F /* RACReplaySubject.m */; };
+		D05AD3E017F2DB1D0080895B /* RACBehaviorSubject.h in Headers */ = {isa = PBXBuildFile; fileRef = 883A84D81513964B006DB4C7 /* RACBehaviorSubject.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD3E117F2DB1D0080895B /* RACBehaviorSubject.m in Sources */ = {isa = PBXBuildFile; fileRef = 883A84D91513964B006DB4C7 /* RACBehaviorSubject.m */; };
+		D05AD3E217F2DB230080895B /* RACDisposable.h in Headers */ = {isa = PBXBuildFile; fileRef = 883A84DD1513B5EC006DB4C7 /* RACDisposable.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD3E317F2DB230080895B /* RACDisposable.m in Sources */ = {isa = PBXBuildFile; fileRef = 883A84DE1513B5EC006DB4C7 /* RACDisposable.m */; };
+		D05AD3E417F2DB230080895B /* RACScopedDisposable.h in Headers */ = {isa = PBXBuildFile; fileRef = 884476E2152367D100958F44 /* RACScopedDisposable.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD3E517F2DB230080895B /* RACScopedDisposable.m in Sources */ = {isa = PBXBuildFile; fileRef = 884476E3152367D100958F44 /* RACScopedDisposable.m */; };
+		D05AD3E617F2DB230080895B /* RACCompoundDisposable.h in Headers */ = {isa = PBXBuildFile; fileRef = 881E86A01669304700667F7B /* RACCompoundDisposable.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD3E717F2DB230080895B /* RACCompoundDisposable.m in Sources */ = {isa = PBXBuildFile; fileRef = 881E86A11669304700667F7B /* RACCompoundDisposable.m */; };
+		D05AD3E817F2DB230080895B /* RACSerialDisposable.h in Headers */ = {isa = PBXBuildFile; fileRef = D028DB72179E53CB00D1042F /* RACSerialDisposable.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD3E917F2DB230080895B /* RACSerialDisposable.m in Sources */ = {isa = PBXBuildFile; fileRef = D028DB73179E53CB00D1042F /* RACSerialDisposable.m */; };
+		D05AD3EA17F2DB270080895B /* RACCommand.h in Headers */ = {isa = PBXBuildFile; fileRef = 882093E91501E6EE00796685 /* RACCommand.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD3EB17F2DB270080895B /* RACCommand.m in Sources */ = {isa = PBXBuildFile; fileRef = 882093EA1501E6EE00796685 /* RACCommand.m */; };
+		D05AD3EE17F2DB4F0080895B /* RACSequence.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E967671641EF9C00FCFF06 /* RACSequence.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD3EF17F2DB4F0080895B /* RACSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967681641EF9C00FCFF06 /* RACSequence.m */; };
+		D05AD3F017F2DB4F0080895B /* RACArraySequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967621641EF9C00FCFF06 /* RACArraySequence.m */; };
+		D05AD3F117F2DB4F0080895B /* RACDynamicSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967641641EF9C00FCFF06 /* RACDynamicSequence.m */; };
+		D05AD3F217F2DB4F0080895B /* RACEagerSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F9743F61694A2460024EB82 /* RACEagerSequence.m */; };
+		D05AD3F317F2DB4F0080895B /* RACEmptySequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967661641EF9C00FCFF06 /* RACEmptySequence.m */; };
+		D05AD3F417F2DB4F0080895B /* RACStringSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E9676A1641EF9C00FCFF06 /* RACStringSequence.m */; };
+		D05AD3F517F2DB4F0080895B /* RACSignalSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0EE284A164D906B006954A4 /* RACSignalSequence.m */; };
+		D05AD3F617F2DB4F0080895B /* RACTupleSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0307EDC1731AAE100D83211 /* RACTupleSequence.m */; };
+		D05AD3F717F2DB4F0080895B /* RACUnarySequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D07CD7151731BA3900DE2394 /* RACUnarySequence.m */; };
+		D05AD3FA17F2DB5D0080895B /* RACScheduler.h in Headers */ = {isa = PBXBuildFile; fileRef = 88E2C6B2153C771C00C7493C /* RACScheduler.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD3FB17F2DB5D0080895B /* RACScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = 88E2C6B3153C771C00C7493C /* RACScheduler.m */; };
+		D05AD3FC17F2DB5D0080895B /* RACQueueScheduler.h in Headers */ = {isa = PBXBuildFile; fileRef = 881E87AA16695C5600667F7B /* RACQueueScheduler.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD3FD17F2DB5D0080895B /* RACQueueScheduler+Subclass.h in Headers */ = {isa = PBXBuildFile; fileRef = 882D07201761521B009EDA69 /* RACQueueScheduler+Subclass.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD3FE17F2DB5D0080895B /* RACQueueScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = 881E87AB16695C5600667F7B /* RACQueueScheduler.m */; };
+		D05AD3FF17F2DB5D0080895B /* RACTargetQueueScheduler.h in Headers */ = {isa = PBXBuildFile; fileRef = 882D071717614FA7009EDA69 /* RACTargetQueueScheduler.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD40017F2DB5D0080895B /* RACTargetQueueScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = 882D071817614FA7009EDA69 /* RACTargetQueueScheduler.m */; };
+		D05AD40217F2DB5D0080895B /* RACImmediateScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = 881E87B116695EDF00667F7B /* RACImmediateScheduler.m */; };
+		D05AD40317F2DB5D0080895B /* RACSubscriptionScheduler.h in Headers */ = {isa = PBXBuildFile; fileRef = 881E87C21669635F00667F7B /* RACSubscriptionScheduler.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD40417F2DB5D0080895B /* RACSubscriptionScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = 881E87C31669636000667F7B /* RACSubscriptionScheduler.m */; };
+		D05AD40517F2DB5D0080895B /* RACTestScheduler.h in Headers */ = {isa = PBXBuildFile; fileRef = D00930771788AB7B00EE7E8B /* RACTestScheduler.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD40617F2DB5D0080895B /* RACTestScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = D00930781788AB7B00EE7E8B /* RACTestScheduler.m */; };
+		D05AD40717F2DB6A0080895B /* NSArray+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E967571641EF9C00FCFF06 /* NSArray+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD40817F2DB6A0080895B /* NSArray+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967581641EF9C00FCFF06 /* NSArray+RACSequenceAdditions.m */; };
+		D05AD40917F2DB6A0080895B /* NSData+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 88442C8716090C1500636B49 /* NSData+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD40A17F2DB6A0080895B /* NSData+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 88442C8816090C1500636B49 /* NSData+RACSupport.m */; };
+		D05AD40B17F2DB6A0080895B /* NSDictionary+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E967591641EF9C00FCFF06 /* NSDictionary+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD40C17F2DB6A0080895B /* NSDictionary+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E9675A1641EF9C00FCFF06 /* NSDictionary+RACSequenceAdditions.m */; };
+		D05AD40D17F2DB6A0080895B /* NSEnumerator+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = 5F773DE8169B46670023069D /* NSEnumerator+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD40E17F2DB6A0080895B /* NSEnumerator+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F773DE9169B46670023069D /* NSEnumerator+RACSequenceAdditions.m */; };
+		D05AD40F17F2DB6A0080895B /* NSFileHandle+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 88442C8916090C1500636B49 /* NSFileHandle+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD41017F2DB6A0080895B /* NSFileHandle+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 88442C8A16090C1500636B49 /* NSFileHandle+RACSupport.m */; };
+		D05AD41117F2DB6A0080895B /* NSNotificationCenter+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 88442C8B16090C1500636B49 /* NSNotificationCenter+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD41217F2DB6A0080895B /* NSNotificationCenter+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 88442C8C16090C1500636B49 /* NSNotificationCenter+RACSupport.m */; };
+		D05AD41317F2DB6A0080895B /* NSObject+RACDescription.m in Sources */ = {isa = PBXBuildFile; fileRef = D0D243B61741FA0E004359C6 /* NSObject+RACDescription.m */; };
+		D05AD41417F2DB6A0080895B /* NSObject+RACSelectorSignal.h in Headers */ = {isa = PBXBuildFile; fileRef = 880D7A5816F7B351004A3361 /* NSObject+RACSelectorSignal.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD41517F2DB6A0080895B /* NSObject+RACSelectorSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = 880D7A5916F7B351004A3361 /* NSObject+RACSelectorSignal.m */; };
+		D05AD41617F2DB6A0080895B /* NSOrderedSet+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E9675B1641EF9C00FCFF06 /* NSOrderedSet+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD41717F2DB6A0080895B /* NSOrderedSet+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E9675C1641EF9C00FCFF06 /* NSOrderedSet+RACSequenceAdditions.m */; };
+		D05AD41817F2DB6A0080895B /* NSSet+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E9675D1641EF9C00FCFF06 /* NSSet+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD41917F2DB6A0080895B /* NSSet+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E9675E1641EF9C00FCFF06 /* NSSet+RACSequenceAdditions.m */; };
+		D05AD41A17F2DB6A0080895B /* NSString+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E9675F1641EF9C00FCFF06 /* NSString+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD41B17F2DB6A0080895B /* NSString+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967601641EF9C00FCFF06 /* NSString+RACSequenceAdditions.m */; };
+		D05AD41C17F2DB6A0080895B /* NSString+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 88442C8D16090C1500636B49 /* NSString+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD41D17F2DB6A0080895B /* NSString+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 88442C8E16090C1500636B49 /* NSString+RACSupport.m */; };
+		D05AD41E17F2DB6E0080895B /* NSControl+RACCommandSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 882093E61501E6CB00796685 /* NSControl+RACCommandSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD41F17F2DB6E0080895B /* NSControl+RACCommandSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 882093E71501E6CB00796685 /* NSControl+RACCommandSupport.m */; };
+		D05AD42017F2DB6E0080895B /* NSControl+RACTextSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = D0A0B03916EAA9AC00C47593 /* NSControl+RACTextSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD42117F2DB6E0080895B /* NSControl+RACTextSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = D0A0B03A16EAA9AC00C47593 /* NSControl+RACTextSignalSupport.m */; };
+		D05AD42217F2DB6E0080895B /* NSObject+RACAppKitBindings.h in Headers */ = {isa = PBXBuildFile; fileRef = 88F440D1153DADEA0097B4C3 /* NSObject+RACAppKitBindings.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD42317F2DB6E0080895B /* NSObject+RACAppKitBindings.m in Sources */ = {isa = PBXBuildFile; fileRef = 88F440D2153DADEA0097B4C3 /* NSObject+RACAppKitBindings.m */; };
+		D05AD42417F2DB6E0080895B /* NSText+RACSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = D0A0B01316EAA3D100C47593 /* NSText+RACSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD42517F2DB6E0080895B /* NSText+RACSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = D0A0B01416EAA3D100C47593 /* NSText+RACSignalSupport.m */; };
+		D05AD42617F2DB840080895B /* RACChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 5F6FE8511692568A00A8D7A6 /* RACChannel.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD42717F2DB840080895B /* RACChannel.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F6FE8521692568A00A8D7A6 /* RACChannel.m */; };
+		D05AD42817F2DB840080895B /* RACKVOChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 5F45A883168CFA3E00B58A2B /* RACKVOChannel.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD42917F2DB840080895B /* RACKVOChannel.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F45A884168CFA3E00B58A2B /* RACKVOChannel.m */; };
+		D05AD42B17F2DB840080895B /* NSObject+RACKVOWrapper.m in Sources */ = {isa = PBXBuildFile; fileRef = 88CDF82915008BB900163A9F /* NSObject+RACKVOWrapper.m */; };
+		D05AD42C17F2DB840080895B /* NSString+RACKeyPathUtilities.m in Sources */ = {isa = PBXBuildFile; fileRef = 5FDC35021736F54700792E52 /* NSString+RACKeyPathUtilities.m */; };
+		D05AD42D17F2DB840080895B /* RACKVOTrampoline.m in Sources */ = {isa = PBXBuildFile; fileRef = 8837EA1516A5A33300FC3CDF /* RACKVOTrampoline.m */; };
+		D05AD42E17F2DB840080895B /* NSObject+RACPropertySubscribing.h in Headers */ = {isa = PBXBuildFile; fileRef = 88CDF82C15008C0500163A9F /* NSObject+RACPropertySubscribing.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D05AD42F17F2DB840080895B /* NSObject+RACPropertySubscribing.m in Sources */ = {isa = PBXBuildFile; fileRef = 886678701518DCD800DE77EC /* NSObject+RACPropertySubscribing.m */; };
+		D05AD43017F2DB840080895B /* RACValueTransformer.m in Sources */ = {isa = PBXBuildFile; fileRef = 88DA309615071CBA00C19D0F /* RACValueTransformer.m */; };
+		D05AD43117F2DB950080895B /* RACObjCRuntime.m in Sources */ = {isa = PBXBuildFile; fileRef = A1FCC371156754A7008C9686 /* RACObjCRuntime.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+		D05AD43217F2DBCA0080895B /* RACSignalProvider.d in Sources */ = {isa = PBXBuildFile; fileRef = D03525D317E2EBC90099CBAB /* RACSignalProvider.d */; };
+		D05F9D3717984EC000FD7982 /* EXTRuntimeExtensions.m in Sources */ = {isa = PBXBuildFile; fileRef = D05F9D3417984EC000FD7982 /* EXTRuntimeExtensions.m */; };
+		D05F9D3817984EC000FD7982 /* EXTRuntimeExtensions.m in Sources */ = {isa = PBXBuildFile; fileRef = D05F9D3417984EC000FD7982 /* EXTRuntimeExtensions.m */; };
+		D066C796176D262500C242D2 /* UIControlRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D066C795176D262500C242D2 /* UIControlRACSupportSpec.m */; };
+		D066C79D176D263D00C242D2 /* RACTestUIButton.m in Sources */ = {isa = PBXBuildFile; fileRef = D066C79C176D263D00C242D2 /* RACTestUIButton.m */; };
+		D0700F4C1672994D00D7CD30 /* NSNotificationCenterRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D0700F4B1672994D00D7CD30 /* NSNotificationCenterRACSupportSpec.m */; };
+		D070CBC517FB5E370017F121 /* RACCompoundDisposableProvider.d in Sources */ = {isa = PBXBuildFile; fileRef = D020F3DA17F6A3E40092BED2 /* RACCompoundDisposableProvider.d */; };
+		D07200251788C57200987F70 /* RACTestSchedulerSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D07200241788C57200987F70 /* RACTestSchedulerSpec.m */; };
+		D07200261788C57200987F70 /* RACTestSchedulerSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D07200241788C57200987F70 /* RACTestSchedulerSpec.m */; };
+		D075A72A17BCB7E100C24FB7 /* RACControlCommandExamples.m in Sources */ = {isa = PBXBuildFile; fileRef = D075A72917BCB7E100C24FB7 /* RACControlCommandExamples.m */; };
+		D075A72B17BCB7E100C24FB7 /* RACControlCommandExamples.m in Sources */ = {isa = PBXBuildFile; fileRef = D075A72917BCB7E100C24FB7 /* RACControlCommandExamples.m */; };
+		D077A16D169B740200057BB1 /* RACEvent.h in Headers */ = {isa = PBXBuildFile; fileRef = D077A16B169B740200057BB1 /* RACEvent.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D077A16E169B740200057BB1 /* RACEvent.h in Headers */ = {isa = PBXBuildFile; fileRef = D077A16B169B740200057BB1 /* RACEvent.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D077A16F169B740200057BB1 /* RACEvent.m in Sources */ = {isa = PBXBuildFile; fileRef = D077A16C169B740200057BB1 /* RACEvent.m */; };
+		D077A170169B740200057BB1 /* RACEvent.m in Sources */ = {isa = PBXBuildFile; fileRef = D077A16C169B740200057BB1 /* RACEvent.m */; };
+		D077A172169B79A900057BB1 /* RACEventSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D077A171169B79A900057BB1 /* RACEventSpec.m */; };
+		D07CD7181731BA3900DE2394 /* RACUnarySequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D07CD7151731BA3900DE2394 /* RACUnarySequence.m */; };
+		D07CD7191731BA3900DE2394 /* RACUnarySequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D07CD7151731BA3900DE2394 /* RACUnarySequence.m */; };
+		D0870C6F16884A0600D0E11D /* RACBacktraceSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D0870C6E16884A0600D0E11D /* RACBacktraceSpec.m */; };
+		D08FF264169A32D100743C6D /* ReactiveCocoa.h in Headers */ = {isa = PBXBuildFile; fileRef = 88037F8C15056328001A5B19 /* ReactiveCocoa.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D08FF265169A32DC00743C6D /* RACSubscriber.h in Headers */ = {isa = PBXBuildFile; fileRef = 88CDF7FA150019CA00163A9F /* RACSubscriber.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D08FF267169A330000743C6D /* RACUnit.h in Headers */ = {isa = PBXBuildFile; fileRef = 881B37CA152260BF0079220B /* RACUnit.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D08FF268169A330000743C6D /* RACTuple.h in Headers */ = {isa = PBXBuildFile; fileRef = 88B76F8C153726B00053EAE2 /* RACTuple.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D08FF269169A330000743C6D /* RACBacktrace.h in Headers */ = {isa = PBXBuildFile; fileRef = D02538A115E2D7FB005BACB8 /* RACBacktrace.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D08FF26A169A330000743C6D /* RACSubscriptingAssignmentTrampoline.h in Headers */ = {isa = PBXBuildFile; fileRef = 88FC735316114F9C00F8A774 /* RACSubscriptingAssignmentTrampoline.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D08FF26B169A330000743C6D /* NSObject+RACLifting.h in Headers */ = {isa = PBXBuildFile; fileRef = 886CEAE0163DE942007632D1 /* NSObject+RACLifting.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D08FF26C169A331A00743C6D /* RACStream.h in Headers */ = {isa = PBXBuildFile; fileRef = D0D486FF1642550100DD7605 /* RACStream.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D08FF26D169A331A00743C6D /* RACSignal.h in Headers */ = {isa = PBXBuildFile; fileRef = 88CDF80415001CA800163A9F /* RACSignal.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D08FF26E169A331A00743C6D /* RACSignal+Operations.h in Headers */ = {isa = PBXBuildFile; fileRef = D0D910CC15F915BD00AD2DDA /* RACSignal+Operations.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D08FF26F169A331A00743C6D /* RACMulticastConnection.h in Headers */ = {isa = PBXBuildFile; fileRef = 88C5A0231692460A0045EF05 /* RACMulticastConnection.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D08FF270169A331A00743C6D /* RACGroupedSignal.h in Headers */ = {isa = PBXBuildFile; fileRef = 886F70281551CF920045D68B /* RACGroupedSignal.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D08FF271169A331A00743C6D /* RACSubject.h in Headers */ = {isa = PBXBuildFile; fileRef = 880B9174150B09190008488E /* RACSubject.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D08FF272169A331A00743C6D /* RACReplaySubject.h in Headers */ = {isa = PBXBuildFile; fileRef = 88D4AB3C1510F6C30011494F /* RACReplaySubject.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D08FF273169A331A00743C6D /* RACBehaviorSubject.h in Headers */ = {isa = PBXBuildFile; fileRef = 883A84D81513964B006DB4C7 /* RACBehaviorSubject.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D08FF274169A331A00743C6D /* RACDisposable.h in Headers */ = {isa = PBXBuildFile; fileRef = 883A84DD1513B5EC006DB4C7 /* RACDisposable.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D08FF275169A331A00743C6D /* RACScopedDisposable.h in Headers */ = {isa = PBXBuildFile; fileRef = 884476E2152367D100958F44 /* RACScopedDisposable.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D08FF276169A331A00743C6D /* RACCompoundDisposable.h in Headers */ = {isa = PBXBuildFile; fileRef = 881E86A01669304700667F7B /* RACCompoundDisposable.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D08FF277169A331B00743C6D /* RACCommand.h in Headers */ = {isa = PBXBuildFile; fileRef = 882093E91501E6EE00796685 /* RACCommand.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D08FF278169A331B00743C6D /* RACSequence.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E967671641EF9C00FCFF06 /* RACSequence.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D08FF27F169A331B00743C6D /* RACScheduler.h in Headers */ = {isa = PBXBuildFile; fileRef = 88E2C6B2153C771C00C7493C /* RACScheduler.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D08FF280169A333400743C6D /* NSArray+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E967571641EF9C00FCFF06 /* NSArray+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D08FF281169A333400743C6D /* NSDictionary+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E967591641EF9C00FCFF06 /* NSDictionary+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D08FF282169A333400743C6D /* NSOrderedSet+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E9675B1641EF9C00FCFF06 /* NSOrderedSet+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D08FF283169A333400743C6D /* NSSet+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E9675D1641EF9C00FCFF06 /* NSSet+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D08FF284169A333400743C6D /* NSString+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E9675F1641EF9C00FCFF06 /* NSString+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D08FF285169A333400743C6D /* UIControl+RACSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 88F4425F153DC0450097B4C3 /* UIControl+RACSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D08FF286169A333400743C6D /* UITextField+RACSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 88F44264153DCAC50097B4C3 /* UITextField+RACSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D08FF287169A333400743C6D /* UITextView+RACSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = A1FCC27215666AA3008C9686 /* UITextView+RACSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D08FF289169A333400743C6D /* NSObject+RACPropertySubscribing.h in Headers */ = {isa = PBXBuildFile; fileRef = 88CDF82C15008C0500163A9F /* NSObject+RACPropertySubscribing.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D090767F17FBEADE00EB087A /* NSURLConnection+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = D090767D17FBEADE00EB087A /* NSURLConnection+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D090768017FBEADE00EB087A /* NSURLConnection+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = D090767D17FBEADE00EB087A /* NSURLConnection+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D090768117FBEADE00EB087A /* NSURLConnection+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = D090767D17FBEADE00EB087A /* NSURLConnection+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D090768217FBEADE00EB087A /* NSURLConnection+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = D090767E17FBEADE00EB087A /* NSURLConnection+RACSupport.m */; };
+		D090768317FBEADE00EB087A /* NSURLConnection+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = D090767E17FBEADE00EB087A /* NSURLConnection+RACSupport.m */; };
+		D090768417FBEADE00EB087A /* NSURLConnection+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = D090767E17FBEADE00EB087A /* NSURLConnection+RACSupport.m */; };
+		D090768A17FBECBF00EB087A /* NSURLConnectionRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D090768917FBECBF00EB087A /* NSURLConnectionRACSupportSpec.m */; };
+		D090768B17FBECBF00EB087A /* NSURLConnectionRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D090768917FBECBF00EB087A /* NSURLConnectionRACSupportSpec.m */; };
+		D090768D17FBED2E00EB087A /* test-data.json in Resources */ = {isa = PBXBuildFile; fileRef = D090768C17FBED2E00EB087A /* test-data.json */; };
+		D090768E17FBED2E00EB087A /* test-data.json in Resources */ = {isa = PBXBuildFile; fileRef = D090768C17FBED2E00EB087A /* test-data.json */; };
+		D094E44917775AF200906BF7 /* EXTKeyPathCoding.h in Headers */ = {isa = PBXBuildFile; fileRef = D094E44517775AF200906BF7 /* EXTKeyPathCoding.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D094E44A17775AF200906BF7 /* EXTKeyPathCoding.h in Headers */ = {isa = PBXBuildFile; fileRef = D094E44517775AF200906BF7 /* EXTKeyPathCoding.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D094E44B17775AF200906BF7 /* EXTScope.h in Headers */ = {isa = PBXBuildFile; fileRef = D094E44617775AF200906BF7 /* EXTScope.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D094E44C17775AF200906BF7 /* EXTScope.h in Headers */ = {isa = PBXBuildFile; fileRef = D094E44617775AF200906BF7 /* EXTScope.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D094E44F17775AF200906BF7 /* metamacros.h in Headers */ = {isa = PBXBuildFile; fileRef = D094E44817775AF200906BF7 /* metamacros.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D094E45017775AF200906BF7 /* metamacros.h in Headers */ = {isa = PBXBuildFile; fileRef = D094E44817775AF200906BF7 /* metamacros.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D0A0B01516EAA3D100C47593 /* NSText+RACSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = D0A0B01316EAA3D100C47593 /* NSText+RACSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D0A0B01616EAA3D100C47593 /* NSText+RACSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = D0A0B01416EAA3D100C47593 /* NSText+RACSignalSupport.m */; };
+		D0A0B01816EAA5CC00C47593 /* NSTextRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D0A0B01716EAA5CC00C47593 /* NSTextRACSupportSpec.m */; };
+		D0A0B03B16EAA9AC00C47593 /* NSControl+RACTextSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = D0A0B03916EAA9AC00C47593 /* NSControl+RACTextSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D0A0B03C16EAA9AC00C47593 /* NSControl+RACTextSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = D0A0B03A16EAA9AC00C47593 /* NSControl+RACTextSignalSupport.m */; };
+		D0A0E226176A84DB007273ED /* RACDisposableSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D0A0E225176A84DA007273ED /* RACDisposableSpec.m */; };
+		D0A0E227176A84DB007273ED /* RACDisposableSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D0A0E225176A84DA007273ED /* RACDisposableSpec.m */; };
+		D0A0E230176A8CD6007273ED /* RACPassthroughSubscriber.m in Sources */ = {isa = PBXBuildFile; fileRef = D0A0E22D176A8CD6007273ED /* RACPassthroughSubscriber.m */; };
+		D0A0E231176A8CD6007273ED /* RACPassthroughSubscriber.m in Sources */ = {isa = PBXBuildFile; fileRef = D0A0E22D176A8CD6007273ED /* RACPassthroughSubscriber.m */; };
+		D0C55CE217759559008CDDCA /* RACDelegateProxySpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D0C55CE117759559008CDDCA /* RACDelegateProxySpec.m */; };
+		D0C70EC616659333005AAD03 /* RACSubscriberExamples.m in Sources */ = {isa = PBXBuildFile; fileRef = D0C70EC516659333005AAD03 /* RACSubscriberExamples.m */; };
+		D0C70EC8166595AD005AAD03 /* RACSubscriberSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D0C70EC7166595AD005AAD03 /* RACSubscriberSpec.m */; };
+		D0C70F90164337A2007027B4 /* RACSequenceAdditionsSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D0C70F8F164337A2007027B4 /* RACSequenceAdditionsSpec.m */; };
+		D0C70F93164337E3007027B4 /* RACSequenceExamples.m in Sources */ = {isa = PBXBuildFile; fileRef = D0C70F92164337E3007027B4 /* RACSequenceExamples.m */; };
+		D0D243BD1741FA13004359C6 /* NSObject+RACDescription.m in Sources */ = {isa = PBXBuildFile; fileRef = D0D243B61741FA0E004359C6 /* NSObject+RACDescription.m */; };
+		D0D243BE1741FA13004359C6 /* NSObject+RACDescription.m in Sources */ = {isa = PBXBuildFile; fileRef = D0D243B61741FA0E004359C6 /* NSObject+RACDescription.m */; };
+		D0D487011642550100DD7605 /* RACStream.h in Headers */ = {isa = PBXBuildFile; fileRef = D0D486FF1642550100DD7605 /* RACStream.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D0D487031642550100DD7605 /* RACStream.m in Sources */ = {isa = PBXBuildFile; fileRef = D0D487001642550100DD7605 /* RACStream.m */; };
+		D0D487041642550100DD7605 /* RACStream.m in Sources */ = {isa = PBXBuildFile; fileRef = D0D487001642550100DD7605 /* RACStream.m */; };
+		D0D487061642651400DD7605 /* RACSequenceSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D0D487051642651400DD7605 /* RACSequenceSpec.m */; };
+		D0D910CE15F915BD00AD2DDA /* RACSignal+Operations.h in Headers */ = {isa = PBXBuildFile; fileRef = D0D910CC15F915BD00AD2DDA /* RACSignal+Operations.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D0D910D015F915BD00AD2DDA /* RACSignal+Operations.m in Sources */ = {isa = PBXBuildFile; fileRef = D0D910CD15F915BD00AD2DDA /* RACSignal+Operations.m */; };
+		D0D910D115F915BD00AD2DDA /* RACSignal+Operations.m in Sources */ = {isa = PBXBuildFile; fileRef = D0D910CD15F915BD00AD2DDA /* RACSignal+Operations.m */; };
+		D0DFBCCE15DD6D40009DADB3 /* RACBacktrace.m in Sources */ = {isa = PBXBuildFile; fileRef = D0DFBCCD15DD6D40009DADB3 /* RACBacktrace.m */; };
+		D0DFBCCF15DD6D40009DADB3 /* RACBacktrace.m in Sources */ = {isa = PBXBuildFile; fileRef = D0DFBCCD15DD6D40009DADB3 /* RACBacktrace.m */; };
+		D0DFBCD015DD70CC009DADB3 /* ReactiveCocoa.framework in Copy Frameworks */ = {isa = PBXBuildFile; fileRef = 88037F8315056328001A5B19 /* ReactiveCocoa.framework */; };
+		D0E9676B1641EF9C00FCFF06 /* NSArray+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E967571641EF9C00FCFF06 /* NSArray+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D0E9676D1641EF9C00FCFF06 /* NSArray+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967581641EF9C00FCFF06 /* NSArray+RACSequenceAdditions.m */; };
+		D0E9676E1641EF9C00FCFF06 /* NSArray+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967581641EF9C00FCFF06 /* NSArray+RACSequenceAdditions.m */; };
+		D0E9676F1641EF9C00FCFF06 /* NSDictionary+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E967591641EF9C00FCFF06 /* NSDictionary+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D0E967711641EF9C00FCFF06 /* NSDictionary+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E9675A1641EF9C00FCFF06 /* NSDictionary+RACSequenceAdditions.m */; };
+		D0E967721641EF9C00FCFF06 /* NSDictionary+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E9675A1641EF9C00FCFF06 /* NSDictionary+RACSequenceAdditions.m */; };
+		D0E967731641EF9C00FCFF06 /* NSOrderedSet+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E9675B1641EF9C00FCFF06 /* NSOrderedSet+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D0E967751641EF9C00FCFF06 /* NSOrderedSet+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E9675C1641EF9C00FCFF06 /* NSOrderedSet+RACSequenceAdditions.m */; };
+		D0E967761641EF9C00FCFF06 /* NSOrderedSet+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E9675C1641EF9C00FCFF06 /* NSOrderedSet+RACSequenceAdditions.m */; };
+		D0E967771641EF9C00FCFF06 /* NSSet+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E9675D1641EF9C00FCFF06 /* NSSet+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D0E967791641EF9C00FCFF06 /* NSSet+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E9675E1641EF9C00FCFF06 /* NSSet+RACSequenceAdditions.m */; };
+		D0E9677A1641EF9C00FCFF06 /* NSSet+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E9675E1641EF9C00FCFF06 /* NSSet+RACSequenceAdditions.m */; };
+		D0E9677B1641EF9C00FCFF06 /* NSString+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E9675F1641EF9C00FCFF06 /* NSString+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D0E9677D1641EF9C00FCFF06 /* NSString+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967601641EF9C00FCFF06 /* NSString+RACSequenceAdditions.m */; };
+		D0E9677E1641EF9C00FCFF06 /* NSString+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967601641EF9C00FCFF06 /* NSString+RACSequenceAdditions.m */; };
+		D0E967811641EF9C00FCFF06 /* RACArraySequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967621641EF9C00FCFF06 /* RACArraySequence.m */; };
+		D0E967821641EF9C00FCFF06 /* RACArraySequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967621641EF9C00FCFF06 /* RACArraySequence.m */; };
+		D0E967851641EF9C00FCFF06 /* RACDynamicSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967641641EF9C00FCFF06 /* RACDynamicSequence.m */; };
+		D0E967861641EF9C00FCFF06 /* RACDynamicSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967641641EF9C00FCFF06 /* RACDynamicSequence.m */; };
+		D0E967891641EF9C00FCFF06 /* RACEmptySequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967661641EF9C00FCFF06 /* RACEmptySequence.m */; };
+		D0E9678A1641EF9C00FCFF06 /* RACEmptySequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967661641EF9C00FCFF06 /* RACEmptySequence.m */; };
+		D0E9678B1641EF9C00FCFF06 /* RACSequence.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E967671641EF9C00FCFF06 /* RACSequence.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		D0E9678D1641EF9C00FCFF06 /* RACSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967681641EF9C00FCFF06 /* RACSequence.m */; };
+		D0E9678E1641EF9C00FCFF06 /* RACSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967681641EF9C00FCFF06 /* RACSequence.m */; };
+		D0E967911641EF9C00FCFF06 /* RACStringSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E9676A1641EF9C00FCFF06 /* RACStringSequence.m */; };
+		D0E967921641EF9C00FCFF06 /* RACStringSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E9676A1641EF9C00FCFF06 /* RACStringSequence.m */; };
+		D0EDE76716968AB10072A780 /* RACPropertySignalExamples.m in Sources */ = {isa = PBXBuildFile; fileRef = D0EDE76616968AB10072A780 /* RACPropertySignalExamples.m */; };
+		D0EE284D164D906B006954A4 /* RACSignalSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0EE284A164D906B006954A4 /* RACSignalSequence.m */; };
+		D0EE284E164D906B006954A4 /* RACSignalSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0EE284A164D906B006954A4 /* RACSignalSequence.m */; };
+		D0F117C8179F0A95006CE68F /* libReactiveCocoa-iOS.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 88F440AB153DAC820097B4C3 /* libReactiveCocoa-iOS.a */; };
+		D0F117CC179F0B97006CE68F /* UITableViewCellRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D0F117CB179F0B97006CE68F /* UITableViewCellRACSupportSpec.m */; };
+		D40D7AAB18E22B5E0065BB70 /* libExpecta.a in Frameworks */ = {isa = PBXBuildFile; fileRef = D40D7AAA18E22B5E0065BB70 /* libExpecta.a */; };
+		D40D7AAD18E22B7E0065BB70 /* libSpecta.a in Frameworks */ = {isa = PBXBuildFile; fileRef = D40D7AAC18E22B7E0065BB70 /* libSpecta.a */; };
+		D40D7AAF18E22BE30065BB70 /* libExpecta-iOS.a in Frameworks */ = {isa = PBXBuildFile; fileRef = D40D7AAE18E22BE30065BB70 /* libExpecta-iOS.a */; };
+		D40D7AB118E22BF60065BB70 /* libSpecta-iOS.a in Frameworks */ = {isa = PBXBuildFile; fileRef = D40D7AB018E22BF60065BB70 /* libSpecta-iOS.a */; };
+		D40D7AB218E22EC60065BB70 /* libSpecta-iOS.a in Frameworks */ = {isa = PBXBuildFile; fileRef = D40D7AB018E22BF60065BB70 /* libSpecta-iOS.a */; };
+		D40D7AB318E22EC90065BB70 /* libExpecta-iOS.a in Frameworks */ = {isa = PBXBuildFile; fileRef = D40D7AAE18E22BE30065BB70 /* libExpecta-iOS.a */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXContainerItemProxy section */
+		1860F435177C91B500C7B3C9 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 88CDF7B215000FCE00163A9F /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 1860F411177C91B500C7B3C9;
+			remoteInfo = "ReactiveCocoa-iOS-UIKitTestHost";
+		};
+		88037FDA150564E9001A5B19 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 88CDF7B215000FCE00163A9F /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 88037F8215056328001A5B19;
+			remoteInfo = ReactiveCocoa;
+		};
+		D0ED9DB517501806003859A6 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 88CDF7B215000FCE00163A9F /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 88F440AA153DAC820097B4C3;
+			remoteInfo = "ReactiveCocoa-iOS";
+		};
+		D0F117C2179F0A91006CE68F /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 88CDF7B215000FCE00163A9F /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 88F440AA153DAC820097B4C3;
+			remoteInfo = "ReactiveCocoa-iOS";
+		};
+/* End PBXContainerItemProxy section */
+
+/* Begin PBXCopyFilesBuildPhase section */
+		8820937F1501C94E00796685 /* Copy Frameworks */ = {
+			isa = PBXCopyFilesBuildPhase;
+			buildActionMask = 2147483647;
+			dstPath = "";
+			dstSubfolderSpec = 10;
+			files = (
+				D0DFBCD015DD70CC009DADB3 /* ReactiveCocoa.framework in Copy Frameworks */,
+			);
+			name = "Copy Frameworks";
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXCopyFilesBuildPhase section */
+
+/* Begin PBXFileReference section */
+		1668027817FE75E900C724B4 /* UICollectionReusableView+RACSignalSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UICollectionReusableView+RACSignalSupport.h"; sourceTree = "<group>"; };
+		1668027917FE75E900C724B4 /* UICollectionReusableView+RACSignalSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UICollectionReusableView+RACSignalSupport.m"; sourceTree = "<group>"; };
+		1668028117FE774800C724B4 /* UICollectionReusableViewRACSupportSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = UICollectionReusableViewRACSupportSpec.m; sourceTree = "<group>"; };
+		1860F412177C91B500C7B3C9 /* ReactiveCocoa-iOS-UIKitTestHost.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = "ReactiveCocoa-iOS-UIKitTestHost.app"; sourceTree = BUILT_PRODUCTS_DIR; };
+		1860F413177C91B500C7B3C9 /* UIKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = UIKit.framework; path = Library/Frameworks/UIKit.framework; sourceTree = DEVELOPER_DIR; };
+		1860F415177C91B500C7B3C9 /* Foundation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Foundation.framework; path = Library/Frameworks/Foundation.framework; sourceTree = DEVELOPER_DIR; };
+		1860F417177C91B500C7B3C9 /* CoreGraphics.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreGraphics.framework; path = Library/Frameworks/CoreGraphics.framework; sourceTree = DEVELOPER_DIR; };
+		1860F41B177C91B500C7B3C9 /* ReactiveCocoa-iOS-UIKitTestHost-Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = "ReactiveCocoa-iOS-UIKitTestHost-Info.plist"; sourceTree = "<group>"; };
+		1860F41D177C91B500C7B3C9 /* en */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = en; path = en.lproj/InfoPlist.strings; sourceTree = "<group>"; };
+		1860F41F177C91B500C7B3C9 /* main.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = main.m; sourceTree = "<group>"; };
+		1860F421177C91B500C7B3C9 /* ReactiveCocoa-iOS-UIKitTestHost-Prefix.pch */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "ReactiveCocoa-iOS-UIKitTestHost-Prefix.pch"; sourceTree = "<group>"; };
+		1860F422177C91B500C7B3C9 /* RACAppDelegate.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RACAppDelegate.h; sourceTree = "<group>"; };
+		1860F423177C91B500C7B3C9 /* RACAppDelegate.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RACAppDelegate.m; sourceTree = "<group>"; };
+		1860F425177C91B500C7B3C9 /* Default.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = Default.png; sourceTree = "<group>"; };
+		1860F427177C91B500C7B3C9 /* Default@2x.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = "Default@2x.png"; sourceTree = "<group>"; };
+		1860F429177C91B500C7B3C9 /* Default-568h@2x.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = "Default-568h@2x.png"; sourceTree = "<group>"; };
+		1860F430177C91B500C7B3C9 /* ReactiveCocoa-iOS-UIKitTestHostTests.octest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = "ReactiveCocoa-iOS-UIKitTestHostTests.octest"; sourceTree = BUILT_PRODUCTS_DIR; };
+		1860F431177C91B500C7B3C9 /* SenTestingKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = SenTestingKit.framework; path = Library/Frameworks/SenTestingKit.framework; sourceTree = DEVELOPER_DIR; };
+		1860F43B177C91B500C7B3C9 /* en */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = en; path = en.lproj/InfoPlist.strings; sourceTree = "<group>"; };
+		1860F455177C96B200C7B3C9 /* ReactiveCocoa-iOS-UIKitTestHostTests-Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; name = "ReactiveCocoa-iOS-UIKitTestHostTests-Info.plist"; path = "ReactiveCocoaTests/UIKit/UIKitTests/ReactiveCocoa-iOS-UIKitTestHostTests-Info.plist"; sourceTree = SOURCE_ROOT; };
+		1860F457177C972E00C7B3C9 /* ReactiveCocoa-iOS-UIKitTest-Prefix.pch */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = "ReactiveCocoa-iOS-UIKitTest-Prefix.pch"; path = "ReactiveCocoaTests/UIKit/UIKitTests/ReactiveCocoa-iOS-UIKitTest-Prefix.pch"; sourceTree = SOURCE_ROOT; };
+		1E89337F171647A5009071B0 /* NSObjectRACPropertySubscribingExamples.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NSObjectRACPropertySubscribingExamples.h; sourceTree = "<group>"; };
+		1E893380171647A5009071B0 /* NSObjectRACPropertySubscribingExamples.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = NSObjectRACPropertySubscribingExamples.m; sourceTree = "<group>"; };
+		1EC06B15173CB04000365258 /* UIGestureRecognizer+RACSignalSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UIGestureRecognizer+RACSignalSupport.h"; sourceTree = "<group>"; };
+		1EC06B16173CB04000365258 /* UIGestureRecognizer+RACSignalSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UIGestureRecognizer+RACSignalSupport.m"; sourceTree = "<group>"; };
+		27A887C71703DB4F00040001 /* UIBarButtonItem+RACCommandSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UIBarButtonItem+RACCommandSupport.h"; sourceTree = "<group>"; };
+		27A887C81703DB4F00040001 /* UIBarButtonItem+RACCommandSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UIBarButtonItem+RACCommandSupport.m"; sourceTree = "<group>"; };
+		4925E805181BCC71000B2FEE /* NSControllerRACSupportSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = NSControllerRACSupportSpec.m; sourceTree = "<group>"; };
+		554D9E5B181064E200F21262 /* UIRefreshControl+RACCommandSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UIRefreshControl+RACCommandSupport.h"; sourceTree = "<group>"; };
+		554D9E5C181064E200F21262 /* UIRefreshControl+RACCommandSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UIRefreshControl+RACCommandSupport.m"; sourceTree = "<group>"; };
+		5564542318107275002BD2E4 /* UIRefreshControlRACSupportSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = UIRefreshControlRACSupportSpec.m; sourceTree = "<group>"; };
+		557A4B58177648C7008EF796 /* UIActionSheet+RACSignalSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UIActionSheet+RACSignalSupport.h"; sourceTree = "<group>"; };
+		557A4B59177648C7008EF796 /* UIActionSheet+RACSignalSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UIActionSheet+RACSignalSupport.m"; sourceTree = "<group>"; };
+		5EE9A7911760D61300EAF5A2 /* UIButton+RACCommandSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UIButton+RACCommandSupport.h"; sourceTree = "<group>"; };
+		5EE9A7921760D61300EAF5A2 /* UIButton+RACCommandSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UIButton+RACCommandSupport.m"; sourceTree = "<group>"; };
+		5EE9A79A1760D88500EAF5A2 /* UIButtonRACSupportSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = UIButtonRACSupportSpec.m; sourceTree = "<group>"; };
+		5F016DF217B10AA8002EEC69 /* UIControl+RACSignalSupportPrivate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UIControl+RACSignalSupportPrivate.h"; sourceTree = "<group>"; };
+		5F016DF317B10AA8002EEC69 /* UIControl+RACSignalSupportPrivate.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UIControl+RACSignalSupportPrivate.m"; sourceTree = "<group>"; };
+		5F2447AC167E87C50062180C /* RACKVOChannelSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACKVOChannelSpec.m; sourceTree = "<group>"; };
+		5F45A883168CFA3E00B58A2B /* RACKVOChannel.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACKVOChannel.h; sourceTree = "<group>"; };
+		5F45A884168CFA3E00B58A2B /* RACKVOChannel.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACKVOChannel.m; sourceTree = "<group>"; };
+		5F6FE8511692568A00A8D7A6 /* RACChannel.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACChannel.h; sourceTree = "<group>"; };
+		5F6FE8521692568A00A8D7A6 /* RACChannel.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACChannel.m; sourceTree = "<group>"; };
+		5F70B2AD17AB1829009AEDF9 /* UIDatePicker+RACSignalSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UIDatePicker+RACSignalSupport.h"; sourceTree = "<group>"; };
+		5F70B2AE17AB1829009AEDF9 /* UIDatePicker+RACSignalSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UIDatePicker+RACSignalSupport.m"; sourceTree = "<group>"; };
+		5F70B2B617AB1856009AEDF9 /* UISegmentedControl+RACSignalSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UISegmentedControl+RACSignalSupport.h"; sourceTree = "<group>"; };
+		5F70B2B717AB1856009AEDF9 /* UISegmentedControl+RACSignalSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UISegmentedControl+RACSignalSupport.m"; sourceTree = "<group>"; };
+		5F70B2B817AB1856009AEDF9 /* UISlider+RACSignalSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UISlider+RACSignalSupport.h"; sourceTree = "<group>"; };
+		5F70B2B917AB1856009AEDF9 /* UISlider+RACSignalSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UISlider+RACSignalSupport.m"; sourceTree = "<group>"; };
+		5F70B2BA17AB1857009AEDF9 /* UIStepper+RACSignalSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UIStepper+RACSignalSupport.h"; sourceTree = "<group>"; };
+		5F70B2BB17AB1857009AEDF9 /* UIStepper+RACSignalSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UIStepper+RACSignalSupport.m"; sourceTree = "<group>"; };
+		5F70B2BC17AB1857009AEDF9 /* UISwitch+RACSignalSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UISwitch+RACSignalSupport.h"; sourceTree = "<group>"; };
+		5F70B2BD17AB1857009AEDF9 /* UISwitch+RACSignalSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UISwitch+RACSignalSupport.m"; sourceTree = "<group>"; };
+		5F773DE8169B46670023069D /* NSEnumerator+RACSequenceAdditions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSEnumerator+RACSequenceAdditions.h"; sourceTree = "<group>"; };
+		5F773DE9169B46670023069D /* NSEnumerator+RACSequenceAdditions.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSEnumerator+RACSequenceAdditions.m"; sourceTree = "<group>"; };
+		5F773DEF169B48830023069D /* NSEnumeratorRACSequenceAdditionsSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = NSEnumeratorRACSequenceAdditionsSpec.m; sourceTree = "<group>"; };
+		5F7EFECC168FBC4B0037E500 /* RACChannelExamples.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACChannelExamples.h; sourceTree = "<group>"; };
+		5F7EFECD168FBC4B0037E500 /* RACChannelExamples.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACChannelExamples.m; sourceTree = "<group>"; };
+		5F7EFECE168FBC4B0037E500 /* RACChannelSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACChannelSpec.m; sourceTree = "<group>"; };
+		5F9743F51694A2460024EB82 /* RACEagerSequence.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACEagerSequence.h; sourceTree = "<group>"; };
+		5F9743F61694A2460024EB82 /* RACEagerSequence.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACEagerSequence.m; sourceTree = "<group>"; };
+		5FAF5223174D4C2000CAC810 /* ReactiveCocoaTests-iOS.octest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = "ReactiveCocoaTests-iOS.octest"; sourceTree = BUILT_PRODUCTS_DIR; };
+		5FAF5261174D4D8E00CAC810 /* UIBarButtonItemRACSupportSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = UIBarButtonItemRACSupportSpec.m; sourceTree = "<group>"; };
+		5FAF5288174E9CD200CAC810 /* CoreGraphics.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreGraphics.framework; path = Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS6.1.sdk/System/Library/Frameworks/CoreGraphics.framework; sourceTree = DEVELOPER_DIR; };
+		5FD7DC7B174F9EEB008710B4 /* UIKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = UIKit.framework; path = System/Library/Frameworks/UIKit.framework; sourceTree = SDKROOT; };
+		5FDC35011736F54600792E52 /* NSString+RACKeyPathUtilities.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSString+RACKeyPathUtilities.h"; sourceTree = "<group>"; };
+		5FDC35021736F54700792E52 /* NSString+RACKeyPathUtilities.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSString+RACKeyPathUtilities.m"; sourceTree = "<group>"; };
+		5FDC350E1736F81800792E52 /* NSStringRACKeyPathUtilitiesSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = NSStringRACKeyPathUtilitiesSpec.m; sourceTree = "<group>"; };
+		6E58405316F22D7500F588A6 /* NSObject+RACDeallocating.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSObject+RACDeallocating.h"; sourceTree = "<group>"; };
+		6E58405416F22D7500F588A6 /* NSObject+RACDeallocating.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSObject+RACDeallocating.m"; sourceTree = "<group>"; };
+		6E58405E16F3414200F588A6 /* NSObjectRACDeallocatingSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = NSObjectRACDeallocatingSpec.m; sourceTree = "<group>"; };
+		7479F6E3186177D200575CDB /* RACIndexSetSequence.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACIndexSetSequence.h; sourceTree = "<group>"; };
+		7479F6E4186177D200575CDB /* RACIndexSetSequence.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACIndexSetSequence.m; sourceTree = "<group>"; };
+		74F17316186024A900BC937C /* NSIndexSet+RACSequenceAdditions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSIndexSet+RACSequenceAdditions.h"; sourceTree = "<group>"; };
+		74F17317186024A900BC937C /* NSIndexSet+RACSequenceAdditions.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSIndexSet+RACSequenceAdditions.m"; sourceTree = "<group>"; };
+		8801E7501644BDE200A155FE /* NSObjectRACLiftingSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = NSObjectRACLiftingSpec.m; sourceTree = "<group>"; };
+		88037F8315056328001A5B19 /* ReactiveCocoa.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = ReactiveCocoa.framework; sourceTree = BUILT_PRODUCTS_DIR; };
+		88037F8C15056328001A5B19 /* ReactiveCocoa.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ReactiveCocoa.h; sourceTree = "<group>"; };
+		8803C010166732BA00C36839 /* RACSchedulerSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSchedulerSpec.m; sourceTree = "<group>"; };
+		880B9174150B09190008488E /* RACSubject.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACSubject.h; sourceTree = "<group>"; };
+		880B9175150B09190008488E /* RACSubject.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSubject.m; sourceTree = "<group>"; };
+		880D7A5816F7B351004A3361 /* NSObject+RACSelectorSignal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSObject+RACSelectorSignal.h"; sourceTree = "<group>"; };
+		880D7A5916F7B351004A3361 /* NSObject+RACSelectorSignal.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSObject+RACSelectorSignal.m"; sourceTree = "<group>"; };
+		880D7A6516F7BB1A004A3361 /* NSObjectRACSelectorSignalSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = NSObjectRACSelectorSignalSpec.m; sourceTree = "<group>"; };
+		880D7A6716F7BCC7004A3361 /* RACSubclassObject.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACSubclassObject.h; sourceTree = "<group>"; };
+		880D7A6816F7BCC7004A3361 /* RACSubclassObject.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSubclassObject.m; sourceTree = "<group>"; };
+		881B37CA152260BF0079220B /* RACUnit.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACUnit.h; sourceTree = "<group>"; };
+		881B37CB152260BF0079220B /* RACUnit.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACUnit.m; sourceTree = "<group>"; };
+		881E86A01669304700667F7B /* RACCompoundDisposable.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACCompoundDisposable.h; sourceTree = "<group>"; };
+		881E86A11669304700667F7B /* RACCompoundDisposable.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACCompoundDisposable.m; sourceTree = "<group>"; };
+		881E86B91669350B00667F7B /* RACCompoundDisposableSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACCompoundDisposableSpec.m; sourceTree = "<group>"; };
+		881E87AA16695C5600667F7B /* RACQueueScheduler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACQueueScheduler.h; sourceTree = "<group>"; };
+		881E87AB16695C5600667F7B /* RACQueueScheduler.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACQueueScheduler.m; sourceTree = "<group>"; };
+		881E87B016695EDF00667F7B /* RACImmediateScheduler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACImmediateScheduler.h; sourceTree = "<group>"; };
+		881E87B116695EDF00667F7B /* RACImmediateScheduler.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACImmediateScheduler.m; sourceTree = "<group>"; };
+		881E87C21669635F00667F7B /* RACSubscriptionScheduler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACSubscriptionScheduler.h; sourceTree = "<group>"; };
+		881E87C31669636000667F7B /* RACSubscriptionScheduler.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSubscriptionScheduler.m; sourceTree = "<group>"; };
+		8820937B1501C8A600796685 /* RACSignalSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSignalSpec.m; sourceTree = "<group>"; };
+		882093E61501E6CB00796685 /* NSControl+RACCommandSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSControl+RACCommandSupport.h"; sourceTree = "<group>"; };
+		882093E71501E6CB00796685 /* NSControl+RACCommandSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSControl+RACCommandSupport.m"; sourceTree = "<group>"; };
+		882093E91501E6EE00796685 /* RACCommand.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = RACCommand.h; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; };
+		882093EA1501E6EE00796685 /* RACCommand.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; lineEnding = 0; path = RACCommand.m; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.objc; };
+		882CCA1D15F1564D00937D6E /* RACCommandSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACCommandSpec.m; sourceTree = "<group>"; };
+		882D071717614FA7009EDA69 /* RACTargetQueueScheduler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACTargetQueueScheduler.h; sourceTree = "<group>"; };
+		882D071817614FA7009EDA69 /* RACTargetQueueScheduler.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACTargetQueueScheduler.m; sourceTree = "<group>"; };
+		882D07201761521B009EDA69 /* RACQueueScheduler+Subclass.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "RACQueueScheduler+Subclass.h"; sourceTree = "<group>"; };
+		88302BFB1762A9E6003633BD /* RACTestExampleScheduler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACTestExampleScheduler.h; sourceTree = "<group>"; };
+		88302BFC1762A9E6003633BD /* RACTestExampleScheduler.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACTestExampleScheduler.m; sourceTree = "<group>"; };
+		88302C2D1762C180003633BD /* RACTargetQueueSchedulerSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACTargetQueueSchedulerSpec.m; sourceTree = "<group>"; };
+		8837EA1416A5A33300FC3CDF /* RACKVOTrampoline.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACKVOTrampoline.h; sourceTree = "<group>"; };
+		8837EA1516A5A33300FC3CDF /* RACKVOTrampoline.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACKVOTrampoline.m; sourceTree = "<group>"; };
+		883A84D81513964B006DB4C7 /* RACBehaviorSubject.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACBehaviorSubject.h; sourceTree = "<group>"; };
+		883A84D91513964B006DB4C7 /* RACBehaviorSubject.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; lineEnding = 0; path = RACBehaviorSubject.m; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.objc; };
+		883A84DD1513B5EC006DB4C7 /* RACDisposable.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACDisposable.h; sourceTree = "<group>"; };
+		883A84DE1513B5EC006DB4C7 /* RACDisposable.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACDisposable.m; sourceTree = "<group>"; };
+		88442A321608A9AD00636B49 /* RACTestObject.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACTestObject.h; sourceTree = "<group>"; };
+		88442A331608A9AD00636B49 /* RACTestObject.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACTestObject.m; sourceTree = "<group>"; };
+		88442C8716090C1500636B49 /* NSData+RACSupport.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "NSData+RACSupport.h"; sourceTree = "<group>"; };
+		88442C8816090C1500636B49 /* NSData+RACSupport.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = "NSData+RACSupport.m"; sourceTree = "<group>"; };
+		88442C8916090C1500636B49 /* NSFileHandle+RACSupport.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "NSFileHandle+RACSupport.h"; sourceTree = "<group>"; };
+		88442C8A16090C1500636B49 /* NSFileHandle+RACSupport.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = "NSFileHandle+RACSupport.m"; sourceTree = "<group>"; };
+		88442C8B16090C1500636B49 /* NSNotificationCenter+RACSupport.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "NSNotificationCenter+RACSupport.h"; sourceTree = "<group>"; };
+		88442C8C16090C1500636B49 /* NSNotificationCenter+RACSupport.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = "NSNotificationCenter+RACSupport.m"; sourceTree = "<group>"; };
+		88442C8D16090C1500636B49 /* NSString+RACSupport.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "NSString+RACSupport.h"; sourceTree = "<group>"; };
+		88442C8E16090C1500636B49 /* NSString+RACSupport.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = "NSString+RACSupport.m"; sourceTree = "<group>"; };
+		884476E2152367D100958F44 /* RACScopedDisposable.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACScopedDisposable.h; sourceTree = "<group>"; };
+		884476E3152367D100958F44 /* RACScopedDisposable.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACScopedDisposable.m; sourceTree = "<group>"; };
+		884848B515F658B800B11BD0 /* NSControlRACSupportSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = NSControlRACSupportSpec.m; sourceTree = "<group>"; };
+		8851A38A16161D500050D47F /* NSObjectRACPropertySubscribingSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = NSObjectRACPropertySubscribingSpec.m; sourceTree = "<group>"; };
+		8857BB81152A27A9009804CC /* NSObject+RACKVOWrapper.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSObject+RACKVOWrapper.h"; sourceTree = "<group>"; };
+		886678701518DCD800DE77EC /* NSObject+RACPropertySubscribing.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSObject+RACPropertySubscribing.m"; sourceTree = "<group>"; };
+		886CEACC163DE669007632D1 /* RACBlockTrampolineSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACBlockTrampolineSpec.m; sourceTree = "<group>"; };
+		886CEAE0163DE942007632D1 /* NSObject+RACLifting.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSObject+RACLifting.h"; sourceTree = "<group>"; };
+		886CEAE1163DE942007632D1 /* NSObject+RACLifting.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSObject+RACLifting.m"; sourceTree = "<group>"; };
+		886D98581667C86D00F22541 /* RACScheduler+Private.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "RACScheduler+Private.h"; sourceTree = "<group>"; };
+		886F70281551CF920045D68B /* RACGroupedSignal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = RACGroupedSignal.h; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; };
+		886F70291551CF920045D68B /* RACGroupedSignal.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACGroupedSignal.m; sourceTree = "<group>"; };
+		887ACDA5165878A7009190AD /* NSInvocation+RACTypeParsing.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSInvocation+RACTypeParsing.h"; sourceTree = "<group>"; };
+		887ACDA6165878A7009190AD /* NSInvocation+RACTypeParsing.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSInvocation+RACTypeParsing.m"; sourceTree = "<group>"; };
+		888439A11634E10D00DED0DB /* RACBlockTrampoline.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACBlockTrampoline.h; sourceTree = "<group>"; };
+		888439A21634E10D00DED0DB /* RACBlockTrampoline.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACBlockTrampoline.m; sourceTree = "<group>"; };
+		8884DD641756ACF600F6C379 /* RACSignalStartExamples.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSignalStartExamples.m; sourceTree = "<group>"; };
+		8884DD6A1756AD3600F6C379 /* RACSignalStartExamples.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RACSignalStartExamples.h; sourceTree = "<group>"; };
+		88977C3D1512914A00A09EC5 /* RACSignal.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSignal.m; sourceTree = "<group>"; };
+		889D0A7F15974B2A00F833E3 /* RACSubjectSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSubjectSpec.m; sourceTree = "<group>"; };
+		88B76F8C153726B00053EAE2 /* RACTuple.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACTuple.h; sourceTree = "<group>"; };
+		88B76F8D153726B00053EAE2 /* RACTuple.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACTuple.m; sourceTree = "<group>"; };
+		88C5A0231692460A0045EF05 /* RACMulticastConnection.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACMulticastConnection.h; sourceTree = "<group>"; };
+		88C5A025169246140045EF05 /* RACMulticastConnection.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACMulticastConnection.m; sourceTree = "<group>"; };
+		88C5A02816924BFC0045EF05 /* RACMulticastConnectionSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACMulticastConnectionSpec.m; sourceTree = "<group>"; };
+		88CDF7BF15000FCE00163A9F /* Cocoa.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Cocoa.framework; path = System/Library/Frameworks/Cocoa.framework; sourceTree = SDKROOT; };
+		88CDF7C315000FCE00163A9F /* CoreData.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreData.framework; path = System/Library/Frameworks/CoreData.framework; sourceTree = SDKROOT; };
+		88CDF7C415000FCE00163A9F /* Foundation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Foundation.framework; path = System/Library/Frameworks/Foundation.framework; sourceTree = SDKROOT; };
+		88CDF7C715000FCE00163A9F /* ReactiveCocoa-Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist; path = "ReactiveCocoa-Info.plist"; sourceTree = "<group>"; };
+		88CDF7C915000FCE00163A9F /* en */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = en; path = en.lproj/InfoPlist.strings; sourceTree = "<group>"; };
+		88CDF7CD15000FCE00163A9F /* ReactiveCocoa-Prefix.pch */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "ReactiveCocoa-Prefix.pch"; sourceTree = "<group>"; };
+		88CDF7DC15000FCF00163A9F /* ReactiveCocoaTests.octest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = ReactiveCocoaTests.octest; sourceTree = BUILT_PRODUCTS_DIR; };
+		88CDF7DD15000FCF00163A9F /* SenTestingKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = SenTestingKit.framework; path = Library/Frameworks/SenTestingKit.framework; sourceTree = DEVELOPER_DIR; };
+		88CDF7E415000FCF00163A9F /* ReactiveCocoaTests-Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist; path = "ReactiveCocoaTests-Info.plist"; sourceTree = "<group>"; };
+		88CDF7E615000FCF00163A9F /* en */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = en; path = en.lproj/InfoPlist.strings; sourceTree = "<group>"; };
+		88CDF7FA150019CA00163A9F /* RACSubscriber.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACSubscriber.h; sourceTree = "<group>"; };
+		88CDF7FB150019CA00163A9F /* RACSubscriber.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSubscriber.m; sourceTree = "<group>"; };
+		88CDF80415001CA800163A9F /* RACSignal.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RACSignal.h; sourceTree = "<group>"; };
+		88CDF82915008BB900163A9F /* NSObject+RACKVOWrapper.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSObject+RACKVOWrapper.m"; sourceTree = "<group>"; };
+		88CDF82C15008C0500163A9F /* NSObject+RACPropertySubscribing.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = "NSObject+RACPropertySubscribing.h"; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; };
+		88D4AB3C1510F6C30011494F /* RACReplaySubject.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACReplaySubject.h; sourceTree = "<group>"; };
+		88D4AB3D1510F6C30011494F /* RACReplaySubject.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; lineEnding = 0; path = RACReplaySubject.m; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.objc; };
+		88DA309515071CBA00C19D0F /* RACValueTransformer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACValueTransformer.h; sourceTree = "<group>"; };
+		88DA309615071CBA00C19D0F /* RACValueTransformer.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACValueTransformer.m; sourceTree = "<group>"; };
+		88E2C6B2153C771C00C7493C /* RACScheduler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACScheduler.h; sourceTree = "<group>"; };
+		88E2C6B3153C771C00C7493C /* RACScheduler.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACScheduler.m; sourceTree = "<group>"; };
+		88F440AB153DAC820097B4C3 /* libReactiveCocoa-iOS.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = "libReactiveCocoa-iOS.a"; sourceTree = BUILT_PRODUCTS_DIR; };
+		88F440D1153DADEA0097B4C3 /* NSObject+RACAppKitBindings.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSObject+RACAppKitBindings.h"; sourceTree = "<group>"; };
+		88F440D2153DADEA0097B4C3 /* NSObject+RACAppKitBindings.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSObject+RACAppKitBindings.m"; sourceTree = "<group>"; };
+		88F4425F153DC0450097B4C3 /* UIControl+RACSignalSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UIControl+RACSignalSupport.h"; sourceTree = "<group>"; };
+		88F44260153DC0450097B4C3 /* UIControl+RACSignalSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UIControl+RACSignalSupport.m"; sourceTree = "<group>"; };
+		88F44264153DCAC50097B4C3 /* UITextField+RACSignalSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UITextField+RACSignalSupport.h"; sourceTree = "<group>"; };
+		88F44265153DCAC50097B4C3 /* UITextField+RACSignalSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UITextField+RACSignalSupport.m"; sourceTree = "<group>"; };
+		88F5870515361C170084BD32 /* RACMulticastConnection+Private.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = "RACMulticastConnection+Private.h"; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; };
+		88FC735316114F9C00F8A774 /* RACSubscriptingAssignmentTrampoline.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACSubscriptingAssignmentTrampoline.h; sourceTree = "<group>"; };
+		88FC735416114F9C00F8A774 /* RACSubscriptingAssignmentTrampoline.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSubscriptingAssignmentTrampoline.m; sourceTree = "<group>"; };
+		88FC735A16114FFB00F8A774 /* RACSubscriptingAssignmentTrampolineSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSubscriptingAssignmentTrampolineSpec.m; sourceTree = "<group>"; };
+		A1FCC27215666AA3008C9686 /* UITextView+RACSignalSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UITextView+RACSignalSupport.h"; sourceTree = "<group>"; };
+		A1FCC27315666AA3008C9686 /* UITextView+RACSignalSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UITextView+RACSignalSupport.m"; sourceTree = "<group>"; };
+		A1FCC370156754A7008C9686 /* RACObjCRuntime.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACObjCRuntime.h; sourceTree = "<group>"; };
+		A1FCC371156754A7008C9686 /* RACObjCRuntime.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACObjCRuntime.m; sourceTree = "<group>"; };
+		A1FCC3761567DED0008C9686 /* RACDelegateProxy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACDelegateProxy.h; sourceTree = "<group>"; };
+		A1FCC3771567DED0008C9686 /* RACDelegateProxy.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACDelegateProxy.m; sourceTree = "<group>"; };
+		AC65FD51176DECB1005ED22B /* UIAlertViewRACSupportSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = UIAlertViewRACSupportSpec.m; sourceTree = "<group>"; };
+		ACB0EAF11797DDD400942FFC /* UIAlertView+RACSignalSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UIAlertView+RACSignalSupport.m"; sourceTree = "<group>"; };
+		ACB0EAF21797DDD400942FFC /* UIAlertView+RACSignalSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UIAlertView+RACSignalSupport.h"; sourceTree = "<group>"; };
+		BE527E9118636F7F006349E8 /* NSUserDefaults+RACSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSUserDefaults+RACSupport.h"; sourceTree = "<group>"; };
+		BE527E9218636F7F006349E8 /* NSUserDefaults+RACSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSUserDefaults+RACSupport.m"; sourceTree = "<group>"; };
+		BE527E9E1863705B006349E8 /* NSUserDefaultsRACSupportSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = NSUserDefaultsRACSupportSpec.m; sourceTree = "<group>"; };
+		CD11C6F118714CD0007C7CFD /* UITableViewHeaderFooterView+RACSignalSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UITableViewHeaderFooterView+RACSignalSupport.h"; sourceTree = "<group>"; };
+		CD11C6F218714CD0007C7CFD /* UITableViewHeaderFooterView+RACSignalSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UITableViewHeaderFooterView+RACSignalSupport.m"; sourceTree = "<group>"; };
+		CD11C6F918714DC1007C7CFD /* UITableViewHeaderFooterViewRACSupportSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = UITableViewHeaderFooterViewRACSupportSpec.m; sourceTree = "<group>"; };
+		CD11C6FC18714DFB007C7CFD /* RACTestTableViewController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACTestTableViewController.h; sourceTree = "<group>"; };
+		CD11C6FD18714DFB007C7CFD /* RACTestTableViewController.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACTestTableViewController.m; sourceTree = "<group>"; };
+		D004BC9B177E1A2B00A5B8C5 /* UIActionSheetRACSupportSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = UIActionSheetRACSupportSpec.m; path = ReactiveCocoaTests/UIActionSheetRACSupportSpec.m; sourceTree = SOURCE_ROOT; };
+		D00930771788AB7B00EE7E8B /* RACTestScheduler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACTestScheduler.h; sourceTree = "<group>"; };
+		D00930781788AB7B00EE7E8B /* RACTestScheduler.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACTestScheduler.m; sourceTree = "<group>"; };
+		D011F9CF1782AFD400EE7E38 /* NSObjectRACAppKitBindingsSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = NSObjectRACAppKitBindingsSpec.m; sourceTree = "<group>"; };
+		D013A3D41807B5ED0072B6CE /* RACErrorSignal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACErrorSignal.h; sourceTree = "<group>"; };
+		D013A3D51807B5ED0072B6CE /* RACErrorSignal.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACErrorSignal.m; sourceTree = "<group>"; };
+		D013A3DC1807B7450072B6CE /* RACEmptySignal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACEmptySignal.h; sourceTree = "<group>"; };
+		D013A3DD1807B7450072B6CE /* RACEmptySignal.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACEmptySignal.m; sourceTree = "<group>"; };
+		D013A3E41807B7C30072B6CE /* RACReturnSignal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACReturnSignal.h; sourceTree = "<group>"; };
+		D013A3E51807B7C30072B6CE /* RACReturnSignal.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACReturnSignal.m; sourceTree = "<group>"; };
+		D013A3ED1807B9690072B6CE /* RACDynamicSignal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACDynamicSignal.h; sourceTree = "<group>"; };
+		D013A3EE1807B9690072B6CE /* RACDynamicSignal.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACDynamicSignal.m; sourceTree = "<group>"; };
+		D01DB9AE166819B9003E8F7F /* ReactiveCocoaTests-Prefix.pch */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "ReactiveCocoaTests-Prefix.pch"; sourceTree = "<group>"; };
+		D020F3DA17F6A3E40092BED2 /* RACCompoundDisposableProvider.d */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.dtrace; path = RACCompoundDisposableProvider.d; sourceTree = "<group>"; };
+		D02221611678910900DBD031 /* RACTupleSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACTupleSpec.m; sourceTree = "<group>"; };
+		D02538A115E2D7FB005BACB8 /* RACBacktrace.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RACBacktrace.h; sourceTree = "<group>"; };
+		D028DB72179E53CB00D1042F /* RACSerialDisposable.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACSerialDisposable.h; sourceTree = "<group>"; };
+		D028DB73179E53CB00D1042F /* RACSerialDisposable.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSerialDisposable.m; sourceTree = "<group>"; };
+		D028DB7C179E591E00D1042F /* RACSerialDisposableSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSerialDisposableSpec.m; sourceTree = "<group>"; };
+		D028DB85179E616700D1042F /* UITableViewCell+RACSignalSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UITableViewCell+RACSignalSupport.h"; sourceTree = "<group>"; };
+		D028DB86179E616700D1042F /* UITableViewCell+RACSignalSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UITableViewCell+RACSignalSupport.m"; sourceTree = "<group>"; };
+		D0307EDB1731AAE100D83211 /* RACTupleSequence.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACTupleSequence.h; sourceTree = "<group>"; };
+		D0307EDC1731AAE100D83211 /* RACTupleSequence.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACTupleSequence.m; sourceTree = "<group>"; };
+		D03525D317E2EBC90099CBAB /* RACSignalProvider.d */ = {isa = PBXFileReference; explicitFileType = sourcecode.dtrace; fileEncoding = 4; path = RACSignalProvider.d; sourceTree = "<group>"; };
+		D041376815D2281C004BBF80 /* RACKVOWrapperSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACKVOWrapperSpec.m; sourceTree = "<group>"; };
+		D0487AB1164314430085D890 /* RACStreamExamples.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACStreamExamples.h; sourceTree = "<group>"; };
+		D0487AB2164314430085D890 /* RACStreamExamples.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACStreamExamples.m; sourceTree = "<group>"; };
+		D05AD39417F2D56F0080895B /* libReactiveCocoa-Mac.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = "libReactiveCocoa-Mac.a"; sourceTree = BUILT_PRODUCTS_DIR; };
+		D05AD39517F2D5700080895B /* Cocoa.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Cocoa.framework; path = System/Library/Frameworks/Cocoa.framework; sourceTree = SDKROOT; };
+		D05AD39717F2D5700080895B /* AppKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = AppKit.framework; path = System/Library/Frameworks/AppKit.framework; sourceTree = SDKROOT; };
+		D05AD3A317F2D5700080895B /* XCTest.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = XCTest.framework; path = Library/Frameworks/XCTest.framework; sourceTree = DEVELOPER_DIR; };
+		D05F9D3317984EC000FD7982 /* EXTRuntimeExtensions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = EXTRuntimeExtensions.h; sourceTree = "<group>"; };
+		D05F9D3417984EC000FD7982 /* EXTRuntimeExtensions.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = EXTRuntimeExtensions.m; sourceTree = "<group>"; };
+		D066C795176D262500C242D2 /* UIControlRACSupportSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = UIControlRACSupportSpec.m; sourceTree = "<group>"; };
+		D066C79B176D263D00C242D2 /* RACTestUIButton.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACTestUIButton.h; sourceTree = "<group>"; };
+		D066C79C176D263D00C242D2 /* RACTestUIButton.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACTestUIButton.m; sourceTree = "<group>"; };
+		D0700F4B1672994D00D7CD30 /* NSNotificationCenterRACSupportSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = NSNotificationCenterRACSupportSpec.m; sourceTree = "<group>"; };
+		D07200241788C57200987F70 /* RACTestSchedulerSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACTestSchedulerSpec.m; sourceTree = "<group>"; };
+		D075A72817BCB7E100C24FB7 /* RACControlCommandExamples.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACControlCommandExamples.h; sourceTree = "<group>"; };
+		D075A72917BCB7E100C24FB7 /* RACControlCommandExamples.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACControlCommandExamples.m; sourceTree = "<group>"; };
+		D077A16B169B740200057BB1 /* RACEvent.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACEvent.h; sourceTree = "<group>"; };
+		D077A16C169B740200057BB1 /* RACEvent.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACEvent.m; sourceTree = "<group>"; };
+		D077A171169B79A900057BB1 /* RACEventSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACEventSpec.m; sourceTree = "<group>"; };
+		D07CD7141731BA3900DE2394 /* RACUnarySequence.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACUnarySequence.h; sourceTree = "<group>"; };
+		D07CD7151731BA3900DE2394 /* RACUnarySequence.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACUnarySequence.m; sourceTree = "<group>"; };
+		D07E9489179DD21E00A6F609 /* RACStream+Private.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "RACStream+Private.h"; sourceTree = "<group>"; };
+		D0870C6E16884A0600D0E11D /* RACBacktraceSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACBacktraceSpec.m; sourceTree = "<group>"; };
+		D090767D17FBEADE00EB087A /* NSURLConnection+RACSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSURLConnection+RACSupport.h"; sourceTree = "<group>"; };
+		D090767E17FBEADE00EB087A /* NSURLConnection+RACSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSURLConnection+RACSupport.m"; sourceTree = "<group>"; };
+		D090768917FBECBF00EB087A /* NSURLConnectionRACSupportSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = NSURLConnectionRACSupportSpec.m; sourceTree = "<group>"; };
+		D090768C17FBED2E00EB087A /* test-data.json */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.json; path = "test-data.json"; sourceTree = "<group>"; };
+		D094E44517775AF200906BF7 /* EXTKeyPathCoding.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = EXTKeyPathCoding.h; sourceTree = "<group>"; };
+		D094E44617775AF200906BF7 /* EXTScope.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = EXTScope.h; sourceTree = "<group>"; };
+		D094E44817775AF200906BF7 /* metamacros.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = metamacros.h; sourceTree = "<group>"; };
+		D094E45317775B1000906BF7 /* Common.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Common.xcconfig; sourceTree = "<group>"; };
+		D094E45517775B1000906BF7 /* Debug.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Debug.xcconfig; sourceTree = "<group>"; };
+		D094E45617775B1000906BF7 /* Profile.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Profile.xcconfig; sourceTree = "<group>"; };
+		D094E45717775B1000906BF7 /* Release.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Release.xcconfig; sourceTree = "<group>"; };
+		D094E45817775B1000906BF7 /* Test.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Test.xcconfig; sourceTree = "<group>"; };
+		D094E45A17775B1000906BF7 /* Application.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Application.xcconfig; sourceTree = "<group>"; };
+		D094E45B17775B1000906BF7 /* StaticLibrary.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = StaticLibrary.xcconfig; sourceTree = "<group>"; };
+		D094E45D17775B1000906BF7 /* iOS-Application.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = "iOS-Application.xcconfig"; sourceTree = "<group>"; };
+		D094E45E17775B1000906BF7 /* iOS-Base.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = "iOS-Base.xcconfig"; sourceTree = "<group>"; };
+		D094E45F17775B1000906BF7 /* iOS-StaticLibrary.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = "iOS-StaticLibrary.xcconfig"; sourceTree = "<group>"; };
+		D094E46117775B1000906BF7 /* Mac-Application.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = "Mac-Application.xcconfig"; sourceTree = "<group>"; };
+		D094E46217775B1000906BF7 /* Mac-Base.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = "Mac-Base.xcconfig"; sourceTree = "<group>"; };
+		D094E46317775B1000906BF7 /* Mac-DynamicLibrary.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = "Mac-DynamicLibrary.xcconfig"; sourceTree = "<group>"; };
+		D094E46417775B1000906BF7 /* Mac-Framework.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = "Mac-Framework.xcconfig"; sourceTree = "<group>"; };
+		D094E46517775B1000906BF7 /* Mac-StaticLibrary.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = "Mac-StaticLibrary.xcconfig"; sourceTree = "<group>"; };
+		D094E46617775B1000906BF7 /* README.md */ = {isa = PBXFileReference; lastKnownFileType = text; path = README.md; sourceTree = "<group>"; };
+		D0A0B01316EAA3D100C47593 /* NSText+RACSignalSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSText+RACSignalSupport.h"; sourceTree = "<group>"; };
+		D0A0B01416EAA3D100C47593 /* NSText+RACSignalSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSText+RACSignalSupport.m"; sourceTree = "<group>"; };
+		D0A0B01716EAA5CC00C47593 /* NSTextRACSupportSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = NSTextRACSupportSpec.m; sourceTree = "<group>"; };
+		D0A0B03916EAA9AC00C47593 /* NSControl+RACTextSignalSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSControl+RACTextSignalSupport.h"; sourceTree = "<group>"; };
+		D0A0B03A16EAA9AC00C47593 /* NSControl+RACTextSignalSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSControl+RACTextSignalSupport.m"; sourceTree = "<group>"; };
+		D0A0E225176A84DA007273ED /* RACDisposableSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACDisposableSpec.m; sourceTree = "<group>"; };
+		D0A0E22C176A8CD6007273ED /* RACPassthroughSubscriber.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACPassthroughSubscriber.h; sourceTree = "<group>"; };
+		D0A0E22D176A8CD6007273ED /* RACPassthroughSubscriber.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACPassthroughSubscriber.m; sourceTree = "<group>"; };
+		D0C55CD817758A73008CDDCA /* UITextFieldRACSupportSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = UITextFieldRACSupportSpec.m; sourceTree = "<group>"; };
+		D0C55CDE17758C2A008CDDCA /* UITextViewRACSupportSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = UITextViewRACSupportSpec.m; sourceTree = "<group>"; };
+		D0C55CE117759559008CDDCA /* RACDelegateProxySpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACDelegateProxySpec.m; sourceTree = "<group>"; };
+		D0C70EC416659333005AAD03 /* RACSubscriberExamples.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACSubscriberExamples.h; sourceTree = "<group>"; };
+		D0C70EC516659333005AAD03 /* RACSubscriberExamples.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSubscriberExamples.m; sourceTree = "<group>"; };
+		D0C70EC7166595AD005AAD03 /* RACSubscriberSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSubscriberSpec.m; sourceTree = "<group>"; };
+		D0C70F8F164337A2007027B4 /* RACSequenceAdditionsSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSequenceAdditionsSpec.m; sourceTree = "<group>"; };
+		D0C70F91164337E3007027B4 /* RACSequenceExamples.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACSequenceExamples.h; sourceTree = "<group>"; };
+		D0C70F92164337E3007027B4 /* RACSequenceExamples.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSequenceExamples.m; sourceTree = "<group>"; };
+		D0D243B51741FA0E004359C6 /* NSObject+RACDescription.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "NSObject+RACDescription.h"; sourceTree = "<group>"; };
+		D0D243B61741FA0E004359C6 /* NSObject+RACDescription.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = "NSObject+RACDescription.m"; sourceTree = "<group>"; };
+		D0D486FF1642550100DD7605 /* RACStream.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACStream.h; sourceTree = "<group>"; };
+		D0D487001642550100DD7605 /* RACStream.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACStream.m; sourceTree = "<group>"; };
+		D0D487051642651400DD7605 /* RACSequenceSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSequenceSpec.m; sourceTree = "<group>"; };
+		D0D910CC15F915BD00AD2DDA /* RACSignal+Operations.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "RACSignal+Operations.h"; sourceTree = "<group>"; };
+		D0D910CD15F915BD00AD2DDA /* RACSignal+Operations.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "RACSignal+Operations.m"; sourceTree = "<group>"; };
+		D0DFBCCD15DD6D40009DADB3 /* RACBacktrace.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACBacktrace.m; sourceTree = "<group>"; };
+		D0E967571641EF9C00FCFF06 /* NSArray+RACSequenceAdditions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSArray+RACSequenceAdditions.h"; sourceTree = "<group>"; };
+		D0E967581641EF9C00FCFF06 /* NSArray+RACSequenceAdditions.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSArray+RACSequenceAdditions.m"; sourceTree = "<group>"; };
+		D0E967591641EF9C00FCFF06 /* NSDictionary+RACSequenceAdditions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSDictionary+RACSequenceAdditions.h"; sourceTree = "<group>"; };
+		D0E9675A1641EF9C00FCFF06 /* NSDictionary+RACSequenceAdditions.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSDictionary+RACSequenceAdditions.m"; sourceTree = "<group>"; };
+		D0E9675B1641EF9C00FCFF06 /* NSOrderedSet+RACSequenceAdditions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSOrderedSet+RACSequenceAdditions.h"; sourceTree = "<group>"; };
+		D0E9675C1641EF9C00FCFF06 /* NSOrderedSet+RACSequenceAdditions.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSOrderedSet+RACSequenceAdditions.m"; sourceTree = "<group>"; };
+		D0E9675D1641EF9C00FCFF06 /* NSSet+RACSequenceAdditions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSSet+RACSequenceAdditions.h"; sourceTree = "<group>"; };
+		D0E9675E1641EF9C00FCFF06 /* NSSet+RACSequenceAdditions.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSSet+RACSequenceAdditions.m"; sourceTree = "<group>"; };
+		D0E9675F1641EF9C00FCFF06 /* NSString+RACSequenceAdditions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSString+RACSequenceAdditions.h"; sourceTree = "<group>"; };
+		D0E967601641EF9C00FCFF06 /* NSString+RACSequenceAdditions.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSString+RACSequenceAdditions.m"; sourceTree = "<group>"; };
+		D0E967611641EF9C00FCFF06 /* RACArraySequence.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACArraySequence.h; sourceTree = "<group>"; };
+		D0E967621641EF9C00FCFF06 /* RACArraySequence.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACArraySequence.m; sourceTree = "<group>"; };
+		D0E967631641EF9C00FCFF06 /* RACDynamicSequence.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACDynamicSequence.h; sourceTree = "<group>"; };
+		D0E967641641EF9C00FCFF06 /* RACDynamicSequence.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACDynamicSequence.m; sourceTree = "<group>"; };
+		D0E967651641EF9C00FCFF06 /* RACEmptySequence.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACEmptySequence.h; sourceTree = "<group>"; };
+		D0E967661641EF9C00FCFF06 /* RACEmptySequence.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACEmptySequence.m; sourceTree = "<group>"; };
+		D0E967671641EF9C00FCFF06 /* RACSequence.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = RACSequence.h; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; };
+		D0E967681641EF9C00FCFF06 /* RACSequence.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSequence.m; sourceTree = "<group>"; };
+		D0E967691641EF9C00FCFF06 /* RACStringSequence.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACStringSequence.h; sourceTree = "<group>"; };
+		D0E9676A1641EF9C00FCFF06 /* RACStringSequence.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACStringSequence.m; sourceTree = "<group>"; };
+		D0EDE76516968AB10072A780 /* RACPropertySignalExamples.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACPropertySignalExamples.h; sourceTree = "<group>"; };
+		D0EDE76616968AB10072A780 /* RACPropertySignalExamples.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACPropertySignalExamples.m; sourceTree = "<group>"; };
+		D0EE2849164D906B006954A4 /* RACSignalSequence.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACSignalSequence.h; sourceTree = "<group>"; };
+		D0EE284A164D906B006954A4 /* RACSignalSequence.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSignalSequence.m; sourceTree = "<group>"; };
+		D0F117CB179F0B97006CE68F /* UITableViewCellRACSupportSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = UITableViewCellRACSupportSpec.m; sourceTree = "<group>"; };
+		D0FAEC02176AEEE600D3C1A7 /* RACSubscriber+Private.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "RACSubscriber+Private.h"; sourceTree = "<group>"; };
+		D40D7AAA18E22B5E0065BB70 /* libExpecta.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libExpecta.a; sourceTree = BUILT_PRODUCTS_DIR; };
+		D40D7AAC18E22B7E0065BB70 /* libSpecta.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libSpecta.a; sourceTree = BUILT_PRODUCTS_DIR; };
+		D40D7AAE18E22BE30065BB70 /* libExpecta-iOS.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = "libExpecta-iOS.a"; path = "../external/expecta/build/Debug-iphoneos/libExpecta-iOS.a"; sourceTree = "<group>"; };
+		D40D7AB018E22BF60065BB70 /* libSpecta-iOS.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = "libSpecta-iOS.a"; path = "../external/specta/build/Debug-iphoneos/libSpecta-iOS.a"; sourceTree = "<group>"; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		1860F40F177C91B500C7B3C9 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				D0F117C8179F0A95006CE68F /* libReactiveCocoa-iOS.a in Frameworks */,
+				1860F414177C91B500C7B3C9 /* UIKit.framework in Frameworks */,
+				1860F416177C91B500C7B3C9 /* Foundation.framework in Frameworks */,
+				1860F418177C91B500C7B3C9 /* CoreGraphics.framework in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		1860F42C177C91B500C7B3C9 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				1860F432177C91B500C7B3C9 /* SenTestingKit.framework in Frameworks */,
+				1860F433177C91B500C7B3C9 /* UIKit.framework in Frameworks */,
+				1860F434177C91B500C7B3C9 /* Foundation.framework in Frameworks */,
+				D40D7AB218E22EC60065BB70 /* libSpecta-iOS.a in Frameworks */,
+				D40D7AB318E22EC90065BB70 /* libExpecta-iOS.a in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		5FAF521F174D4C2000CAC810 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				5FD7DC7C174F9EEB008710B4 /* UIKit.framework in Frameworks */,
+				5FAF5289174E9CD300CAC810 /* CoreGraphics.framework in Frameworks */,
+				5FAF5265174D500D00CAC810 /* libReactiveCocoa-iOS.a in Frameworks */,
+				5FAF5224174D4C2000CAC810 /* SenTestingKit.framework in Frameworks */,
+				D40D7AAF18E22BE30065BB70 /* libExpecta-iOS.a in Frameworks */,
+				D40D7AB118E22BF60065BB70 /* libSpecta-iOS.a in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		88037F7F15056328001A5B19 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				88037F8415056328001A5B19 /* Cocoa.framework in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		88CDF7D815000FCF00163A9F /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				88037FD9150564D9001A5B19 /* ReactiveCocoa.framework in Frameworks */,
+				88CDF7DE15000FCF00163A9F /* SenTestingKit.framework in Frameworks */,
+				88CDF7DF15000FCF00163A9F /* Cocoa.framework in Frameworks */,
+				D40D7AAB18E22B5E0065BB70 /* libExpecta.a in Frameworks */,
+				D40D7AAD18E22B7E0065BB70 /* libSpecta.a in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		88F440A8153DAC820097B4C3 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				5FD7DC7A174F9EAF008710B4 /* Foundation.framework in Frameworks */,
+				5FD7DC7F174F9FC8008710B4 /* UIKit.framework in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		D05AD39117F2D56F0080895B /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				D05AD39617F2D5700080895B /* Cocoa.framework in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		1860F419177C91B500C7B3C9 /* UIKitTestHost */ = {
+			isa = PBXGroup;
+			children = (
+				1860F422177C91B500C7B3C9 /* RACAppDelegate.h */,
+				1860F423177C91B500C7B3C9 /* RACAppDelegate.m */,
+				CD11C6FC18714DFB007C7CFD /* RACTestTableViewController.h */,
+				CD11C6FD18714DFB007C7CFD /* RACTestTableViewController.m */,
+				1860F41A177C91B500C7B3C9 /* Supporting Files */,
+			);
+			path = UIKitTestHost;
+			sourceTree = "<group>";
+		};
+		1860F41A177C91B500C7B3C9 /* Supporting Files */ = {
+			isa = PBXGroup;
+			children = (
+				1860F41B177C91B500C7B3C9 /* ReactiveCocoa-iOS-UIKitTestHost-Info.plist */,
+				1860F41C177C91B500C7B3C9 /* InfoPlist.strings */,
+				1860F41F177C91B500C7B3C9 /* main.m */,
+				1860F421177C91B500C7B3C9 /* ReactiveCocoa-iOS-UIKitTestHost-Prefix.pch */,
+				1860F425177C91B500C7B3C9 /* Default.png */,
+				1860F427177C91B500C7B3C9 /* Default@2x.png */,
+				1860F429177C91B500C7B3C9 /* Default-568h@2x.png */,
+			);
+			name = "Supporting Files";
+			sourceTree = "<group>";
+		};
+		1860F437177C91B500C7B3C9 /* UIKitTests */ = {
+			isa = PBXGroup;
+			children = (
+				D004BC9B177E1A2B00A5B8C5 /* UIActionSheetRACSupportSpec.m */,
+				1668028117FE774800C724B4 /* UICollectionReusableViewRACSupportSpec.m */,
+				D0F117CB179F0B97006CE68F /* UITableViewCellRACSupportSpec.m */,
+				CD11C6F918714DC1007C7CFD /* UITableViewHeaderFooterViewRACSupportSpec.m */,
+				D0C55CD817758A73008CDDCA /* UITextFieldRACSupportSpec.m */,
+				D0C55CDE17758C2A008CDDCA /* UITextViewRACSupportSpec.m */,
+			);
+			path = UIKitTests;
+			sourceTree = "<group>";
+		};
+		1860F438177C91B500C7B3C9 /* Supporting Files */ = {
+			isa = PBXGroup;
+			children = (
+				1860F455177C96B200C7B3C9 /* ReactiveCocoa-iOS-UIKitTestHostTests-Info.plist */,
+				1860F457177C972E00C7B3C9 /* ReactiveCocoa-iOS-UIKitTest-Prefix.pch */,
+				1860F43A177C91B500C7B3C9 /* InfoPlist.strings */,
+			);
+			name = "Supporting Files";
+			path = UIKitTestHost;
+			sourceTree = "<group>";
+		};
+		1860F44E177C949A00C7B3C9 /* UIKit */ = {
+			isa = PBXGroup;
+			children = (
+				1860F437177C91B500C7B3C9 /* UIKitTests */,
+				1860F419177C91B500C7B3C9 /* UIKitTestHost */,
+				1860F438177C91B500C7B3C9 /* Supporting Files */,
+			);
+			path = UIKit;
+			sourceTree = "<group>";
+		};
+		5FAF525F174D4D6100CAC810 /* OS X */ = {
+			isa = PBXGroup;
+			children = (
+				884848B515F658B800B11BD0 /* NSControlRACSupportSpec.m */,
+				D011F9CF1782AFD400EE7E38 /* NSObjectRACAppKitBindingsSpec.m */,
+				D0A0B01716EAA5CC00C47593 /* NSTextRACSupportSpec.m */,
+				4925E805181BCC71000B2FEE /* NSControllerRACSupportSpec.m */,
+			);
+			name = "OS X";
+			sourceTree = "<group>";
+		};
+		5FAF5260174D4D7100CAC810 /* iOS */ = {
+			isa = PBXGroup;
+			children = (
+				1860F44E177C949A00C7B3C9 /* UIKit */,
+				D0C55CE117759559008CDDCA /* RACDelegateProxySpec.m */,
+				D066C79B176D263D00C242D2 /* RACTestUIButton.h */,
+				D066C79C176D263D00C242D2 /* RACTestUIButton.m */,
+				AC65FD51176DECB1005ED22B /* UIAlertViewRACSupportSpec.m */,
+				5FAF5261174D4D8E00CAC810 /* UIBarButtonItemRACSupportSpec.m */,
+				5EE9A79A1760D88500EAF5A2 /* UIButtonRACSupportSpec.m */,
+				D066C795176D262500C242D2 /* UIControlRACSupportSpec.m */,
+				5564542318107275002BD2E4 /* UIRefreshControlRACSupportSpec.m */,
+			);
+			name = iOS;
+			sourceTree = "<group>";
+		};
+		88977C5915129AB200A09EC5 /* KVO + Bindings */ = {
+			isa = PBXGroup;
+			children = (
+				5F6FE8511692568A00A8D7A6 /* RACChannel.h */,
+				5F6FE8521692568A00A8D7A6 /* RACChannel.m */,
+				5F45A883168CFA3E00B58A2B /* RACKVOChannel.h */,
+				5F45A884168CFA3E00B58A2B /* RACKVOChannel.m */,
+				8857BB81152A27A9009804CC /* NSObject+RACKVOWrapper.h */,
+				88CDF82915008BB900163A9F /* NSObject+RACKVOWrapper.m */,
+				5FDC35011736F54600792E52 /* NSString+RACKeyPathUtilities.h */,
+				5FDC35021736F54700792E52 /* NSString+RACKeyPathUtilities.m */,
+				8837EA1416A5A33300FC3CDF /* RACKVOTrampoline.h */,
+				8837EA1516A5A33300FC3CDF /* RACKVOTrampoline.m */,
+				88CDF82C15008C0500163A9F /* NSObject+RACPropertySubscribing.h */,
+				886678701518DCD800DE77EC /* NSObject+RACPropertySubscribing.m */,
+				88DA309515071CBA00C19D0F /* RACValueTransformer.h */,
+				88DA309615071CBA00C19D0F /* RACValueTransformer.m */,
+			);
+			name = "KVO + Bindings";
+			sourceTree = "<group>";
+		};
+		889C04BB155DA37600F19F0C /* Foundation Support */ = {
+			isa = PBXGroup;
+			children = (
+				D0E967571641EF9C00FCFF06 /* NSArray+RACSequenceAdditions.h */,
+				D0E967581641EF9C00FCFF06 /* NSArray+RACSequenceAdditions.m */,
+				88442C8716090C1500636B49 /* NSData+RACSupport.h */,
+				88442C8816090C1500636B49 /* NSData+RACSupport.m */,
+				D0E967591641EF9C00FCFF06 /* NSDictionary+RACSequenceAdditions.h */,
+				D0E9675A1641EF9C00FCFF06 /* NSDictionary+RACSequenceAdditions.m */,
+				5F773DE8169B46670023069D /* NSEnumerator+RACSequenceAdditions.h */,
+				5F773DE9169B46670023069D /* NSEnumerator+RACSequenceAdditions.m */,
+				88442C8916090C1500636B49 /* NSFileHandle+RACSupport.h */,
+				88442C8A16090C1500636B49 /* NSFileHandle+RACSupport.m */,
+				74F17316186024A900BC937C /* NSIndexSet+RACSequenceAdditions.h */,
+				74F17317186024A900BC937C /* NSIndexSet+RACSequenceAdditions.m */,
+				88442C8B16090C1500636B49 /* NSNotificationCenter+RACSupport.h */,
+				88442C8C16090C1500636B49 /* NSNotificationCenter+RACSupport.m */,
+				D0D243B51741FA0E004359C6 /* NSObject+RACDescription.h */,
+				D0D243B61741FA0E004359C6 /* NSObject+RACDescription.m */,
+				880D7A5816F7B351004A3361 /* NSObject+RACSelectorSignal.h */,
+				880D7A5916F7B351004A3361 /* NSObject+RACSelectorSignal.m */,
+				D0E9675B1641EF9C00FCFF06 /* NSOrderedSet+RACSequenceAdditions.h */,
+				D0E9675C1641EF9C00FCFF06 /* NSOrderedSet+RACSequenceAdditions.m */,
+				D0E9675D1641EF9C00FCFF06 /* NSSet+RACSequenceAdditions.h */,
+				D0E9675E1641EF9C00FCFF06 /* NSSet+RACSequenceAdditions.m */,
+				D0E9675F1641EF9C00FCFF06 /* NSString+RACSequenceAdditions.h */,
+				D0E967601641EF9C00FCFF06 /* NSString+RACSequenceAdditions.m */,
+				88442C8D16090C1500636B49 /* NSString+RACSupport.h */,
+				88442C8E16090C1500636B49 /* NSString+RACSupport.m */,
+				D090767D17FBEADE00EB087A /* NSURLConnection+RACSupport.h */,
+				D090767E17FBEADE00EB087A /* NSURLConnection+RACSupport.m */,
+				BE527E9118636F7F006349E8 /* NSUserDefaults+RACSupport.h */,
+				BE527E9218636F7F006349E8 /* NSUserDefaults+RACSupport.m */,
+			);
+			name = "Foundation Support";
+			sourceTree = "<group>";
+		};
+		88CDF7B015000FCE00163A9F = {
+			isa = PBXGroup;
+			children = (
+				88CDF7C515000FCE00163A9F /* ReactiveCocoa */,
+				88CDF7E215000FCF00163A9F /* ReactiveCocoaTests */,
+				88CDF7BE15000FCE00163A9F /* Frameworks */,
+				D094E45117775B1000906BF7 /* Configuration */,
+				88CDF7BC15000FCE00163A9F /* Products */,
+			);
+			sourceTree = "<group>";
+			usesTabs = 1;
+		};
+		88CDF7BC15000FCE00163A9F /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				88CDF7DC15000FCF00163A9F /* ReactiveCocoaTests.octest */,
+				88037F8315056328001A5B19 /* ReactiveCocoa.framework */,
+				88F440AB153DAC820097B4C3 /* libReactiveCocoa-iOS.a */,
+				5FAF5223174D4C2000CAC810 /* ReactiveCocoaTests-iOS.octest */,
+				1860F412177C91B500C7B3C9 /* ReactiveCocoa-iOS-UIKitTestHost.app */,
+				1860F430177C91B500C7B3C9 /* ReactiveCocoa-iOS-UIKitTestHostTests.octest */,
+				D05AD39417F2D56F0080895B /* libReactiveCocoa-Mac.a */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		88CDF7BE15000FCE00163A9F /* Frameworks */ = {
+			isa = PBXGroup;
+			children = (
+				D40D7AAC18E22B7E0065BB70 /* libSpecta.a */,
+				D40D7AB018E22BF60065BB70 /* libSpecta-iOS.a */,
+				D40D7AAA18E22B5E0065BB70 /* libExpecta.a */,
+				D40D7AAE18E22BE30065BB70 /* libExpecta-iOS.a */,
+				D094E44417775ACD00906BF7 /* libextobjc */,
+				1860F413177C91B500C7B3C9 /* UIKit.framework */,
+				1860F415177C91B500C7B3C9 /* Foundation.framework */,
+				1860F417177C91B500C7B3C9 /* CoreGraphics.framework */,
+				1860F431177C91B500C7B3C9 /* SenTestingKit.framework */,
+				D05AD39517F2D5700080895B /* Cocoa.framework */,
+				D05AD3A317F2D5700080895B /* XCTest.framework */,
+				88CDF7C115000FCE00163A9F /* Other Frameworks */,
+			);
+			name = Frameworks;
+			sourceTree = "<group>";
+		};
+		88CDF7C115000FCE00163A9F /* Other Frameworks */ = {
+			isa = PBXGroup;
+			children = (
+				88CDF7BF15000FCE00163A9F /* Cocoa.framework */,
+				88CDF7C315000FCE00163A9F /* CoreData.framework */,
+				5FAF5288174E9CD200CAC810 /* CoreGraphics.framework */,
+				88CDF7C415000FCE00163A9F /* Foundation.framework */,
+				88CDF7DD15000FCF00163A9F /* SenTestingKit.framework */,
+				5FD7DC7B174F9EEB008710B4 /* UIKit.framework */,
+				D05AD39717F2D5700080895B /* AppKit.framework */,
+			);
+			name = "Other Frameworks";
+			sourceTree = "<group>";
+		};
+		88CDF7C515000FCE00163A9F /* ReactiveCocoa */ = {
+			isa = PBXGroup;
+			children = (
+				88037F8C15056328001A5B19 /* ReactiveCocoa.h */,
+				88DA308C15071C4C00C19D0F /* Core */,
+				889C04BB155DA37600F19F0C /* Foundation Support */,
+				88DA309415071C5F00C19D0F /* AppKit Support */,
+				88F44257153DC0100097B4C3 /* UIKit Support */,
+				88977C5915129AB200A09EC5 /* KVO + Bindings */,
+				A1FCC36F15675466008C9686 /* Objective-C Runtime */,
+				88CDF7C615000FCE00163A9F /* Supporting Files */,
+			);
+			path = ReactiveCocoa;
+			sourceTree = "<group>";
+		};
+		88CDF7C615000FCE00163A9F /* Supporting Files */ = {
+			isa = PBXGroup;
+			children = (
+				88CDF7C715000FCE00163A9F /* ReactiveCocoa-Info.plist */,
+				88CDF7C815000FCE00163A9F /* InfoPlist.strings */,
+				88CDF7CD15000FCE00163A9F /* ReactiveCocoa-Prefix.pch */,
+			);
+			name = "Supporting Files";
+			sourceTree = "<group>";
+		};
+		88CDF7E215000FCF00163A9F /* ReactiveCocoaTests */ = {
+			isa = PBXGroup;
+			children = (
+				5FAF5260174D4D7100CAC810 /* iOS */,
+				5FAF525F174D4D6100CAC810 /* OS X */,
+				88CDF7E315000FCF00163A9F /* Supporting Files */,
+				5F773DEF169B48830023069D /* NSEnumeratorRACSequenceAdditionsSpec.m */,
+				D0700F4B1672994D00D7CD30 /* NSNotificationCenterRACSupportSpec.m */,
+				6E58405E16F3414200F588A6 /* NSObjectRACDeallocatingSpec.m */,
+				8801E7501644BDE200A155FE /* NSObjectRACLiftingSpec.m */,
+				1E89337F171647A5009071B0 /* NSObjectRACPropertySubscribingExamples.h */,
+				1E893380171647A5009071B0 /* NSObjectRACPropertySubscribingExamples.m */,
+				8851A38A16161D500050D47F /* NSObjectRACPropertySubscribingSpec.m */,
+				880D7A6516F7BB1A004A3361 /* NSObjectRACSelectorSignalSpec.m */,
+				5FDC350E1736F81800792E52 /* NSStringRACKeyPathUtilitiesSpec.m */,
+				D090768917FBECBF00EB087A /* NSURLConnectionRACSupportSpec.m */,
+				BE527E9E1863705B006349E8 /* NSUserDefaultsRACSupportSpec.m */,
+				D0870C6E16884A0600D0E11D /* RACBacktraceSpec.m */,
+				5F7EFECC168FBC4B0037E500 /* RACChannelExamples.h */,
+				5F7EFECD168FBC4B0037E500 /* RACChannelExamples.m */,
+				5F7EFECE168FBC4B0037E500 /* RACChannelSpec.m */,
+				D075A72817BCB7E100C24FB7 /* RACControlCommandExamples.h */,
+				D075A72917BCB7E100C24FB7 /* RACControlCommandExamples.m */,
+				886CEACC163DE669007632D1 /* RACBlockTrampolineSpec.m */,
+				882CCA1D15F1564D00937D6E /* RACCommandSpec.m */,
+				881E86B91669350B00667F7B /* RACCompoundDisposableSpec.m */,
+				D0A0E225176A84DA007273ED /* RACDisposableSpec.m */,
+				D077A171169B79A900057BB1 /* RACEventSpec.m */,
+				5F2447AC167E87C50062180C /* RACKVOChannelSpec.m */,
+				D041376815D2281C004BBF80 /* RACKVOWrapperSpec.m */,
+				88C5A02816924BFC0045EF05 /* RACMulticastConnectionSpec.m */,
+				D0EDE76516968AB10072A780 /* RACPropertySignalExamples.h */,
+				D0EDE76616968AB10072A780 /* RACPropertySignalExamples.m */,
+				8803C010166732BA00C36839 /* RACSchedulerSpec.m */,
+				D0C70F8F164337A2007027B4 /* RACSequenceAdditionsSpec.m */,
+				D0C70F91164337E3007027B4 /* RACSequenceExamples.h */,
+				D0C70F92164337E3007027B4 /* RACSequenceExamples.m */,
+				D0D487051642651400DD7605 /* RACSequenceSpec.m */,
+				8820937B1501C8A600796685 /* RACSignalSpec.m */,
+				8884DD6A1756AD3600F6C379 /* RACSignalStartExamples.h */,
+				8884DD641756ACF600F6C379 /* RACSignalStartExamples.m */,
+				D0487AB1164314430085D890 /* RACStreamExamples.h */,
+				D0487AB2164314430085D890 /* RACStreamExamples.m */,
+				880D7A6716F7BCC7004A3361 /* RACSubclassObject.h */,
+				880D7A6816F7BCC7004A3361 /* RACSubclassObject.m */,
+				889D0A7F15974B2A00F833E3 /* RACSubjectSpec.m */,
+				D0C70EC416659333005AAD03 /* RACSubscriberExamples.h */,
+				D0C70EC516659333005AAD03 /* RACSubscriberExamples.m */,
+				D0C70EC7166595AD005AAD03 /* RACSubscriberSpec.m */,
+				88FC735A16114FFB00F8A774 /* RACSubscriptingAssignmentTrampolineSpec.m */,
+				88302C2D1762C180003633BD /* RACTargetQueueSchedulerSpec.m */,
+				88302BFB1762A9E6003633BD /* RACTestExampleScheduler.h */,
+				88302BFC1762A9E6003633BD /* RACTestExampleScheduler.m */,
+				88442A321608A9AD00636B49 /* RACTestObject.h */,
+				88442A331608A9AD00636B49 /* RACTestObject.m */,
+				D02221611678910900DBD031 /* RACTupleSpec.m */,
+				8803C010166732BA00C36839 /* RACSchedulerSpec.m */,
+				D028DB7C179E591E00D1042F /* RACSerialDisposableSpec.m */,
+				D07200241788C57200987F70 /* RACTestSchedulerSpec.m */,
+			);
+			path = ReactiveCocoaTests;
+			sourceTree = "<group>";
+		};
+		88CDF7E315000FCF00163A9F /* Supporting Files */ = {
+			isa = PBXGroup;
+			children = (
+				88CDF7E415000FCF00163A9F /* ReactiveCocoaTests-Info.plist */,
+				88CDF7E515000FCF00163A9F /* InfoPlist.strings */,
+				D01DB9AE166819B9003E8F7F /* ReactiveCocoaTests-Prefix.pch */,
+				D090768C17FBED2E00EB087A /* test-data.json */,
+			);
+			name = "Supporting Files";
+			sourceTree = "<group>";
+		};
+		88DA308C15071C4C00C19D0F /* Core */ = {
+			isa = PBXGroup;
+			children = (
+				88CDF7FA150019CA00163A9F /* RACSubscriber.h */,
+				D0FAEC02176AEEE600D3C1A7 /* RACSubscriber+Private.h */,
+				88CDF7FB150019CA00163A9F /* RACSubscriber.m */,
+				D0A0E22C176A8CD6007273ED /* RACPassthroughSubscriber.h */,
+				D0A0E22D176A8CD6007273ED /* RACPassthroughSubscriber.m */,
+				888439A11634E10D00DED0DB /* RACBlockTrampoline.h */,
+				888439A21634E10D00DED0DB /* RACBlockTrampoline.m */,
+				881B37CA152260BF0079220B /* RACUnit.h */,
+				881B37CB152260BF0079220B /* RACUnit.m */,
+				88B76F8C153726B00053EAE2 /* RACTuple.h */,
+				88B76F8D153726B00053EAE2 /* RACTuple.m */,
+				D02538A115E2D7FB005BACB8 /* RACBacktrace.h */,
+				D0DFBCCD15DD6D40009DADB3 /* RACBacktrace.m */,
+				88FC735316114F9C00F8A774 /* RACSubscriptingAssignmentTrampoline.h */,
+				88FC735416114F9C00F8A774 /* RACSubscriptingAssignmentTrampoline.m */,
+				6E58405316F22D7500F588A6 /* NSObject+RACDeallocating.h */,
+				6E58405416F22D7500F588A6 /* NSObject+RACDeallocating.m */,
+				886CEAE0163DE942007632D1 /* NSObject+RACLifting.h */,
+				886CEAE1163DE942007632D1 /* NSObject+RACLifting.m */,
+				887ACDA5165878A7009190AD /* NSInvocation+RACTypeParsing.h */,
+				887ACDA6165878A7009190AD /* NSInvocation+RACTypeParsing.m */,
+				D0D486FF1642550100DD7605 /* RACStream.h */,
+				D07E9489179DD21E00A6F609 /* RACStream+Private.h */,
+				D0D487001642550100DD7605 /* RACStream.m */,
+				D0D486FB164253B600DD7605 /* Signals */,
+				D0D486FD164253D500DD7605 /* Disposables */,
+				D0D486FE164253E100DD7605 /* Commands */,
+				D0E967561641EF8200FCFF06 /* Sequences */,
+				D0087C1B16705C5600679459 /* Schedulers */,
+			);
+			name = Core;
+			sourceTree = "<group>";
+		};
+		88DA309415071C5F00C19D0F /* AppKit Support */ = {
+			isa = PBXGroup;
+			children = (
+				882093E61501E6CB00796685 /* NSControl+RACCommandSupport.h */,
+				882093E71501E6CB00796685 /* NSControl+RACCommandSupport.m */,
+				D0A0B03916EAA9AC00C47593 /* NSControl+RACTextSignalSupport.h */,
+				D0A0B03A16EAA9AC00C47593 /* NSControl+RACTextSignalSupport.m */,
+				88F440D1153DADEA0097B4C3 /* NSObject+RACAppKitBindings.h */,
+				88F440D2153DADEA0097B4C3 /* NSObject+RACAppKitBindings.m */,
+				D0A0B01316EAA3D100C47593 /* NSText+RACSignalSupport.h */,
+				D0A0B01416EAA3D100C47593 /* NSText+RACSignalSupport.m */,
+			);
+			name = "AppKit Support";
+			sourceTree = "<group>";
+		};
+		88F44257153DC0100097B4C3 /* UIKit Support */ = {
+			isa = PBXGroup;
+			children = (
+				A1FCC3761567DED0008C9686 /* RACDelegateProxy.h */,
+				A1FCC3771567DED0008C9686 /* RACDelegateProxy.m */,
+				557A4B58177648C7008EF796 /* UIActionSheet+RACSignalSupport.h */,
+				557A4B59177648C7008EF796 /* UIActionSheet+RACSignalSupport.m */,
+				ACB0EAF21797DDD400942FFC /* UIAlertView+RACSignalSupport.h */,
+				ACB0EAF11797DDD400942FFC /* UIAlertView+RACSignalSupport.m */,
+				27A887C71703DB4F00040001 /* UIBarButtonItem+RACCommandSupport.h */,
+				27A887C81703DB4F00040001 /* UIBarButtonItem+RACCommandSupport.m */,
+				5EE9A7911760D61300EAF5A2 /* UIButton+RACCommandSupport.h */,
+				5EE9A7921760D61300EAF5A2 /* UIButton+RACCommandSupport.m */,
+				1668027817FE75E900C724B4 /* UICollectionReusableView+RACSignalSupport.h */,
+				1668027917FE75E900C724B4 /* UICollectionReusableView+RACSignalSupport.m */,
+				88F4425F153DC0450097B4C3 /* UIControl+RACSignalSupport.h */,
+				88F44260153DC0450097B4C3 /* UIControl+RACSignalSupport.m */,
+				5F016DF217B10AA8002EEC69 /* UIControl+RACSignalSupportPrivate.h */,
+				5F016DF317B10AA8002EEC69 /* UIControl+RACSignalSupportPrivate.m */,
+				5F70B2AD17AB1829009AEDF9 /* UIDatePicker+RACSignalSupport.h */,
+				5F70B2AE17AB1829009AEDF9 /* UIDatePicker+RACSignalSupport.m */,
+				1EC06B15173CB04000365258 /* UIGestureRecognizer+RACSignalSupport.h */,
+				1EC06B16173CB04000365258 /* UIGestureRecognizer+RACSignalSupport.m */,
+				554D9E5B181064E200F21262 /* UIRefreshControl+RACCommandSupport.h */,
+				554D9E5C181064E200F21262 /* UIRefreshControl+RACCommandSupport.m */,
+				5F70B2B617AB1856009AEDF9 /* UISegmentedControl+RACSignalSupport.h */,
+				5F70B2B717AB1856009AEDF9 /* UISegmentedControl+RACSignalSupport.m */,
+				5F70B2B817AB1856009AEDF9 /* UISlider+RACSignalSupport.h */,
+				5F70B2B917AB1856009AEDF9 /* UISlider+RACSignalSupport.m */,
+				5F70B2BA17AB1857009AEDF9 /* UIStepper+RACSignalSupport.h */,
+				5F70B2BB17AB1857009AEDF9 /* UIStepper+RACSignalSupport.m */,
+				5F70B2BC17AB1857009AEDF9 /* UISwitch+RACSignalSupport.h */,
+				5F70B2BD17AB1857009AEDF9 /* UISwitch+RACSignalSupport.m */,
+				D028DB85179E616700D1042F /* UITableViewCell+RACSignalSupport.h */,
+				D028DB86179E616700D1042F /* UITableViewCell+RACSignalSupport.m */,
+				CD11C6F118714CD0007C7CFD /* UITableViewHeaderFooterView+RACSignalSupport.h */,
+				CD11C6F218714CD0007C7CFD /* UITableViewHeaderFooterView+RACSignalSupport.m */,
+				88F44264153DCAC50097B4C3 /* UITextField+RACSignalSupport.h */,
+				88F44265153DCAC50097B4C3 /* UITextField+RACSignalSupport.m */,
+				A1FCC27215666AA3008C9686 /* UITextView+RACSignalSupport.h */,
+				A1FCC27315666AA3008C9686 /* UITextView+RACSignalSupport.m */,
+			);
+			name = "UIKit Support";
+			sourceTree = "<group>";
+		};
+		A1FCC36F15675466008C9686 /* Objective-C Runtime */ = {
+			isa = PBXGroup;
+			children = (
+				A1FCC370156754A7008C9686 /* RACObjCRuntime.h */,
+				A1FCC371156754A7008C9686 /* RACObjCRuntime.m */,
+			);
+			name = "Objective-C Runtime";
+			sourceTree = "<group>";
+		};
+		D0087C1B16705C5600679459 /* Schedulers */ = {
+			isa = PBXGroup;
+			children = (
+				88E2C6B2153C771C00C7493C /* RACScheduler.h */,
+				886D98581667C86D00F22541 /* RACScheduler+Private.h */,
+				88E2C6B3153C771C00C7493C /* RACScheduler.m */,
+				881E87AA16695C5600667F7B /* RACQueueScheduler.h */,
+				882D07201761521B009EDA69 /* RACQueueScheduler+Subclass.h */,
+				881E87AB16695C5600667F7B /* RACQueueScheduler.m */,
+				882D071717614FA7009EDA69 /* RACTargetQueueScheduler.h */,
+				882D071817614FA7009EDA69 /* RACTargetQueueScheduler.m */,
+				881E87B016695EDF00667F7B /* RACImmediateScheduler.h */,
+				881E87B116695EDF00667F7B /* RACImmediateScheduler.m */,
+				881E87C21669635F00667F7B /* RACSubscriptionScheduler.h */,
+				881E87C31669636000667F7B /* RACSubscriptionScheduler.m */,
+				D00930771788AB7B00EE7E8B /* RACTestScheduler.h */,
+				D00930781788AB7B00EE7E8B /* RACTestScheduler.m */,
+			);
+			name = Schedulers;
+			sourceTree = "<group>";
+		};
+		D013A3EC1807B9260072B6CE /* Private */ = {
+			isa = PBXGroup;
+			children = (
+				D013A3ED1807B9690072B6CE /* RACDynamicSignal.h */,
+				D013A3EE1807B9690072B6CE /* RACDynamicSignal.m */,
+				D013A3DC1807B7450072B6CE /* RACEmptySignal.h */,
+				D013A3DD1807B7450072B6CE /* RACEmptySignal.m */,
+				D013A3D41807B5ED0072B6CE /* RACErrorSignal.h */,
+				D013A3D51807B5ED0072B6CE /* RACErrorSignal.m */,
+				D013A3E41807B7C30072B6CE /* RACReturnSignal.h */,
+				D013A3E51807B7C30072B6CE /* RACReturnSignal.m */,
+			);
+			name = Private;
+			sourceTree = "<group>";
+		};
+		D094E44417775ACD00906BF7 /* libextobjc */ = {
+			isa = PBXGroup;
+			children = (
+				D094E44517775AF200906BF7 /* EXTKeyPathCoding.h */,
+				D05F9D3317984EC000FD7982 /* EXTRuntimeExtensions.h */,
+				D05F9D3417984EC000FD7982 /* EXTRuntimeExtensions.m */,
+				D094E44617775AF200906BF7 /* EXTScope.h */,
+				D094E44817775AF200906BF7 /* metamacros.h */,
+			);
+			name = libextobjc;
+			path = ReactiveCocoa/extobjc;
+			sourceTree = "<group>";
+		};
+		D094E45117775B1000906BF7 /* Configuration */ = {
+			isa = PBXGroup;
+			children = (
+				D094E45217775B1000906BF7 /* Base */,
+				D094E45C17775B1000906BF7 /* iOS */,
+				D094E46017775B1000906BF7 /* Mac OS X */,
+				D094E46617775B1000906BF7 /* README.md */,
+			);
+			name = Configuration;
+			path = ../external/xcconfigs;
+			sourceTree = "<group>";
+		};
+		D094E45217775B1000906BF7 /* Base */ = {
+			isa = PBXGroup;
+			children = (
+				D094E45317775B1000906BF7 /* Common.xcconfig */,
+				D094E45417775B1000906BF7 /* Configurations */,
+				D094E45917775B1000906BF7 /* Targets */,
+			);
+			path = Base;
+			sourceTree = "<group>";
+		};
+		D094E45417775B1000906BF7 /* Configurations */ = {
+			isa = PBXGroup;
+			children = (
+				D094E45517775B1000906BF7 /* Debug.xcconfig */,
+				D094E45617775B1000906BF7 /* Profile.xcconfig */,
+				D094E45717775B1000906BF7 /* Release.xcconfig */,
+				D094E45817775B1000906BF7 /* Test.xcconfig */,
+			);
+			path = Configurations;
+			sourceTree = "<group>";
+		};
+		D094E45917775B1000906BF7 /* Targets */ = {
+			isa = PBXGroup;
+			children = (
+				D094E45A17775B1000906BF7 /* Application.xcconfig */,
+				D094E45B17775B1000906BF7 /* StaticLibrary.xcconfig */,
+			);
+			path = Targets;
+			sourceTree = "<group>";
+		};
+		D094E45C17775B1000906BF7 /* iOS */ = {
+			isa = PBXGroup;
+			children = (
+				D094E45D17775B1000906BF7 /* iOS-Application.xcconfig */,
+				D094E45E17775B1000906BF7 /* iOS-Base.xcconfig */,
+				D094E45F17775B1000906BF7 /* iOS-StaticLibrary.xcconfig */,
+			);
+			path = iOS;
+			sourceTree = "<group>";
+		};
+		D094E46017775B1000906BF7 /* Mac OS X */ = {
+			isa = PBXGroup;
+			children = (
+				D094E46117775B1000906BF7 /* Mac-Application.xcconfig */,
+				D094E46217775B1000906BF7 /* Mac-Base.xcconfig */,
+				D094E46317775B1000906BF7 /* Mac-DynamicLibrary.xcconfig */,
+				D094E46417775B1000906BF7 /* Mac-Framework.xcconfig */,
+				D094E46517775B1000906BF7 /* Mac-StaticLibrary.xcconfig */,
+			);
+			path = "Mac OS X";
+			sourceTree = "<group>";
+		};
+		D0D486FB164253B600DD7605 /* Signals */ = {
+			isa = PBXGroup;
+			children = (
+				88CDF80415001CA800163A9F /* RACSignal.h */,
+				88977C3D1512914A00A09EC5 /* RACSignal.m */,
+				D03525D317E2EBC90099CBAB /* RACSignalProvider.d */,
+				D0D910CC15F915BD00AD2DDA /* RACSignal+Operations.h */,
+				D0D910CD15F915BD00AD2DDA /* RACSignal+Operations.m */,
+				D077A16B169B740200057BB1 /* RACEvent.h */,
+				D077A16C169B740200057BB1 /* RACEvent.m */,
+				88C5A0231692460A0045EF05 /* RACMulticastConnection.h */,
+				88F5870515361C170084BD32 /* RACMulticastConnection+Private.h */,
+				88C5A025169246140045EF05 /* RACMulticastConnection.m */,
+				886F70281551CF920045D68B /* RACGroupedSignal.h */,
+				886F70291551CF920045D68B /* RACGroupedSignal.m */,
+				D013A3EC1807B9260072B6CE /* Private */,
+				D0D486FC164253C400DD7605 /* Subjects */,
+			);
+			name = Signals;
+			sourceTree = "<group>";
+		};
+		D0D486FC164253C400DD7605 /* Subjects */ = {
+			isa = PBXGroup;
+			children = (
+				880B9174150B09190008488E /* RACSubject.h */,
+				880B9175150B09190008488E /* RACSubject.m */,
+				88D4AB3C1510F6C30011494F /* RACReplaySubject.h */,
+				88D4AB3D1510F6C30011494F /* RACReplaySubject.m */,
+				883A84D81513964B006DB4C7 /* RACBehaviorSubject.h */,
+				883A84D91513964B006DB4C7 /* RACBehaviorSubject.m */,
+			);
+			name = Subjects;
+			sourceTree = "<group>";
+		};
+		D0D486FD164253D500DD7605 /* Disposables */ = {
+			isa = PBXGroup;
+			children = (
+				883A84DD1513B5EC006DB4C7 /* RACDisposable.h */,
+				883A84DE1513B5EC006DB4C7 /* RACDisposable.m */,
+				884476E2152367D100958F44 /* RACScopedDisposable.h */,
+				884476E3152367D100958F44 /* RACScopedDisposable.m */,
+				881E86A01669304700667F7B /* RACCompoundDisposable.h */,
+				881E86A11669304700667F7B /* RACCompoundDisposable.m */,
+				D020F3DA17F6A3E40092BED2 /* RACCompoundDisposableProvider.d */,
+				D028DB72179E53CB00D1042F /* RACSerialDisposable.h */,
+				D028DB73179E53CB00D1042F /* RACSerialDisposable.m */,
+			);
+			name = Disposables;
+			sourceTree = "<group>";
+		};
+		D0D486FE164253E100DD7605 /* Commands */ = {
+			isa = PBXGroup;
+			children = (
+				882093E91501E6EE00796685 /* RACCommand.h */,
+				882093EA1501E6EE00796685 /* RACCommand.m */,
+			);
+			name = Commands;
+			sourceTree = "<group>";
+		};
+		D0E967561641EF8200FCFF06 /* Sequences */ = {
+			isa = PBXGroup;
+			children = (
+				D0E967671641EF9C00FCFF06 /* RACSequence.h */,
+				D0E967681641EF9C00FCFF06 /* RACSequence.m */,
+				D0E967611641EF9C00FCFF06 /* RACArraySequence.h */,
+				D0E967621641EF9C00FCFF06 /* RACArraySequence.m */,
+				D0E967631641EF9C00FCFF06 /* RACDynamicSequence.h */,
+				D0E967641641EF9C00FCFF06 /* RACDynamicSequence.m */,
+				5F9743F51694A2460024EB82 /* RACEagerSequence.h */,
+				5F9743F61694A2460024EB82 /* RACEagerSequence.m */,
+				D0E967651641EF9C00FCFF06 /* RACEmptySequence.h */,
+				D0E967661641EF9C00FCFF06 /* RACEmptySequence.m */,
+				7479F6E3186177D200575CDB /* RACIndexSetSequence.h */,
+				7479F6E4186177D200575CDB /* RACIndexSetSequence.m */,
+				D0E967691641EF9C00FCFF06 /* RACStringSequence.h */,
+				D0E9676A1641EF9C00FCFF06 /* RACStringSequence.m */,
+				D0EE2849164D906B006954A4 /* RACSignalSequence.h */,
+				D0EE284A164D906B006954A4 /* RACSignalSequence.m */,
+				D0307EDB1731AAE100D83211 /* RACTupleSequence.h */,
+				D0307EDC1731AAE100D83211 /* RACTupleSequence.m */,
+				D07CD7141731BA3900DE2394 /* RACUnarySequence.h */,
+				D07CD7151731BA3900DE2394 /* RACUnarySequence.m */,
+			);
+			name = Sequences;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXHeadersBuildPhase section */
+		88037F8015056328001A5B19 /* Headers */ = {
+			isa = PBXHeadersBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				882D071917614FA7009EDA69 /* RACTargetQueueScheduler.h in Headers */,
+				881E87AC16695C5600667F7B /* RACQueueScheduler.h in Headers */,
+				88037FB81505645C001A5B19 /* ReactiveCocoa.h in Headers */,
+				88037FBB1505646C001A5B19 /* NSObject+RACPropertySubscribing.h in Headers */,
+				88037FBC1505646C001A5B19 /* RACSignal.h in Headers */,
+				88037FBE1505646C001A5B19 /* RACSubscriber.h in Headers */,
+				88037FC11505646C001A5B19 /* RACCommand.h in Headers */,
+				88037FC21505646C001A5B19 /* NSControl+RACCommandSupport.h in Headers */,
+				D028DB74179E53CB00D1042F /* RACSerialDisposable.h in Headers */,
+				880B9176150B09190008488E /* RACSubject.h in Headers */,
+				D090767F17FBEADE00EB087A /* NSURLConnection+RACSupport.h in Headers */,
+				88F440D3153DADEA0097B4C3 /* NSObject+RACAppKitBindings.h in Headers */,
+				88D4AB3E1510F6C30011494F /* RACReplaySubject.h in Headers */,
+				883A84DA1513964B006DB4C7 /* RACBehaviorSubject.h in Headers */,
+				883A84DF1513B5EC006DB4C7 /* RACDisposable.h in Headers */,
+				886F702A1551CF920045D68B /* RACGroupedSignal.h in Headers */,
+				881B37CC152260BF0079220B /* RACUnit.h in Headers */,
+				884476E4152367D100958F44 /* RACScopedDisposable.h in Headers */,
+				88E2C6B4153C771C00C7493C /* RACScheduler.h in Headers */,
+				88B76F8E153726B00053EAE2 /* RACTuple.h in Headers */,
+				886CEAE2163DE942007632D1 /* NSObject+RACLifting.h in Headers */,
+				D0D910CE15F915BD00AD2DDA /* RACSignal+Operations.h in Headers */,
+				D0E9676B1641EF9C00FCFF06 /* NSArray+RACSequenceAdditions.h in Headers */,
+				D0E9676F1641EF9C00FCFF06 /* NSDictionary+RACSequenceAdditions.h in Headers */,
+				D0E967731641EF9C00FCFF06 /* NSOrderedSet+RACSequenceAdditions.h in Headers */,
+				D0E967771641EF9C00FCFF06 /* NSSet+RACSequenceAdditions.h in Headers */,
+				D0E9677B1641EF9C00FCFF06 /* NSString+RACSequenceAdditions.h in Headers */,
+				D0E9678B1641EF9C00FCFF06 /* RACSequence.h in Headers */,
+				88A0B6D3165B2B77005DE8F3 /* RACSubscriptingAssignmentTrampoline.h in Headers */,
+				D0D487011642550100DD7605 /* RACStream.h in Headers */,
+				88C5A0241692460A0045EF05 /* RACMulticastConnection.h in Headers */,
+				881E86A21669304800667F7B /* RACCompoundDisposable.h in Headers */,
+				881E87C41669636000667F7B /* RACSubscriptionScheduler.h in Headers */,
+				5F45A885168CFA3E00B58A2B /* RACKVOChannel.h in Headers */,
+				880D7A5A16F7B351004A3361 /* NSObject+RACSelectorSignal.h in Headers */,
+				6E58405516F22D7500F588A6 /* NSObject+RACDeallocating.h in Headers */,
+				5F6FE8531692568A00A8D7A6 /* RACChannel.h in Headers */,
+				882D072117615381009EDA69 /* RACQueueScheduler+Subclass.h in Headers */,
+				D005A259169A3B7D00A9D2DB /* RACBacktrace.h in Headers */,
+				BE527E9318636F7F006349E8 /* NSUserDefaults+RACSupport.h in Headers */,
+				5F773DEA169B46670023069D /* NSEnumerator+RACSequenceAdditions.h in Headers */,
+				D077A16D169B740200057BB1 /* RACEvent.h in Headers */,
+				D0A0B01516EAA3D100C47593 /* NSText+RACSignalSupport.h in Headers */,
+				D0A0B03B16EAA9AC00C47593 /* NSControl+RACTextSignalSupport.h in Headers */,
+				D094E44917775AF200906BF7 /* EXTKeyPathCoding.h in Headers */,
+				D094E44B17775AF200906BF7 /* EXTScope.h in Headers */,
+				D094E44F17775AF200906BF7 /* metamacros.h in Headers */,
+				D00930791788AB7B00EE7E8B /* RACTestScheduler.h in Headers */,
+				74F17318186024A900BC937C /* NSIndexSet+RACSequenceAdditions.h in Headers */,
+				55C39DEC17F1EC84006DC60C /* NSData+RACSupport.h in Headers */,
+				55C39DED17F1EC84006DC60C /* NSFileHandle+RACSupport.h in Headers */,
+				55C39DEE17F1EC84006DC60C /* NSNotificationCenter+RACSupport.h in Headers */,
+				55C39DEF17F1EC84006DC60C /* NSString+RACSupport.h in Headers */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		88F440A9153DAC820097B4C3 /* Headers */ = {
+			isa = PBXHeadersBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				880D7A5B16F7B351004A3361 /* NSObject+RACSelectorSignal.h in Headers */,
+				CD11C6F318714CD0007C7CFD /* UITableViewHeaderFooterView+RACSignalSupport.h in Headers */,
+				5F45A886168CFA3E00B58A2B /* RACKVOChannel.h in Headers */,
+				554D9E5D181064E200F21262 /* UIRefreshControl+RACCommandSupport.h in Headers */,
+				5F6FE8541692568A00A8D7A6 /* RACChannel.h in Headers */,
+				D08FF264169A32D100743C6D /* ReactiveCocoa.h in Headers */,
+				D08FF265169A32DC00743C6D /* RACSubscriber.h in Headers */,
+				D08FF267169A330000743C6D /* RACUnit.h in Headers */,
+				D08FF268169A330000743C6D /* RACTuple.h in Headers */,
+				D08FF269169A330000743C6D /* RACBacktrace.h in Headers */,
+				D08FF26A169A330000743C6D /* RACSubscriptingAssignmentTrampoline.h in Headers */,
+				74F17319186024A900BC937C /* NSIndexSet+RACSequenceAdditions.h in Headers */,
+				D08FF26C169A331A00743C6D /* RACStream.h in Headers */,
+				D08FF26D169A331A00743C6D /* RACSignal.h in Headers */,
+				D08FF26E169A331A00743C6D /* RACSignal+Operations.h in Headers */,
+				D08FF26F169A331A00743C6D /* RACMulticastConnection.h in Headers */,
+				D08FF270169A331A00743C6D /* RACGroupedSignal.h in Headers */,
+				D08FF271169A331A00743C6D /* RACSubject.h in Headers */,
+				D08FF272169A331A00743C6D /* RACReplaySubject.h in Headers */,
+				D08FF273169A331A00743C6D /* RACBehaviorSubject.h in Headers */,
+				D08FF274169A331A00743C6D /* RACDisposable.h in Headers */,
+				D08FF275169A331A00743C6D /* RACScopedDisposable.h in Headers */,
+				D08FF276169A331A00743C6D /* RACCompoundDisposable.h in Headers */,
+				D08FF277169A331B00743C6D /* RACCommand.h in Headers */,
+				D08FF278169A331B00743C6D /* RACSequence.h in Headers */,
+				D08FF27F169A331B00743C6D /* RACScheduler.h in Headers */,
+				D08FF26B169A330000743C6D /* NSObject+RACLifting.h in Headers */,
+				D08FF280169A333400743C6D /* NSArray+RACSequenceAdditions.h in Headers */,
+				D028DB75179E53CB00D1042F /* RACSerialDisposable.h in Headers */,
+				D08FF281169A333400743C6D /* NSDictionary+RACSequenceAdditions.h in Headers */,
+				D08FF282169A333400743C6D /* NSOrderedSet+RACSequenceAdditions.h in Headers */,
+				D028DB87179E616700D1042F /* UITableViewCell+RACSignalSupport.h in Headers */,
+				1646747B17FFA0610036E30B /* UICollectionReusableView+RACSignalSupport.h in Headers */,
+				D08FF283169A333400743C6D /* NSSet+RACSequenceAdditions.h in Headers */,
+				D08FF284169A333400743C6D /* NSString+RACSequenceAdditions.h in Headers */,
+				D08FF285169A333400743C6D /* UIControl+RACSignalSupport.h in Headers */,
+				D08FF286169A333400743C6D /* UITextField+RACSignalSupport.h in Headers */,
+				D08FF287169A333400743C6D /* UITextView+RACSignalSupport.h in Headers */,
+				D08FF289169A333400743C6D /* NSObject+RACPropertySubscribing.h in Headers */,
+				5F773DEB169B46670023069D /* NSEnumerator+RACSequenceAdditions.h in Headers */,
+				D077A16E169B740200057BB1 /* RACEvent.h in Headers */,
+				6EA0C08216F4AEC1006EBEB2 /* NSObject+RACDeallocating.h in Headers */,
+				27A887D21703DDEB00040001 /* UIBarButtonItem+RACCommandSupport.h in Headers */,
+				1EC06B17173CB04000365258 /* UIGestureRecognizer+RACSignalSupport.h in Headers */,
+				D090768017FBEADE00EB087A /* NSURLConnection+RACSupport.h in Headers */,
+				5EE9A7931760D61300EAF5A2 /* UIButton+RACCommandSupport.h in Headers */,
+				88302C961762EC79003633BD /* RACQueueScheduler.h in Headers */,
+				BE527E9418636F7F006349E8 /* NSUserDefaults+RACSupport.h in Headers */,
+				88302C9B1762EC7E003633BD /* RACQueueScheduler+Subclass.h in Headers */,
+				88302CA21762F62D003633BD /* RACTargetQueueScheduler.h in Headers */,
+				557A4B5A177648C7008EF796 /* UIActionSheet+RACSignalSupport.h in Headers */,
+				ACB0EAF41797DDD400942FFC /* UIAlertView+RACSignalSupport.h in Headers */,
+				D094E44A17775AF200906BF7 /* EXTKeyPathCoding.h in Headers */,
+				D094E44C17775AF200906BF7 /* EXTScope.h in Headers */,
+				D094E45017775AF200906BF7 /* metamacros.h in Headers */,
+				D009307A1788AB7B00EE7E8B /* RACTestScheduler.h in Headers */,
+				5F70B2AF17AB1829009AEDF9 /* UIDatePicker+RACSignalSupport.h in Headers */,
+				5F70B2BE17AB1857009AEDF9 /* UISegmentedControl+RACSignalSupport.h in Headers */,
+				5F70B2C017AB1857009AEDF9 /* UISlider+RACSignalSupport.h in Headers */,
+				5F70B2C217AB1857009AEDF9 /* UIStepper+RACSignalSupport.h in Headers */,
+				5F70B2C417AB1857009AEDF9 /* UISwitch+RACSignalSupport.h in Headers */,
+				55C39DF017F1EC84006DC60C /* NSData+RACSupport.h in Headers */,
+				55C39DF117F1EC84006DC60C /* NSFileHandle+RACSupport.h in Headers */,
+				55C39DF217F1EC84006DC60C /* NSNotificationCenter+RACSupport.h in Headers */,
+				55C39DF317F1EC84006DC60C /* NSString+RACSupport.h in Headers */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		D05AD39217F2D56F0080895B /* Headers */ = {
+			isa = PBXHeadersBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				D05AD3E017F2DB1D0080895B /* RACBehaviorSubject.h in Headers */,
+				D05AD3C917F2DB100080895B /* RACSubscriptingAssignmentTrampoline.h in Headers */,
+				D05AD3C517F2DB100080895B /* RACTuple.h in Headers */,
+				74F1731A186024A900BC937C /* NSIndexSet+RACSequenceAdditions.h in Headers */,
+				D05AD41A17F2DB6A0080895B /* NSString+RACSequenceAdditions.h in Headers */,
+				D05AD41E17F2DB6E0080895B /* NSControl+RACCommandSupport.h in Headers */,
+				D05AD3E417F2DB230080895B /* RACScopedDisposable.h in Headers */,
+				D05AD40F17F2DB6A0080895B /* NSFileHandle+RACSupport.h in Headers */,
+				D05AD40517F2DB5D0080895B /* RACTestScheduler.h in Headers */,
+				D05AD42817F2DB840080895B /* RACKVOChannel.h in Headers */,
+				D05AD3FF17F2DB5D0080895B /* RACTargetQueueScheduler.h in Headers */,
+				D05AD3E217F2DB230080895B /* RACDisposable.h in Headers */,
+				D05AD42617F2DB840080895B /* RACChannel.h in Headers */,
+				D05AD3EA17F2DB270080895B /* RACCommand.h in Headers */,
+				D05AD3DE17F2DB1D0080895B /* RACReplaySubject.h in Headers */,
+				D05AD3D817F2DB1D0080895B /* RACMulticastConnection.h in Headers */,
+				D05AD3E817F2DB230080895B /* RACSerialDisposable.h in Headers */,
+				D05AD42E17F2DB840080895B /* NSObject+RACPropertySubscribing.h in Headers */,
+				D05AD3CB17F2DB100080895B /* NSObject+RACDeallocating.h in Headers */,
+				D05AD3D417F2DB1D0080895B /* RACSignal+Operations.h in Headers */,
+				D05AD41417F2DB6A0080895B /* NSObject+RACSelectorSignal.h in Headers */,
+				D05AD3FC17F2DB5D0080895B /* RACQueueScheduler.h in Headers */,
+				D05AD42017F2DB6E0080895B /* NSControl+RACTextSignalSupport.h in Headers */,
+				D05AD3FD17F2DB5D0080895B /* RACQueueScheduler+Subclass.h in Headers */,
+				D05AD42217F2DB6E0080895B /* NSObject+RACAppKitBindings.h in Headers */,
+				BE527E9518636F7F006349E8 /* NSUserDefaults+RACSupport.h in Headers */,
+				D05AD3DA17F2DB1D0080895B /* RACGroupedSignal.h in Headers */,
+				D05AD41617F2DB6A0080895B /* NSOrderedSet+RACSequenceAdditions.h in Headers */,
+				D05AD3E617F2DB230080895B /* RACCompoundDisposable.h in Headers */,
+				D05AD40B17F2DB6A0080895B /* NSDictionary+RACSequenceAdditions.h in Headers */,
+				D05AD3D617F2DB1D0080895B /* RACEvent.h in Headers */,
+				D05AD3D017F2DB100080895B /* RACStream.h in Headers */,
+				D05AD3DC17F2DB1D0080895B /* RACSubject.h in Headers */,
+				D05AD41C17F2DB6A0080895B /* NSString+RACSupport.h in Headers */,
+				D05AD42417F2DB6E0080895B /* NSText+RACSignalSupport.h in Headers */,
+				D05AD3C017F2DA300080895B /* RACSubscriber.h in Headers */,
+				D05AD40717F2DB6A0080895B /* NSArray+RACSequenceAdditions.h in Headers */,
+				D090768117FBEADE00EB087A /* NSURLConnection+RACSupport.h in Headers */,
+				D05AD3C717F2DB100080895B /* RACBacktrace.h in Headers */,
+				D05AD3EE17F2DB4F0080895B /* RACSequence.h in Headers */,
+				D05AD3D217F2DB1D0080895B /* RACSignal.h in Headers */,
+				D05AD3CD17F2DB100080895B /* NSObject+RACLifting.h in Headers */,
+				D05AD40D17F2DB6A0080895B /* NSEnumerator+RACSequenceAdditions.h in Headers */,
+				D05AD3FA17F2DB5D0080895B /* RACScheduler.h in Headers */,
+				D05AD40317F2DB5D0080895B /* RACSubscriptionScheduler.h in Headers */,
+				D05AD41817F2DB6A0080895B /* NSSet+RACSequenceAdditions.h in Headers */,
+				D05AD41117F2DB6A0080895B /* NSNotificationCenter+RACSupport.h in Headers */,
+				D05AD40917F2DB6A0080895B /* NSData+RACSupport.h in Headers */,
+				D05AD3C317F2DB100080895B /* RACUnit.h in Headers */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXHeadersBuildPhase section */
+
+/* Begin PBXNativeTarget section */
+		1860F411177C91B500C7B3C9 /* ReactiveCocoa-iOS-UIKitTestHost */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 1860F44C177C91B500C7B3C9 /* Build configuration list for PBXNativeTarget "ReactiveCocoa-iOS-UIKitTestHost" */;
+			buildPhases = (
+				1860F40E177C91B500C7B3C9 /* Sources */,
+				1860F40F177C91B500C7B3C9 /* Frameworks */,
+				1860F410177C91B500C7B3C9 /* Resources */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				D0F117C3179F0A91006CE68F /* PBXTargetDependency */,
+			);
+			name = "ReactiveCocoa-iOS-UIKitTestHost";
+			productName = "ReactiveCocoa-iOS-UIKitTestHost";
+			productReference = 1860F412177C91B500C7B3C9 /* ReactiveCocoa-iOS-UIKitTestHost.app */;
+			productType = "com.apple.product-type.application";
+		};
+		1860F42F177C91B500C7B3C9 /* ReactiveCocoa-iOS-UIKitTestHostTests */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 1860F44D177C91B500C7B3C9 /* Build configuration list for PBXNativeTarget "ReactiveCocoa-iOS-UIKitTestHostTests" */;
+			buildPhases = (
+				1860F42B177C91B500C7B3C9 /* Sources */,
+				1860F42C177C91B500C7B3C9 /* Frameworks */,
+				1860F42D177C91B500C7B3C9 /* Resources */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				1860F436177C91B500C7B3C9 /* PBXTargetDependency */,
+			);
+			name = "ReactiveCocoa-iOS-UIKitTestHostTests";
+			productName = "ReactiveCocoa-iOS-UIKitTestHostTests";
+			productReference = 1860F430177C91B500C7B3C9 /* ReactiveCocoa-iOS-UIKitTestHostTests.octest */;
+			productType = "com.apple.product-type.bundle";
+		};
+		5FAF5222174D4C2000CAC810 /* ReactiveCocoaTests-iOS */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 5FAF523D174D4C2000CAC810 /* Build configuration list for PBXNativeTarget "ReactiveCocoaTests-iOS" */;
+			buildPhases = (
+				5FAF521E174D4C2000CAC810 /* Sources */,
+				5FAF521F174D4C2000CAC810 /* Frameworks */,
+				5FAF5220174D4C2000CAC810 /* Resources */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				D0ED9DB617501806003859A6 /* PBXTargetDependency */,
+			);
+			name = "ReactiveCocoaTests-iOS";
+			productName = "ReactiveCocoaTests-iOS";
+			productReference = 5FAF5223174D4C2000CAC810 /* ReactiveCocoaTests-iOS.octest */;
+			productType = "com.apple.product-type.bundle";
+		};
+		88037F8215056328001A5B19 /* ReactiveCocoa */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 88037F8F15056328001A5B19 /* Build configuration list for PBXNativeTarget "ReactiveCocoa" */;
+			buildPhases = (
+				88037F7E15056328001A5B19 /* Sources */,
+				88037F7F15056328001A5B19 /* Frameworks */,
+				88037F8015056328001A5B19 /* Headers */,
+				88037F8115056328001A5B19 /* Resources */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = ReactiveCocoa;
+			productName = ReactiveCocoa;
+			productReference = 88037F8315056328001A5B19 /* ReactiveCocoa.framework */;
+			productType = "com.apple.product-type.framework";
+		};
+		88CDF7DB15000FCF00163A9F /* ReactiveCocoaTests */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 88CDF7F015000FCF00163A9F /* Build configuration list for PBXNativeTarget "ReactiveCocoaTests" */;
+			buildPhases = (
+				88CDF7D715000FCF00163A9F /* Sources */,
+				88CDF7D815000FCF00163A9F /* Frameworks */,
+				88CDF7D915000FCF00163A9F /* Resources */,
+				8820937F1501C94E00796685 /* Copy Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				88037FDB150564E9001A5B19 /* PBXTargetDependency */,
+			);
+			name = ReactiveCocoaTests;
+			productName = GHObservableTests;
+			productReference = 88CDF7DC15000FCF00163A9F /* ReactiveCocoaTests.octest */;
+			productType = "com.apple.product-type.bundle";
+		};
+		88F440AA153DAC820097B4C3 /* ReactiveCocoa-iOS */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 88F440B3153DAC820097B4C3 /* Build configuration list for PBXNativeTarget "ReactiveCocoa-iOS" */;
+			buildPhases = (
+				88F440A7153DAC820097B4C3 /* Sources */,
+				88F440A8153DAC820097B4C3 /* Frameworks */,
+				88F440A9153DAC820097B4C3 /* Headers */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = "ReactiveCocoa-iOS";
+			productName = ReactiveCocoaLib;
+			productReference = 88F440AB153DAC820097B4C3 /* libReactiveCocoa-iOS.a */;
+			productType = "com.apple.product-type.library.static";
+		};
+		D05AD39317F2D56F0080895B /* ReactiveCocoa-Mac */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = D05AD3BD17F2D5710080895B /* Build configuration list for PBXNativeTarget "ReactiveCocoa-Mac" */;
+			buildPhases = (
+				D05AD39017F2D56F0080895B /* Sources */,
+				D05AD39117F2D56F0080895B /* Frameworks */,
+				D05AD39217F2D56F0080895B /* Headers */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = "ReactiveCocoa-Mac";
+			productName = "ReactiveCocoa-Mac";
+			productReference = D05AD39417F2D56F0080895B /* libReactiveCocoa-Mac.a */;
+			productType = "com.apple.product-type.library.static";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		88CDF7B215000FCE00163A9F /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				CLASSPREFIX = RAC;
+				LastUpgradeCheck = 0500;
+				ORGANIZATIONNAME = "GitHub, Inc.";
+			};
+			buildConfigurationList = 88CDF7B515000FCE00163A9F /* Build configuration list for PBXProject "ReactiveCocoa" */;
+			compatibilityVersion = "Xcode 3.2";
+			developmentRegion = English;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				en,
+			);
+			mainGroup = 88CDF7B015000FCE00163A9F;
+			productRefGroup = 88CDF7BC15000FCE00163A9F /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				88037F8215056328001A5B19 /* ReactiveCocoa */,
+				88F440AA153DAC820097B4C3 /* ReactiveCocoa-iOS */,
+				88CDF7DB15000FCF00163A9F /* ReactiveCocoaTests */,
+				5FAF5222174D4C2000CAC810 /* ReactiveCocoaTests-iOS */,
+				1860F411177C91B500C7B3C9 /* ReactiveCocoa-iOS-UIKitTestHost */,
+				1860F42F177C91B500C7B3C9 /* ReactiveCocoa-iOS-UIKitTestHostTests */,
+				D05AD39317F2D56F0080895B /* ReactiveCocoa-Mac */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXResourcesBuildPhase section */
+		1860F410177C91B500C7B3C9 /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				1860F41E177C91B500C7B3C9 /* InfoPlist.strings in Resources */,
+				1860F426177C91B500C7B3C9 /* Default.png in Resources */,
+				1860F428177C91B500C7B3C9 /* Default@2x.png in Resources */,
+				1860F42A177C91B500C7B3C9 /* Default-568h@2x.png in Resources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		1860F42D177C91B500C7B3C9 /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				1860F43C177C91B500C7B3C9 /* InfoPlist.strings in Resources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		5FAF5220174D4C2000CAC810 /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				D090768E17FBED2E00EB087A /* test-data.json in Resources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		88037F8115056328001A5B19 /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		88CDF7D915000FCF00163A9F /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				D090768D17FBED2E00EB087A /* test-data.json in Resources */,
+				88CDF7E715000FCF00163A9F /* InfoPlist.strings in Resources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXResourcesBuildPhase section */
+
+/* Begin PBXSourcesBuildPhase section */
+		1860F40E177C91B500C7B3C9 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				CD11C6FF18714F00007C7CFD /* RACTestTableViewController.m in Sources */,
+				1860F420177C91B500C7B3C9 /* main.m in Sources */,
+				1860F424177C91B500C7B3C9 /* RACAppDelegate.m in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		1860F42B177C91B500C7B3C9 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				CD11C700187151AE007C7CFD /* UITableViewHeaderFooterViewRACSupportSpec.m in Sources */,
+				1668028317FE775200C724B4 /* UICollectionReusableViewRACSupportSpec.m in Sources */,
+				5564537F18107203002BD2E4 /* RACControlCommandExamples.m in Sources */,
+				D0F117CC179F0B97006CE68F /* UITableViewCellRACSupportSpec.m in Sources */,
+				1860F44F177C958300C7B3C9 /* UITextFieldRACSupportSpec.m in Sources */,
+				1860F450177C958900C7B3C9 /* UITextViewRACSupportSpec.m in Sources */,
+				D004BC9C177E1A2B00A5B8C5 /* UIActionSheetRACSupportSpec.m in Sources */,
+				5564542418107275002BD2E4 /* UIRefreshControlRACSupportSpec.m in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		5FAF521E174D4C2000CAC810 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				5FAF523E174D4D3200CAC810 /* NSEnumeratorRACSequenceAdditionsSpec.m in Sources */,
+				5FAF523F174D4D3600CAC810 /* NSNotificationCenterRACSupportSpec.m in Sources */,
+				D090768B17FBECBF00EB087A /* NSURLConnectionRACSupportSpec.m in Sources */,
+				5FAF5240174D4D5600CAC810 /* NSObjectRACDeallocatingSpec.m in Sources */,
+				5FAF5241174D4D5600CAC810 /* NSObjectRACLiftingSpec.m in Sources */,
+				5FAF5242174D4D5600CAC810 /* NSObjectRACPropertySubscribingExamples.m in Sources */,
+				5FAF5243174D4D5600CAC810 /* NSObjectRACPropertySubscribingSpec.m in Sources */,
+				5FAF5244174D4D5600CAC810 /* NSStringRACKeyPathUtilitiesSpec.m in Sources */,
+				5FAF5246174D4D5600CAC810 /* RACBacktraceSpec.m in Sources */,
+				5FAF5247174D4D5600CAC810 /* RACBlockTrampolineSpec.m in Sources */,
+				5FAF5248174D4D5600CAC810 /* RACCommandSpec.m in Sources */,
+				5FAF5249174D4D5600CAC810 /* RACCompoundDisposableSpec.m in Sources */,
+				BE527EA01863706B006349E8 /* NSUserDefaultsRACSupportSpec.m in Sources */,
+				5FAF524A174D4D5600CAC810 /* RACEventSpec.m in Sources */,
+				5FAF524B174D4D5600CAC810 /* RACKVOWrapperSpec.m in Sources */,
+				5FAF524C174D4D5600CAC810 /* RACMulticastConnectionSpec.m in Sources */,
+				5FAF524D174D4D5600CAC810 /* RACKVOChannelSpec.m in Sources */,
+				5FAF524E174D4D5600CAC810 /* RACPropertySignalExamples.m in Sources */,
+				5FAF524F174D4D5600CAC810 /* RACChannelExamples.m in Sources */,
+				5FAF5250174D4D5600CAC810 /* RACChannelSpec.m in Sources */,
+				5FAF5251174D4D5600CAC810 /* RACSchedulerSpec.m in Sources */,
+				5FAF5252174D4D5600CAC810 /* RACSequenceAdditionsSpec.m in Sources */,
+				5FAF5253174D4D5600CAC810 /* RACSequenceExamples.m in Sources */,
+				5FAF5254174D4D5600CAC810 /* RACSequenceSpec.m in Sources */,
+				5FAF5255174D4D5600CAC810 /* RACSignalSpec.m in Sources */,
+				5FAF5256174D4D5600CAC810 /* RACStreamExamples.m in Sources */,
+				5FAF5257174D4D5600CAC810 /* RACSubjectSpec.m in Sources */,
+				5FAF5258174D4D5600CAC810 /* RACSubscriberExamples.m in Sources */,
+				5FAF5259174D4D5600CAC810 /* RACSubscriberSpec.m in Sources */,
+				AC65FD52176DECB1005ED22B /* UIAlertViewRACSupportSpec.m in Sources */,
+				5FAF525A174D4D5600CAC810 /* RACSubscriptingAssignmentTrampolineSpec.m in Sources */,
+				5FAF525B174D4D5600CAC810 /* RACTestObject.m in Sources */,
+				5FAF525C174D4D5600CAC810 /* RACTupleSpec.m in Sources */,
+				5FAF525D174D4D5600CAC810 /* NSObjectRACSelectorSignalSpec.m in Sources */,
+				5FAF525E174D4D5600CAC810 /* RACSubclassObject.m in Sources */,
+				5FAF5262174D4D8F00CAC810 /* UIBarButtonItemRACSupportSpec.m in Sources */,
+				88302BFE1762A9E6003633BD /* RACTestExampleScheduler.m in Sources */,
+				8884DD6B1756B65300F6C379 /* RACSignalStartExamples.m in Sources */,
+				D028DB7E179E591E00D1042F /* RACSerialDisposableSpec.m in Sources */,
+				5EE9A79B1760D88500EAF5A2 /* UIButtonRACSupportSpec.m in Sources */,
+				88302C2F1762C180003633BD /* RACTargetQueueSchedulerSpec.m in Sources */,
+				D0A0E227176A84DB007273ED /* RACDisposableSpec.m in Sources */,
+				D066C796176D262500C242D2 /* UIControlRACSupportSpec.m in Sources */,
+				D066C79D176D263D00C242D2 /* RACTestUIButton.m in Sources */,
+				D0C55CE217759559008CDDCA /* RACDelegateProxySpec.m in Sources */,
+				D07200261788C57200987F70 /* RACTestSchedulerSpec.m in Sources */,
+				D075A72B17BCB7E100C24FB7 /* RACControlCommandExamples.m in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		88037F7E15056328001A5B19 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				88A0B6D2165B2B09005DE8F3 /* RACBlockTrampoline.m in Sources */,
+				88037FC71505647E001A5B19 /* NSObject+RACKVOWrapper.m in Sources */,
+				88037FC91505648C001A5B19 /* RACSubscriber.m in Sources */,
+				88037FCC1505648C001A5B19 /* RACCommand.m in Sources */,
+				88037FCD1505648C001A5B19 /* NSControl+RACCommandSupport.m in Sources */,
+				D090768217FBEADE00EB087A /* NSURLConnection+RACSupport.m in Sources */,
+				88DA309815071CBA00C19D0F /* RACValueTransformer.m in Sources */,
+				880B9177150B09190008488E /* RACSubject.m in Sources */,
+				88D4AB3F1510F6C30011494F /* RACReplaySubject.m in Sources */,
+				88977C3E1512914A00A09EC5 /* RACSignal.m in Sources */,
+				883A84DB1513964B006DB4C7 /* RACBehaviorSubject.m in Sources */,
+				883A84E01513B5EC006DB4C7 /* RACDisposable.m in Sources */,
+				886678711518DCD800DE77EC /* NSObject+RACPropertySubscribing.m in Sources */,
+				881B37CD152260BF0079220B /* RACUnit.m in Sources */,
+				884476E5152367D100958F44 /* RACScopedDisposable.m in Sources */,
+				88B76F8F153726B00053EAE2 /* RACTuple.m in Sources */,
+				88E2C6B5153C771C00C7493C /* RACScheduler.m in Sources */,
+				88F440D4153DADEA0097B4C3 /* NSObject+RACAppKitBindings.m in Sources */,
+				886F702B1551CF920045D68B /* RACGroupedSignal.m in Sources */,
+				A1FCC374156754A7008C9686 /* RACObjCRuntime.m in Sources */,
+				BE527E9618636F7F006349E8 /* NSUserDefaults+RACSupport.m in Sources */,
+				D0DFBCCE15DD6D40009DADB3 /* RACBacktrace.m in Sources */,
+				D0D910D015F915BD00AD2DDA /* RACSignal+Operations.m in Sources */,
+				88FC735716114F9C00F8A774 /* RACSubscriptingAssignmentTrampoline.m in Sources */,
+				886CEAE4163DE942007632D1 /* NSObject+RACLifting.m in Sources */,
+				D013A3E11807B7450072B6CE /* RACEmptySignal.m in Sources */,
+				887ACDA9165878A8009190AD /* NSInvocation+RACTypeParsing.m in Sources */,
+				D0E9676D1641EF9C00FCFF06 /* NSArray+RACSequenceAdditions.m in Sources */,
+				D0E967711641EF9C00FCFF06 /* NSDictionary+RACSequenceAdditions.m in Sources */,
+				D0E967751641EF9C00FCFF06 /* NSOrderedSet+RACSequenceAdditions.m in Sources */,
+				D0E967791641EF9C00FCFF06 /* NSSet+RACSequenceAdditions.m in Sources */,
+				D0E9677D1641EF9C00FCFF06 /* NSString+RACSequenceAdditions.m in Sources */,
+				D0E967811641EF9C00FCFF06 /* RACArraySequence.m in Sources */,
+				D0E967851641EF9C00FCFF06 /* RACDynamicSequence.m in Sources */,
+				D0E967891641EF9C00FCFF06 /* RACEmptySequence.m in Sources */,
+				D03525D417E2EBC90099CBAB /* RACSignalProvider.d in Sources */,
+				D028DB76179E53CB00D1042F /* RACSerialDisposable.m in Sources */,
+				D0E9678D1641EF9C00FCFF06 /* RACSequence.m in Sources */,
+				D0E967911641EF9C00FCFF06 /* RACStringSequence.m in Sources */,
+				D0D487031642550100DD7605 /* RACStream.m in Sources */,
+				D0EE284D164D906B006954A4 /* RACSignalSequence.m in Sources */,
+				881E86A41669304800667F7B /* RACCompoundDisposable.m in Sources */,
+				881E87AE16695C5600667F7B /* RACQueueScheduler.m in Sources */,
+				881E87B416695EDF00667F7B /* RACImmediateScheduler.m in Sources */,
+				881E87C61669636000667F7B /* RACSubscriptionScheduler.m in Sources */,
+				5F45A887168CFA3E00B58A2B /* RACKVOChannel.m in Sources */,
+				5F6FE8551692568A00A8D7A6 /* RACChannel.m in Sources */,
+				88C5A026169246140045EF05 /* RACMulticastConnection.m in Sources */,
+				5F9743F91694A2460024EB82 /* RACEagerSequence.m in Sources */,
+				5F773DEC169B46670023069D /* NSEnumerator+RACSequenceAdditions.m in Sources */,
+				D077A16F169B740200057BB1 /* RACEvent.m in Sources */,
+				8837EA1816A5A33300FC3CDF /* RACKVOTrampoline.m in Sources */,
+				D0A0B01616EAA3D100C47593 /* NSText+RACSignalSupport.m in Sources */,
+				D020F3DB17F6A3E40092BED2 /* RACCompoundDisposableProvider.d in Sources */,
+				D0A0B03C16EAA9AC00C47593 /* NSControl+RACTextSignalSupport.m in Sources */,
+				D013A3E91807B7C30072B6CE /* RACReturnSignal.m in Sources */,
+				6E58405616F22D7500F588A6 /* NSObject+RACDeallocating.m in Sources */,
+				880D7A5C16F7B351004A3361 /* NSObject+RACSelectorSignal.m in Sources */,
+				D0307EDF1731AAE100D83211 /* RACTupleSequence.m in Sources */,
+				D07CD7181731BA3900DE2394 /* RACUnarySequence.m in Sources */,
+				5FDC35051736F54700792E52 /* NSString+RACKeyPathUtilities.m in Sources */,
+				D0D243BD1741FA13004359C6 /* NSObject+RACDescription.m in Sources */,
+				882D071A17614FA7009EDA69 /* RACTargetQueueScheduler.m in Sources */,
+				74F1731B186024A900BC937C /* NSIndexSet+RACSequenceAdditions.m in Sources */,
+				D0A0E230176A8CD6007273ED /* RACPassthroughSubscriber.m in Sources */,
+				D013A3D91807B5ED0072B6CE /* RACErrorSignal.m in Sources */,
+				7479F6E8186177D200575CDB /* RACIndexSetSequence.m in Sources */,
+				D05F9D3717984EC000FD7982 /* EXTRuntimeExtensions.m in Sources */,
+				D009307B1788AB7B00EE7E8B /* RACTestScheduler.m in Sources */,
+				55C39DE417F1EC6E006DC60C /* NSData+RACSupport.m in Sources */,
+				55C39DE517F1EC6E006DC60C /* NSFileHandle+RACSupport.m in Sources */,
+				55C39DE617F1EC6E006DC60C /* NSNotificationCenter+RACSupport.m in Sources */,
+				D013A3F21807B9690072B6CE /* RACDynamicSignal.m in Sources */,
+				55C39DE717F1EC6E006DC60C /* NSString+RACSupport.m in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		88CDF7D715000FCF00163A9F /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				8820937C1501C8A600796685 /* RACSignalSpec.m in Sources */,
+				889D0A8015974B2A00F833E3 /* RACSubjectSpec.m in Sources */,
+				D041376915D2281C004BBF80 /* RACKVOWrapperSpec.m in Sources */,
+				D028DB7D179E591E00D1042F /* RACSerialDisposableSpec.m in Sources */,
+				882CCA1E15F1564D00937D6E /* RACCommandSpec.m in Sources */,
+				884848B615F658B800B11BD0 /* NSControlRACSupportSpec.m in Sources */,
+				88442A341608A9AD00636B49 /* RACTestObject.m in Sources */,
+				88FC735B16114FFB00F8A774 /* RACSubscriptingAssignmentTrampolineSpec.m in Sources */,
+				8851A38B16161D500050D47F /* NSObjectRACPropertySubscribingSpec.m in Sources */,
+				D0D487061642651400DD7605 /* RACSequenceSpec.m in Sources */,
+				D0487AB3164314430085D890 /* RACStreamExamples.m in Sources */,
+				D0C70F90164337A2007027B4 /* RACSequenceAdditionsSpec.m in Sources */,
+				D0C70F93164337E3007027B4 /* RACSequenceExamples.m in Sources */,
+				886CEACD163DE669007632D1 /* RACBlockTrampolineSpec.m in Sources */,
+				8801E7511644BDE200A155FE /* NSObjectRACLiftingSpec.m in Sources */,
+				D0C70EC616659333005AAD03 /* RACSubscriberExamples.m in Sources */,
+				D090768A17FBECBF00EB087A /* NSURLConnectionRACSupportSpec.m in Sources */,
+				D0C70EC8166595AD005AAD03 /* RACSubscriberSpec.m in Sources */,
+				8803C011166732BA00C36839 /* RACSchedulerSpec.m in Sources */,
+				881E86BA1669350B00667F7B /* RACCompoundDisposableSpec.m in Sources */,
+				D0700F4C1672994D00D7CD30 /* NSNotificationCenterRACSupportSpec.m in Sources */,
+				5F2447AD167E87C50062180C /* RACKVOChannelSpec.m in Sources */,
+				D02221621678910900DBD031 /* RACTupleSpec.m in Sources */,
+				5F7EFECF168FBC4B0037E500 /* RACChannelExamples.m in Sources */,
+				5F7EFED0168FBC4B0037E500 /* RACChannelSpec.m in Sources */,
+				D0870C6F16884A0600D0E11D /* RACBacktraceSpec.m in Sources */,
+				88C5A02916924BFC0045EF05 /* RACMulticastConnectionSpec.m in Sources */,
+				D0EDE76716968AB10072A780 /* RACPropertySignalExamples.m in Sources */,
+				BE527E9F1863705B006349E8 /* NSUserDefaultsRACSupportSpec.m in Sources */,
+				5F773DF0169B48830023069D /* NSEnumeratorRACSequenceAdditionsSpec.m in Sources */,
+				D077A172169B79A900057BB1 /* RACEventSpec.m in Sources */,
+				D0A0B01816EAA5CC00C47593 /* NSTextRACSupportSpec.m in Sources */,
+				6E58405F16F3414200F588A6 /* NSObjectRACDeallocatingSpec.m in Sources */,
+				1E893381171647A5009071B0 /* NSObjectRACPropertySubscribingExamples.m in Sources */,
+				880D7A6616F7BB1A004A3361 /* NSObjectRACSelectorSignalSpec.m in Sources */,
+				880D7A6916F7BCC7004A3361 /* RACSubclassObject.m in Sources */,
+				5FDC350F1736F81900792E52 /* NSStringRACKeyPathUtilitiesSpec.m in Sources */,
+				D075A72A17BCB7E100C24FB7 /* RACControlCommandExamples.m in Sources */,
+				88302BFD1762A9E6003633BD /* RACTestExampleScheduler.m in Sources */,
+				4925E806181BCC71000B2FEE /* NSControllerRACSupportSpec.m in Sources */,
+				8884DD651756ACF600F6C379 /* RACSignalStartExamples.m in Sources */,
+				88302C2E1762C180003633BD /* RACTargetQueueSchedulerSpec.m in Sources */,
+				D0A0E226176A84DB007273ED /* RACDisposableSpec.m in Sources */,
+				D011F9D01782AFD400EE7E38 /* NSObjectRACAppKitBindingsSpec.m in Sources */,
+				D07200251788C57200987F70 /* RACTestSchedulerSpec.m in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		88F440A7153DAC820097B4C3 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				27A887D11703DC6800040001 /* UIBarButtonItem+RACCommandSupport.m in Sources */,
+				8882D4601673B0450080E7CD /* RACBlockTrampoline.m in Sources */,
+				88F440BA153DAD570097B4C3 /* RACCommand.m in Sources */,
+				88F440BC153DAD5A0097B4C3 /* RACSubscriber.m in Sources */,
+				88F440BD153DAD5C0097B4C3 /* RACSignal.m in Sources */,
+				88F440CF153DAD850097B4C3 /* NSObject+RACPropertySubscribing.m in Sources */,
+				ACB0EAF31797DDD400942FFC /* UIAlertView+RACSignalSupport.m in Sources */,
+				88F440CE153DAD830097B4C3 /* NSObject+RACKVOWrapper.m in Sources */,
+				88F440C1153DAD640097B4C3 /* RACReplaySubject.m in Sources */,
+				88F440C0153DAD630097B4C3 /* RACSubject.m in Sources */,
+				88F440C6153DAD6E0097B4C3 /* RACScopedDisposable.m in Sources */,
+				88F440C3153DAD690097B4C3 /* RACBehaviorSubject.m in Sources */,
+				88F440C9153DAD740097B4C3 /* RACUnit.m in Sources */,
+				88F440CB153DAD780097B4C3 /* RACScheduler.m in Sources */,
+				88F440CA153DAD760097B4C3 /* RACTuple.m in Sources */,
+				88F440C5153DAD6C0097B4C3 /* RACDisposable.m in Sources */,
+				D090768317FBEADE00EB087A /* NSURLConnection+RACSupport.m in Sources */,
+				88F44263153DC2C70097B4C3 /* UIControl+RACSignalSupport.m in Sources */,
+				886F702C1551CF9D0045D68B /* RACGroupedSignal.m in Sources */,
+				88F44267153DCAC50097B4C3 /* UITextField+RACSignalSupport.m in Sources */,
+				A1FCC27715666AA3008C9686 /* UITextView+RACSignalSupport.m in Sources */,
+				D03525D917E2FAAD0099CBAB /* RACSignalProvider.d in Sources */,
+				A1FCC375156754A7008C9686 /* RACObjCRuntime.m in Sources */,
+				A1FCC37B1567DED0008C9686 /* RACDelegateProxy.m in Sources */,
+				D0DFBCCF15DD6D40009DADB3 /* RACBacktrace.m in Sources */,
+				D0D910D115F915BD00AD2DDA /* RACSignal+Operations.m in Sources */,
+				88FC735816114F9C00F8A774 /* RACSubscriptingAssignmentTrampoline.m in Sources */,
+				CD11C6F418714CD0007C7CFD /* UITableViewHeaderFooterView+RACSignalSupport.m in Sources */,
+				886CEAE5163DE942007632D1 /* NSObject+RACLifting.m in Sources */,
+				887ACDAA165878A8009190AD /* NSInvocation+RACTypeParsing.m in Sources */,
+				D0E9676E1641EF9C00FCFF06 /* NSArray+RACSequenceAdditions.m in Sources */,
+				D013A3E21807B7450072B6CE /* RACEmptySignal.m in Sources */,
+				D0E967721641EF9C00FCFF06 /* NSDictionary+RACSequenceAdditions.m in Sources */,
+				D0E967761641EF9C00FCFF06 /* NSOrderedSet+RACSequenceAdditions.m in Sources */,
+				D0E9677A1641EF9C00FCFF06 /* NSSet+RACSequenceAdditions.m in Sources */,
+				D0E9677E1641EF9C00FCFF06 /* NSString+RACSequenceAdditions.m in Sources */,
+				D0E967821641EF9C00FCFF06 /* RACArraySequence.m in Sources */,
+				D0E967861641EF9C00FCFF06 /* RACDynamicSequence.m in Sources */,
+				D028DB88179E616700D1042F /* UITableViewCell+RACSignalSupport.m in Sources */,
+				BE527E9718636F7F006349E8 /* NSUserDefaults+RACSupport.m in Sources */,
+				D0E9678A1641EF9C00FCFF06 /* RACEmptySequence.m in Sources */,
+				D0E9678E1641EF9C00FCFF06 /* RACSequence.m in Sources */,
+				D0E967921641EF9C00FCFF06 /* RACStringSequence.m in Sources */,
+				D013A3F31807B9690072B6CE /* RACDynamicSignal.m in Sources */,
+				D0D487041642550100DD7605 /* RACStream.m in Sources */,
+				D013A3DA1807B5ED0072B6CE /* RACErrorSignal.m in Sources */,
+				D0EE284E164D906B006954A4 /* RACSignalSequence.m in Sources */,
+				74F1731C186024A900BC937C /* NSIndexSet+RACSequenceAdditions.m in Sources */,
+				881E86A51669304800667F7B /* RACCompoundDisposable.m in Sources */,
+				881E87AF16695C5600667F7B /* RACQueueScheduler.m in Sources */,
+				881E87B516695EDF00667F7B /* RACImmediateScheduler.m in Sources */,
+				1668028017FE75F900C724B4 /* UICollectionReusableView+RACSignalSupport.m in Sources */,
+				881E87C71669636000667F7B /* RACSubscriptionScheduler.m in Sources */,
+				5F45A888168CFA3E00B58A2B /* RACKVOChannel.m in Sources */,
+				D028DB77179E53CB00D1042F /* RACSerialDisposable.m in Sources */,
+				5F6FE8561692568A00A8D7A6 /* RACChannel.m in Sources */,
+				88C5A027169246140045EF05 /* RACMulticastConnection.m in Sources */,
+				5F9743FA1694A2460024EB82 /* RACEagerSequence.m in Sources */,
+				5F773DED169B46670023069D /* NSEnumerator+RACSequenceAdditions.m in Sources */,
+				D077A170169B740200057BB1 /* RACEvent.m in Sources */,
+				8837EA1916A5A33300FC3CDF /* RACKVOTrampoline.m in Sources */,
+				6E58405D16F22F7800F588A6 /* NSObject+RACDeallocating.m in Sources */,
+				880D7A5D16F7B351004A3361 /* NSObject+RACSelectorSignal.m in Sources */,
+				D0307EE01731AAE100D83211 /* RACTupleSequence.m in Sources */,
+				D07CD7191731BA3900DE2394 /* RACUnarySequence.m in Sources */,
+				554D9E5E181064E200F21262 /* UIRefreshControl+RACCommandSupport.m in Sources */,
+				1EC06B18173CB04000365258 /* UIGestureRecognizer+RACSignalSupport.m in Sources */,
+				5FDC35061736F54700792E52 /* NSString+RACKeyPathUtilities.m in Sources */,
+				D0D243BE1741FA13004359C6 /* NSObject+RACDescription.m in Sources */,
+				5EE9A7941760D61300EAF5A2 /* UIButton+RACCommandSupport.m in Sources */,
+				882D071F17615139009EDA69 /* RACTargetQueueScheduler.m in Sources */,
+				D0A0E231176A8CD6007273ED /* RACPassthroughSubscriber.m in Sources */,
+				557A4B5B177648C7008EF796 /* UIActionSheet+RACSignalSupport.m in Sources */,
+				D05F9D3817984EC000FD7982 /* EXTRuntimeExtensions.m in Sources */,
+				D009307C1788AB7B00EE7E8B /* RACTestScheduler.m in Sources */,
+				5F70B2B017AB1829009AEDF9 /* UIDatePicker+RACSignalSupport.m in Sources */,
+				5F70B2BF17AB1857009AEDF9 /* UISegmentedControl+RACSignalSupport.m in Sources */,
+				5F70B2C117AB1857009AEDF9 /* UISlider+RACSignalSupport.m in Sources */,
+				5F70B2C317AB1857009AEDF9 /* UIStepper+RACSignalSupport.m in Sources */,
+				5F70B2C517AB1857009AEDF9 /* UISwitch+RACSignalSupport.m in Sources */,
+				5F016DF717B10AA8002EEC69 /* UIControl+RACSignalSupportPrivate.m in Sources */,
+				D013A3EA1807B7C30072B6CE /* RACReturnSignal.m in Sources */,
+				D020F3DC17F6A3E40092BED2 /* RACCompoundDisposableProvider.d in Sources */,
+				7479F6E9186177D200575CDB /* RACIndexSetSequence.m in Sources */,
+				55C39DE817F1EC6E006DC60C /* NSData+RACSupport.m in Sources */,
+				55C39DE917F1EC6E006DC60C /* NSFileHandle+RACSupport.m in Sources */,
+				55C39DEA17F1EC6E006DC60C /* NSNotificationCenter+RACSupport.m in Sources */,
+				55C39DEB17F1EC6E006DC60C /* NSString+RACSupport.m in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		D05AD39017F2D56F0080895B /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				D05AD3CF17F2DB100080895B /* NSInvocation+RACTypeParsing.m in Sources */,
+				D05AD3F117F2DB4F0080895B /* RACDynamicSequence.m in Sources */,
+				D05AD3F517F2DB4F0080895B /* RACSignalSequence.m in Sources */,
+				D05AD3C217F2DB100080895B /* RACBlockTrampoline.m in Sources */,
+				D05AD41917F2DB6A0080895B /* NSSet+RACSequenceAdditions.m in Sources */,
+				D090768417FBEADE00EB087A /* NSURLConnection+RACSupport.m in Sources */,
+				D05AD3CE17F2DB100080895B /* NSObject+RACLifting.m in Sources */,
+				D05AD3FE17F2DB5D0080895B /* RACQueueScheduler.m in Sources */,
+				D05AD42517F2DB6E0080895B /* NSText+RACSignalSupport.m in Sources */,
+				D05AD43017F2DB840080895B /* RACValueTransformer.m in Sources */,
+				D070CBC517FB5E370017F121 /* RACCompoundDisposableProvider.d in Sources */,
+				D05AD3F217F2DB4F0080895B /* RACEagerSequence.m in Sources */,
+				D05AD3F617F2DB4F0080895B /* RACTupleSequence.m in Sources */,
+				D05AD3E917F2DB230080895B /* RACSerialDisposable.m in Sources */,
+				D05AD42117F2DB6E0080895B /* NSControl+RACTextSignalSupport.m in Sources */,
+				D05AD40E17F2DB6A0080895B /* NSEnumerator+RACSequenceAdditions.m in Sources */,
+				D05AD41B17F2DB6A0080895B /* NSString+RACSequenceAdditions.m in Sources */,
+				D05AD43217F2DBCA0080895B /* RACSignalProvider.d in Sources */,
+				D05AD42D17F2DB840080895B /* RACKVOTrampoline.m in Sources */,
+				D05AD3D517F2DB1D0080895B /* RACSignal+Operations.m in Sources */,
+				BE527E9818636F7F006349E8 /* NSUserDefaults+RACSupport.m in Sources */,
+				D05AD41317F2DB6A0080895B /* NSObject+RACDescription.m in Sources */,
+				D05AD3CA17F2DB100080895B /* RACSubscriptingAssignmentTrampoline.m in Sources */,
+				D05AD3E717F2DB230080895B /* RACCompoundDisposable.m in Sources */,
+				D05AD3DD17F2DB1D0080895B /* RACSubject.m in Sources */,
+				D013A3E31807B7450072B6CE /* RACEmptySignal.m in Sources */,
+				D05AD3F417F2DB4F0080895B /* RACStringSequence.m in Sources */,
+				D05AD40C17F2DB6A0080895B /* NSDictionary+RACSequenceAdditions.m in Sources */,
+				D05AD41F17F2DB6E0080895B /* NSControl+RACCommandSupport.m in Sources */,
+				D05AD41517F2DB6A0080895B /* NSObject+RACSelectorSignal.m in Sources */,
+				D05AD3C817F2DB100080895B /* RACBacktrace.m in Sources */,
+				D05AD41217F2DB6A0080895B /* NSNotificationCenter+RACSupport.m in Sources */,
+				D05AD3D917F2DB1D0080895B /* RACMulticastConnection.m in Sources */,
+				D05AD43117F2DB950080895B /* RACObjCRuntime.m in Sources */,
+				D05AD3DB17F2DB1D0080895B /* RACGroupedSignal.m in Sources */,
+				D05AD3F017F2DB4F0080895B /* RACArraySequence.m in Sources */,
+				D05AD3E517F2DB230080895B /* RACScopedDisposable.m in Sources */,
+				D05AD40417F2DB5D0080895B /* RACSubscriptionScheduler.m in Sources */,
+				D05AD42917F2DB840080895B /* RACKVOChannel.m in Sources */,
+				D05AD42C17F2DB840080895B /* NSString+RACKeyPathUtilities.m in Sources */,
+				D05AD42717F2DB840080895B /* RACChannel.m in Sources */,
+				D05AD3FB17F2DB5D0080895B /* RACScheduler.m in Sources */,
+				D05AD3EB17F2DB270080895B /* RACCommand.m in Sources */,
+				D05AD3D117F2DB100080895B /* RACStream.m in Sources */,
+				D05AD3F717F2DB4F0080895B /* RACUnarySequence.m in Sources */,
+				D05AD3D317F2DB1D0080895B /* RACSignal.m in Sources */,
+				D05AD42F17F2DB840080895B /* NSObject+RACPropertySubscribing.m in Sources */,
+				D05AD3F317F2DB4F0080895B /* RACEmptySequence.m in Sources */,
+				D05AD42317F2DB6E0080895B /* NSObject+RACAppKitBindings.m in Sources */,
+				D05AD40817F2DB6A0080895B /* NSArray+RACSequenceAdditions.m in Sources */,
+				D05AD40017F2DB5D0080895B /* RACTargetQueueScheduler.m in Sources */,
+				D05AD41717F2DB6A0080895B /* NSOrderedSet+RACSequenceAdditions.m in Sources */,
+				D05AD40617F2DB5D0080895B /* RACTestScheduler.m in Sources */,
+				D05AD3EF17F2DB4F0080895B /* RACSequence.m in Sources */,
+				D05AD3BF17F2DA2A0080895B /* RACSubscriber.m in Sources */,
+				D013A3EB1807B7C30072B6CE /* RACReturnSignal.m in Sources */,
+				D05AD3DF17F2DB1D0080895B /* RACReplaySubject.m in Sources */,
+				D05AD3C417F2DB100080895B /* RACUnit.m in Sources */,
+				D05AD41017F2DB6A0080895B /* NSFileHandle+RACSupport.m in Sources */,
+				D05AD41D17F2DB6A0080895B /* NSString+RACSupport.m in Sources */,
+				D05AD3E317F2DB230080895B /* RACDisposable.m in Sources */,
+				D05AD40217F2DB5D0080895B /* RACImmediateScheduler.m in Sources */,
+				D05AD3CC17F2DB100080895B /* NSObject+RACDeallocating.m in Sources */,
+				74F1731D186024A900BC937C /* NSIndexSet+RACSequenceAdditions.m in Sources */,
+				D05AD40A17F2DB6A0080895B /* NSData+RACSupport.m in Sources */,
+				D013A3DB1807B5ED0072B6CE /* RACErrorSignal.m in Sources */,
+				7479F6EA186177D200575CDB /* RACIndexSetSequence.m in Sources */,
+				D05AD42B17F2DB840080895B /* NSObject+RACKVOWrapper.m in Sources */,
+				D05AD3E117F2DB1D0080895B /* RACBehaviorSubject.m in Sources */,
+				D05AD3D717F2DB1D0080895B /* RACEvent.m in Sources */,
+				D05AD3C117F2DB100080895B /* RACPassthroughSubscriber.m in Sources */,
+				D05AD3C617F2DB100080895B /* RACTuple.m in Sources */,
+				D013A3F41807B9690072B6CE /* RACDynamicSignal.m in Sources */,
+				D049804217F91F42001EE042 /* EXTRuntimeExtensions.m in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin PBXTargetDependency section */
+		1860F436177C91B500C7B3C9 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 1860F411177C91B500C7B3C9 /* ReactiveCocoa-iOS-UIKitTestHost */;
+			targetProxy = 1860F435177C91B500C7B3C9 /* PBXContainerItemProxy */;
+		};
+		88037FDB150564E9001A5B19 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 88037F8215056328001A5B19 /* ReactiveCocoa */;
+			targetProxy = 88037FDA150564E9001A5B19 /* PBXContainerItemProxy */;
+		};
+		D0ED9DB617501806003859A6 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 88F440AA153DAC820097B4C3 /* ReactiveCocoa-iOS */;
+			targetProxy = D0ED9DB517501806003859A6 /* PBXContainerItemProxy */;
+		};
+		D0F117C3179F0A91006CE68F /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 88F440AA153DAC820097B4C3 /* ReactiveCocoa-iOS */;
+			targetProxy = D0F117C2179F0A91006CE68F /* PBXContainerItemProxy */;
+		};
+/* End PBXTargetDependency section */
+
+/* Begin PBXVariantGroup section */
+		1860F41C177C91B500C7B3C9 /* InfoPlist.strings */ = {
+			isa = PBXVariantGroup;
+			children = (
+				1860F41D177C91B500C7B3C9 /* en */,
+			);
+			name = InfoPlist.strings;
+			sourceTree = "<group>";
+		};
+		1860F43A177C91B500C7B3C9 /* InfoPlist.strings */ = {
+			isa = PBXVariantGroup;
+			children = (
+				1860F43B177C91B500C7B3C9 /* en */,
+			);
+			name = InfoPlist.strings;
+			sourceTree = "<group>";
+		};
+		88CDF7C815000FCE00163A9F /* InfoPlist.strings */ = {
+			isa = PBXVariantGroup;
+			children = (
+				88CDF7C915000FCE00163A9F /* en */,
+			);
+			name = InfoPlist.strings;
+			sourceTree = "<group>";
+		};
+		88CDF7E515000FCF00163A9F /* InfoPlist.strings */ = {
+			isa = PBXVariantGroup;
+			children = (
+				88CDF7E615000FCF00163A9F /* en */,
+			);
+			name = InfoPlist.strings;
+			sourceTree = "<group>";
+		};
+/* End PBXVariantGroup section */
+
+/* Begin XCBuildConfiguration section */
+		1860F440177C91B500C7B3C9 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = D094E45D17775B1000906BF7 /* iOS-Application.xcconfig */;
+			buildSettings = {
+				FRAMEWORK_SEARCH_PATHS = (
+					"\"$(SDKROOT)/Developer/Library/Frameworks\"",
+					"\"$(DEVELOPER_LIBRARY_DIR)/Frameworks\"",
+				);
+				GCC_PREFIX_HEADER = "ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch";
+				HEADER_SEARCH_PATHS = (
+					"\"$(PROJECT_DIR)/../external/specta/src\"",
+					"\"$(PROJECT_DIR)/../external/expecta/src\"/**",
+					"$(inherited)",
+				);
+				INFOPLIST_FILE = "ReactiveCocoaTests/UIKit/UIKitTestHost/ReactiveCocoa-iOS-UIKitTestHost-Info.plist";
+				OTHER_LDFLAGS = "-all_load";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				WRAPPER_EXTENSION = app;
+			};
+			name = Debug;
+		};
+		1860F441177C91B500C7B3C9 /* Test */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = D094E45D17775B1000906BF7 /* iOS-Application.xcconfig */;
+			buildSettings = {
+				FRAMEWORK_SEARCH_PATHS = (
+					"\"$(SDKROOT)/Developer/Library/Frameworks\"",
+					"\"$(DEVELOPER_LIBRARY_DIR)/Frameworks\"",
+				);
+				GCC_PREFIX_HEADER = "ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch";
+				HEADER_SEARCH_PATHS = (
+					"\"$(PROJECT_DIR)/../external/specta/src\"",
+					"\"$(PROJECT_DIR)/../external/expecta/src\"/**",
+					"$(inherited)",
+				);
+				INFOPLIST_FILE = "ReactiveCocoaTests/UIKit/UIKitTestHost/ReactiveCocoa-iOS-UIKitTestHost-Info.plist";
+				OTHER_LDFLAGS = "-all_load";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				WRAPPER_EXTENSION = app;
+			};
+			name = Test;
+		};
+		1860F442177C91B500C7B3C9 /* Release */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = D094E45D17775B1000906BF7 /* iOS-Application.xcconfig */;
+			buildSettings = {
+				FRAMEWORK_SEARCH_PATHS = (
+					"\"$(SDKROOT)/Developer/Library/Frameworks\"",
+					"\"$(DEVELOPER_LIBRARY_DIR)/Frameworks\"",
+				);
+				GCC_PREFIX_HEADER = "ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch";
+				HEADER_SEARCH_PATHS = (
+					"\"$(PROJECT_DIR)/../external/specta/src\"",
+					"\"$(PROJECT_DIR)/../external/expecta/src\"/**",
+					"$(inherited)",
+				);
+				INFOPLIST_FILE = "ReactiveCocoaTests/UIKit/UIKitTestHost/ReactiveCocoa-iOS-UIKitTestHost-Info.plist";
+				OTHER_LDFLAGS = "-all_load";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				WRAPPER_EXTENSION = app;
+			};
+			name = Release;
+		};
+		1860F443177C91B500C7B3C9 /* Profile */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = D094E45D17775B1000906BF7 /* iOS-Application.xcconfig */;
+			buildSettings = {
+				FRAMEWORK_SEARCH_PATHS = (
+					"\"$(SDKROOT)/Developer/Library/Frameworks\"",
+					"\"$(DEVELOPER_LIBRARY_DIR)/Frameworks\"",
+				);
+				GCC_PREFIX_HEADER = "ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch";
+				HEADER_SEARCH_PATHS = (
+					"\"$(PROJECT_DIR)/../external/specta/src\"",
+					"\"$(PROJECT_DIR)/../external/expecta/src\"/**",
+					"$(inherited)",
+				);
+				INFOPLIST_FILE = "ReactiveCocoaTests/UIKit/UIKitTestHost/ReactiveCocoa-iOS-UIKitTestHost-Info.plist";
+				OTHER_LDFLAGS = "-all_load";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				WRAPPER_EXTENSION = app;
+			};
+			name = Profile;
+		};
+		1860F444177C91B500C7B3C9 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = D094E45D17775B1000906BF7 /* iOS-Application.xcconfig */;
+			buildSettings = {
+				BUNDLE_LOADER = "$(BUILT_PRODUCTS_DIR)/ReactiveCocoa-iOS-UIKitTestHost.app/ReactiveCocoa-iOS-UIKitTestHost";
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				FRAMEWORK_SEARCH_PATHS = (
+					"\"$(SDKROOT)/Developer/Library/Frameworks\"",
+					"\"$(DEVELOPER_LIBRARY_DIR)/Frameworks\"",
+				);
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_PREFIX_HEADER = "ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch";
+				HEADER_SEARCH_PATHS = (
+					"\"$(PROJECT_DIR)/../external/specta/src\"",
+					"\"$(PROJECT_DIR)/../external/expecta/src\"/**",
+					"$(inherited)",
+					"\"$(SDKROOT)/Developer/Library/Frameworks\"",
+					"\"$(DEVELOPER_LIBRARY_DIR)/Frameworks\"\n\n//:configuration",
+				);
+				INFOPLIST_FILE = "ReactiveCocoaTests/UIKit/UIKitTests/ReactiveCocoa-iOS-UIKitTestHostTests-Info.plist";
+				ONLY_ACTIVE_ARCH = YES;
+				OTHER_LDFLAGS = "-all_load";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				TEST_HOST = "$(BUNDLE_LOADER)";
+				WRAPPER_EXTENSION = octest;
+			};
+			name = Debug;
+		};
+		1860F445177C91B500C7B3C9 /* Test */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = D094E45D17775B1000906BF7 /* iOS-Application.xcconfig */;
+			buildSettings = {
+				BUNDLE_LOADER = "$(BUILT_PRODUCTS_DIR)/ReactiveCocoa-iOS-UIKitTestHost.app/ReactiveCocoa-iOS-UIKitTestHost";
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				FRAMEWORK_SEARCH_PATHS = (
+					"\"$(SDKROOT)/Developer/Library/Frameworks\"",
+					"\"$(DEVELOPER_LIBRARY_DIR)/Frameworks\"",
+				);
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_PREFIX_HEADER = "ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch";
+				HEADER_SEARCH_PATHS = (
+					"\"$(PROJECT_DIR)/../external/specta/src\"",
+					"\"$(PROJECT_DIR)/../external/expecta/src\"/**",
+					"$(inherited)",
+					"\"$(SDKROOT)/Developer/Library/Frameworks\"",
+					"\"$(DEVELOPER_LIBRARY_DIR)/Frameworks\"\n\n//:configuration",
+				);
+				INFOPLIST_FILE = "ReactiveCocoaTests/UIKit/UIKitTests/ReactiveCocoa-iOS-UIKitTestHostTests-Info.plist";
+				ONLY_ACTIVE_ARCH = YES;
+				OTHER_LDFLAGS = "-all_load";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				TEST_HOST = "$(BUNDLE_LOADER)";
+				WRAPPER_EXTENSION = octest;
+			};
+			name = Test;
+		};
+		1860F446177C91B500C7B3C9 /* Release */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = D094E45D17775B1000906BF7 /* iOS-Application.xcconfig */;
+			buildSettings = {
+				BUNDLE_LOADER = "$(BUILT_PRODUCTS_DIR)/ReactiveCocoa-iOS-UIKitTestHost.app/ReactiveCocoa-iOS-UIKitTestHost";
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				FRAMEWORK_SEARCH_PATHS = (
+					"\"$(SDKROOT)/Developer/Library/Frameworks\"",
+					"\"$(DEVELOPER_LIBRARY_DIR)/Frameworks\"",
+				);
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_PREFIX_HEADER = "ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch";
+				HEADER_SEARCH_PATHS = (
+					"\"$(PROJECT_DIR)/../external/specta/src\"",
+					"\"$(PROJECT_DIR)/../external/expecta/src\"/**",
+					"$(inherited)",
+					"\"$(SDKROOT)/Developer/Library/Frameworks\"",
+					"\"$(DEVELOPER_LIBRARY_DIR)/Frameworks\"\n\n//:configuration",
+				);
+				INFOPLIST_FILE = "ReactiveCocoaTests/UIKit/UIKitTests/ReactiveCocoa-iOS-UIKitTestHostTests-Info.plist";
+				OTHER_LDFLAGS = "-all_load";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				TEST_HOST = "$(BUNDLE_LOADER)";
+				WRAPPER_EXTENSION = octest;
+			};
+			name = Release;
+		};
+		1860F447177C91B500C7B3C9 /* Profile */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = D094E45D17775B1000906BF7 /* iOS-Application.xcconfig */;
+			buildSettings = {
+				BUNDLE_LOADER = "$(BUILT_PRODUCTS_DIR)/ReactiveCocoa-iOS-UIKitTestHost.app/ReactiveCocoa-iOS-UIKitTestHost";
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				FRAMEWORK_SEARCH_PATHS = (
+					"\"$(SDKROOT)/Developer/Library/Frameworks\"",
+					"\"$(DEVELOPER_LIBRARY_DIR)/Frameworks\"",
+				);
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_PREFIX_HEADER = "ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch";
+				HEADER_SEARCH_PATHS = (
+					"\"$(PROJECT_DIR)/../external/specta/src\"",
+					"\"$(PROJECT_DIR)/../external/expecta/src\"/**",
+					"$(inherited)",
+					"\"$(SDKROOT)/Developer/Library/Frameworks\"",
+					"\"$(DEVELOPER_LIBRARY_DIR)/Frameworks\"\n\n//:configuration",
+				);
+				INFOPLIST_FILE = "ReactiveCocoaTests/UIKit/UIKitTests/ReactiveCocoa-iOS-UIKitTestHostTests-Info.plist";
+				OTHER_LDFLAGS = "-all_load";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				TEST_HOST = "$(BUNDLE_LOADER)";
+				WRAPPER_EXTENSION = octest;
+			};
+			name = Profile;
+		};
+		5FAF5233174D4C2000CAC810 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = D094E45D17775B1000906BF7 /* iOS-Application.xcconfig */;
+			buildSettings = {
+				FRAMEWORK_SEARCH_PATHS = (
+					"\"$(SDKROOT)/Developer/Library/Frameworks\"",
+					"\"$(DEVELOPER_LIBRARY_DIR)/Frameworks\"",
+				);
+				GCC_PREFIX_HEADER = "ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch";
+				HEADER_SEARCH_PATHS = (
+					"\"$(PROJECT_DIR)/../external/specta/src\"",
+					"\"$(PROJECT_DIR)/../external/expecta/src\"/**",
+					"$(inherited)",
+				);
+				INFOPLIST_FILE = "ReactiveCocoaTests/ReactiveCocoaTests-Info.plist";
+				OTHER_LDFLAGS = "-ObjC";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				WRAPPER_EXTENSION = octest;
+			};
+			name = Debug;
+		};
+		5FAF5234174D4C2000CAC810 /* Test */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = D094E45D17775B1000906BF7 /* iOS-Application.xcconfig */;
+			buildSettings = {
+				FRAMEWORK_SEARCH_PATHS = (
+					"\"$(SDKROOT)/Developer/Library/Frameworks\"",
+					"\"$(DEVELOPER_LIBRARY_DIR)/Frameworks\"",
+				);
+				GCC_PREFIX_HEADER = "ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch";
+				HEADER_SEARCH_PATHS = (
+					"\"$(PROJECT_DIR)/../external/specta/src\"",
+					"\"$(PROJECT_DIR)/../external/expecta/src\"/**",
+					"$(inherited)",
+				);
+				INFOPLIST_FILE = "ReactiveCocoaTests/ReactiveCocoaTests-Info.plist";
+				OTHER_LDFLAGS = "-ObjC";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				WRAPPER_EXTENSION = octest;
+			};
+			name = Test;
+		};
+		5FAF5235174D4C2000CAC810 /* Release */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = D094E45D17775B1000906BF7 /* iOS-Application.xcconfig */;
+			buildSettings = {
+				FRAMEWORK_SEARCH_PATHS = (
+					"\"$(SDKROOT)/Developer/Library/Frameworks\"",
+					"\"$(DEVELOPER_LIBRARY_DIR)/Frameworks\"",
+				);
+				GCC_PREFIX_HEADER = "ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch";
+				HEADER_SEARCH_PATHS = (
+					"\"$(PROJECT_DIR)/../external/specta/src\"",
+					"\"$(PROJECT_DIR)/../external/expecta/src\"/**",
+					"$(inherited)",
+				);
+				INFOPLIST_FILE = "ReactiveCocoaTests/ReactiveCocoaTests-Info.plist";
+				OTHER_LDFLAGS = "-ObjC";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				WRAPPER_EXTENSION = octest;
+			};
+			name = Release;
+		};
+		5FAF5236174D4C2000CAC810 /* Profile */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = D094E45D17775B1000906BF7 /* iOS-Application.xcconfig */;
+			buildSettings = {
+				FRAMEWORK_SEARCH_PATHS = (
+					"\"$(SDKROOT)/Developer/Library/Frameworks\"",
+					"\"$(DEVELOPER_LIBRARY_DIR)/Frameworks\"",
+				);
+				GCC_PREFIX_HEADER = "ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch";
+				HEADER_SEARCH_PATHS = (
+					"\"$(PROJECT_DIR)/../external/specta/src\"",
+					"\"$(PROJECT_DIR)/../external/expecta/src\"/**",
+					"$(inherited)",
+				);
+				INFOPLIST_FILE = "ReactiveCocoaTests/ReactiveCocoaTests-Info.plist";
+				OTHER_LDFLAGS = "-ObjC";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				WRAPPER_EXTENSION = octest;
+			};
+			name = Profile;
+		};
+		88037F9015056328001A5B19 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = D094E46417775B1000906BF7 /* Mac-Framework.xcconfig */;
+			buildSettings = {
+				DYLIB_COMPATIBILITY_VERSION = 1;
+				DYLIB_CURRENT_VERSION = 1;
+				FRAMEWORK_VERSION = A;
+				GCC_PREFIX_HEADER = "ReactiveCocoa/ReactiveCocoa-Prefix.pch";
+				INFOPLIST_FILE = "ReactiveCocoa/ReactiveCocoa-Info.plist";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				WRAPPER_EXTENSION = framework;
+			};
+			name = Debug;
+		};
+		88037F9115056328001A5B19 /* Release */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = D094E46417775B1000906BF7 /* Mac-Framework.xcconfig */;
+			buildSettings = {
+				DYLIB_COMPATIBILITY_VERSION = 1;
+				DYLIB_CURRENT_VERSION = 1;
+				FRAMEWORK_VERSION = A;
+				GCC_PREFIX_HEADER = "ReactiveCocoa/ReactiveCocoa-Prefix.pch";
+				INFOPLIST_FILE = "ReactiveCocoa/ReactiveCocoa-Info.plist";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				WRAPPER_EXTENSION = framework;
+			};
+			name = Release;
+		};
+		88997CAA1728912B00C569A6 /* Test */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = D094E45817775B1000906BF7 /* Test.xcconfig */;
+			buildSettings = {
+				ARCHS = "$(ARCHS_STANDARD_64_BIT)";
+				CLANG_WARN_IMPLICIT_SIGN_CONVERSION = YES;
+				GCC_OPTIMIZATION_LEVEL = fast;
+				GCC_WARN_ABOUT_MISSING_NEWLINE = YES;
+				GCC_WARN_STRICT_SELECTOR_MATCH = YES;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 5.0;
+				MACOSX_DEPLOYMENT_TARGET = 10.7;
+				SDKROOT = macosx;
+				TARGETED_DEVICE_FAMILY = "1,2";
+				VALID_ARCHS = x86_64;
+				WARNING_CFLAGS = (
+					"-Werror",
+					"-Wall",
+				);
+			};
+			name = Test;
+		};
+		88997CAB1728912B00C569A6 /* Test */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = D094E46417775B1000906BF7 /* Mac-Framework.xcconfig */;
+			buildSettings = {
+				DYLIB_COMPATIBILITY_VERSION = 1;
+				DYLIB_CURRENT_VERSION = 1;
+				FRAMEWORK_VERSION = A;
+				GCC_PREFIX_HEADER = "ReactiveCocoa/ReactiveCocoa-Prefix.pch";
+				INFOPLIST_FILE = "ReactiveCocoa/ReactiveCocoa-Info.plist";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				WRAPPER_EXTENSION = framework;
+			};
+			name = Test;
+		};
+		88997CAC1728912B00C569A6 /* Test */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = D094E45F17775B1000906BF7 /* iOS-StaticLibrary.xcconfig */;
+			buildSettings = {
+				GCC_PREFIX_HEADER = "ReactiveCocoa/ReactiveCocoa-Prefix.pch";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				PUBLIC_HEADERS_FOLDER_PATH = include/ReactiveCocoa;
+			};
+			name = Test;
+		};
+		88997CAD1728912B00C569A6 /* Test */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = D094E46117775B1000906BF7 /* Mac-Application.xcconfig */;
+			buildSettings = {
+				FRAMEWORK_SEARCH_PATHS = "$(DEVELOPER_LIBRARY_DIR)/Frameworks";
+				GCC_PREFIX_HEADER = "ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch";
+				HEADER_SEARCH_PATHS = (
+					"\"$(PROJECT_DIR)/../external/specta/src\"",
+					"\"$(PROJECT_DIR)/../external/expecta/src\"/**",
+				);
+				INFOPLIST_FILE = "ReactiveCocoaTests/ReactiveCocoaTests-Info.plist";
+				OTHER_LDFLAGS = "-ObjC";
+				PRODUCT_NAME = ReactiveCocoaTests;
+				VALID_ARCHS = x86_64;
+				WRAPPER_EXTENSION = octest;
+			};
+			name = Test;
+		};
+		88CDF7EB15000FCF00163A9F /* Debug */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = D094E45517775B1000906BF7 /* Debug.xcconfig */;
+			buildSettings = {
+				ARCHS = "$(ARCHS_STANDARD_64_BIT)";
+				CLANG_WARN_IMPLICIT_SIGN_CONVERSION = YES;
+				GCC_WARN_ABOUT_MISSING_NEWLINE = YES;
+				GCC_WARN_STRICT_SELECTOR_MATCH = YES;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 5.0;
+				MACOSX_DEPLOYMENT_TARGET = 10.7;
+				SDKROOT = macosx;
+				TARGETED_DEVICE_FAMILY = "1,2";
+				VALID_ARCHS = x86_64;
+				WARNING_CFLAGS = (
+					"-Werror",
+					"-Wall",
+				);
+			};
+			name = Debug;
+		};
+		88CDF7EC15000FCF00163A9F /* Release */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = D094E45717775B1000906BF7 /* Release.xcconfig */;
+			buildSettings = {
+				ARCHS = "$(ARCHS_STANDARD_64_BIT)";
+				CLANG_WARN_IMPLICIT_SIGN_CONVERSION = YES;
+				GCC_WARN_ABOUT_MISSING_NEWLINE = YES;
+				GCC_WARN_STRICT_SELECTOR_MATCH = YES;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 5.0;
+				MACOSX_DEPLOYMENT_TARGET = 10.7;
+				SDKROOT = macosx;
+				TARGETED_DEVICE_FAMILY = "1,2";
+				VALID_ARCHS = x86_64;
+				WARNING_CFLAGS = (
+					"-Werror",
+					"-Wall",
+				);
+			};
+			name = Release;
+		};
+		88CDF7F115000FCF00163A9F /* Debug */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = D094E46117775B1000906BF7 /* Mac-Application.xcconfig */;
+			buildSettings = {
+				FRAMEWORK_SEARCH_PATHS = "$(DEVELOPER_LIBRARY_DIR)/Frameworks";
+				GCC_PREFIX_HEADER = "ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch";
+				HEADER_SEARCH_PATHS = (
+					"\"$(PROJECT_DIR)/../external/specta/src\"",
+					"\"$(PROJECT_DIR)/../external/expecta/src\"/**",
+				);
+				INFOPLIST_FILE = "ReactiveCocoaTests/ReactiveCocoaTests-Info.plist";
+				OTHER_LDFLAGS = "-ObjC";
+				PRODUCT_NAME = ReactiveCocoaTests;
+				VALID_ARCHS = x86_64;
+				WRAPPER_EXTENSION = octest;
+			};
+			name = Debug;
+		};
+		88CDF7F215000FCF00163A9F /* Release */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = D094E46117775B1000906BF7 /* Mac-Application.xcconfig */;
+			buildSettings = {
+				FRAMEWORK_SEARCH_PATHS = "$(DEVELOPER_LIBRARY_DIR)/Frameworks";
+				GCC_PREFIX_HEADER = "ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch";
+				HEADER_SEARCH_PATHS = (
+					"\"$(PROJECT_DIR)/../external/specta/src\"",
+					"\"$(PROJECT_DIR)/../external/expecta/src\"/**",
+				);
+				INFOPLIST_FILE = "ReactiveCocoaTests/ReactiveCocoaTests-Info.plist";
+				OTHER_LDFLAGS = "-ObjC";
+				PRODUCT_NAME = ReactiveCocoaTests;
+				VALID_ARCHS = x86_64;
+				WRAPPER_EXTENSION = octest;
+			};
+			name = Release;
+		};
+		88F440B4153DAC820097B4C3 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = D094E45F17775B1000906BF7 /* iOS-StaticLibrary.xcconfig */;
+			buildSettings = {
+				GCC_PREFIX_HEADER = "ReactiveCocoa/ReactiveCocoa-Prefix.pch";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				PUBLIC_HEADERS_FOLDER_PATH = include/ReactiveCocoa;
+			};
+			name = Debug;
+		};
+		88F440B5153DAC820097B4C3 /* Release */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = D094E45F17775B1000906BF7 /* iOS-StaticLibrary.xcconfig */;
+			buildSettings = {
+				GCC_PREFIX_HEADER = "ReactiveCocoa/ReactiveCocoa-Prefix.pch";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				PUBLIC_HEADERS_FOLDER_PATH = include/ReactiveCocoa;
+			};
+			name = Release;
+		};
+		D05AD3B117F2D5710080895B /* Debug */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = D094E46517775B1000906BF7 /* Mac-StaticLibrary.xcconfig */;
+			buildSettings = {
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				GCC_PREFIX_HEADER = "ReactiveCocoa/ReactiveCocoa-Prefix.pch";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Debug;
+		};
+		D05AD3B217F2D5710080895B /* Test */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = D094E46517775B1000906BF7 /* Mac-StaticLibrary.xcconfig */;
+			buildSettings = {
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				GCC_PREFIX_HEADER = "ReactiveCocoa/ReactiveCocoa-Prefix.pch";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Test;
+		};
+		D05AD3B317F2D5710080895B /* Release */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = D094E46517775B1000906BF7 /* Mac-StaticLibrary.xcconfig */;
+			buildSettings = {
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				GCC_PREFIX_HEADER = "ReactiveCocoa/ReactiveCocoa-Prefix.pch";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Release;
+		};
+		D05AD3B417F2D5710080895B /* Profile */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = D094E46517775B1000906BF7 /* Mac-StaticLibrary.xcconfig */;
+			buildSettings = {
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				GCC_PREFIX_HEADER = "ReactiveCocoa/ReactiveCocoa-Prefix.pch";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Profile;
+		};
+		D095BDD115CB2F9D00E9BB13 /* Profile */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = D094E45617775B1000906BF7 /* Profile.xcconfig */;
+			buildSettings = {
+				ARCHS = "$(ARCHS_STANDARD_64_BIT)";
+				CLANG_WARN_IMPLICIT_SIGN_CONVERSION = YES;
+				GCC_WARN_ABOUT_MISSING_NEWLINE = YES;
+				GCC_WARN_STRICT_SELECTOR_MATCH = YES;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 5.0;
+				MACOSX_DEPLOYMENT_TARGET = 10.7;
+				SDKROOT = macosx;
+				TARGETED_DEVICE_FAMILY = "1,2";
+				VALID_ARCHS = x86_64;
+				WARNING_CFLAGS = (
+					"-Werror",
+					"-Wall",
+				);
+			};
+			name = Profile;
+		};
+		D095BDD215CB2F9D00E9BB13 /* Profile */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = D094E46417775B1000906BF7 /* Mac-Framework.xcconfig */;
+			buildSettings = {
+				DYLIB_COMPATIBILITY_VERSION = 1;
+				DYLIB_CURRENT_VERSION = 1;
+				FRAMEWORK_VERSION = A;
+				GCC_PREFIX_HEADER = "ReactiveCocoa/ReactiveCocoa-Prefix.pch";
+				INFOPLIST_FILE = "ReactiveCocoa/ReactiveCocoa-Info.plist";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				WRAPPER_EXTENSION = framework;
+			};
+			name = Profile;
+		};
+		D095BDD315CB2F9D00E9BB13 /* Profile */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = D094E45F17775B1000906BF7 /* iOS-StaticLibrary.xcconfig */;
+			buildSettings = {
+				GCC_PREFIX_HEADER = "ReactiveCocoa/ReactiveCocoa-Prefix.pch";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				PUBLIC_HEADERS_FOLDER_PATH = include/ReactiveCocoa;
+			};
+			name = Profile;
+		};
+		D095BDD415CB2F9D00E9BB13 /* Profile */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = D094E46117775B1000906BF7 /* Mac-Application.xcconfig */;
+			buildSettings = {
+				FRAMEWORK_SEARCH_PATHS = "$(DEVELOPER_LIBRARY_DIR)/Frameworks";
+				GCC_PREFIX_HEADER = "ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch";
+				HEADER_SEARCH_PATHS = (
+					"\"$(PROJECT_DIR)/../external/specta/src\"",
+					"\"$(PROJECT_DIR)/../external/expecta/src\"/**",
+				);
+				INFOPLIST_FILE = "ReactiveCocoaTests/ReactiveCocoaTests-Info.plist";
+				OTHER_LDFLAGS = "-ObjC";
+				PRODUCT_NAME = ReactiveCocoaTests;
+				VALID_ARCHS = x86_64;
+				WRAPPER_EXTENSION = octest;
+			};
+			name = Profile;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		1860F44C177C91B500C7B3C9 /* Build configuration list for PBXNativeTarget "ReactiveCocoa-iOS-UIKitTestHost" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				1860F440177C91B500C7B3C9 /* Debug */,
+				1860F441177C91B500C7B3C9 /* Test */,
+				1860F442177C91B500C7B3C9 /* Release */,
+				1860F443177C91B500C7B3C9 /* Profile */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		1860F44D177C91B500C7B3C9 /* Build configuration list for PBXNativeTarget "ReactiveCocoa-iOS-UIKitTestHostTests" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				1860F444177C91B500C7B3C9 /* Debug */,
+				1860F445177C91B500C7B3C9 /* Test */,
+				1860F446177C91B500C7B3C9 /* Release */,
+				1860F447177C91B500C7B3C9 /* Profile */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		5FAF523D174D4C2000CAC810 /* Build configuration list for PBXNativeTarget "ReactiveCocoaTests-iOS" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				5FAF5233174D4C2000CAC810 /* Debug */,
+				5FAF5234174D4C2000CAC810 /* Test */,
+				5FAF5235174D4C2000CAC810 /* Release */,
+				5FAF5236174D4C2000CAC810 /* Profile */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		88037F8F15056328001A5B19 /* Build configuration list for PBXNativeTarget "ReactiveCocoa" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				88037F9015056328001A5B19 /* Debug */,
+				88997CAB1728912B00C569A6 /* Test */,
+				88037F9115056328001A5B19 /* Release */,
+				D095BDD215CB2F9D00E9BB13 /* Profile */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		88CDF7B515000FCE00163A9F /* Build configuration list for PBXProject "ReactiveCocoa" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				88CDF7EB15000FCF00163A9F /* Debug */,
+				88997CAA1728912B00C569A6 /* Test */,
+				88CDF7EC15000FCF00163A9F /* Release */,
+				D095BDD115CB2F9D00E9BB13 /* Profile */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		88CDF7F015000FCF00163A9F /* Build configuration list for PBXNativeTarget "ReactiveCocoaTests" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				88CDF7F115000FCF00163A9F /* Debug */,
+				88997CAD1728912B00C569A6 /* Test */,
+				88CDF7F215000FCF00163A9F /* Release */,
+				D095BDD415CB2F9D00E9BB13 /* Profile */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		88F440B3153DAC820097B4C3 /* Build configuration list for PBXNativeTarget "ReactiveCocoa-iOS" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				88F440B4153DAC820097B4C3 /* Debug */,
+				88997CAC1728912B00C569A6 /* Test */,
+				88F440B5153DAC820097B4C3 /* Release */,
+				D095BDD315CB2F9D00E9BB13 /* Profile */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		D05AD3BD17F2D5710080895B /* Build configuration list for PBXNativeTarget "ReactiveCocoa-Mac" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				D05AD3B117F2D5710080895B /* Debug */,
+				D05AD3B217F2D5710080895B /* Test */,
+				D05AD3B317F2D5710080895B /* Release */,
+				D05AD3B417F2D5710080895B /* Profile */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = 88CDF7B215000FCE00163A9F /* Project object */;
+}
diff --git a/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/project.xcworkspace/contents.xcworkspacedata b/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/project.xcworkspace/contents.xcworkspacedata
new file mode 100644
index 0000000..a8ff253
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/project.xcworkspace/contents.xcworkspacedata
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Workspace
+   version = "1.0">
+   <FileRef
+      location = "self:ReactiveCocoa.xcodeproj">
+   </FileRef>
+</Workspace>
diff --git a/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/xcshareddata/xcschemes/ReactiveCocoa-Mac.xcscheme b/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/xcshareddata/xcschemes/ReactiveCocoa-Mac.xcscheme
new file mode 100644
index 0000000..b7efc3f
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/xcshareddata/xcschemes/ReactiveCocoa-Mac.xcscheme
@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "0510"
+   version = "1.3">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "D05AD39317F2D56F0080895B"
+               BuildableName = "libReactiveCocoa-Mac.a"
+               BlueprintName = "ReactiveCocoa-Mac"
+               ReferencedContainer = "container:ReactiveCocoa.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      buildConfiguration = "Debug">
+      <Testables>
+         <TestableReference
+            skipped = "NO">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "D05AD3A117F2D5700080895B"
+               BuildableName = "ReactiveCocoa-MacTests.xctest"
+               BlueprintName = "ReactiveCocoa-MacTests"
+               ReferencedContainer = "container:ReactiveCocoa.xcodeproj">
+            </BuildableReference>
+         </TestableReference>
+      </Testables>
+   </TestAction>
+   <LaunchAction
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      buildConfiguration = "Debug"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      allowLocationSimulation = "YES">
+      <AdditionalOptions>
+      </AdditionalOptions>
+   </LaunchAction>
+   <ProfileAction
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      buildConfiguration = "Release"
+      debugDocumentVersioning = "YES">
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>
diff --git a/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/xcshareddata/xcschemes/ReactiveCocoa-iOS-UIKitTestHost.xcscheme b/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/xcshareddata/xcschemes/ReactiveCocoa-iOS-UIKitTestHost.xcscheme
new file mode 100644
index 0000000..306864a
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/xcshareddata/xcschemes/ReactiveCocoa-iOS-UIKitTestHost.xcscheme
@@ -0,0 +1,110 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "0500"
+   version = "1.3">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "1860F411177C91B500C7B3C9"
+               BuildableName = "ReactiveCocoa-iOS-UIKitTestHost.app"
+               BlueprintName = "ReactiveCocoa-iOS-UIKitTestHost"
+               ReferencedContainer = "container:ReactiveCocoa.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "NO"
+            buildForArchiving = "NO"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "1860F42F177C91B500C7B3C9"
+               BuildableName = "ReactiveCocoa-iOS-UIKitTestHostTests.octest"
+               BlueprintName = "ReactiveCocoa-iOS-UIKitTestHostTests"
+               ReferencedContainer = "container:ReactiveCocoa.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      buildConfiguration = "Test">
+      <Testables>
+         <TestableReference
+            skipped = "NO">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "1860F42F177C91B500C7B3C9"
+               BuildableName = "ReactiveCocoa-iOS-UIKitTestHostTests.octest"
+               BlueprintName = "ReactiveCocoa-iOS-UIKitTestHostTests"
+               ReferencedContainer = "container:ReactiveCocoa.xcodeproj">
+            </BuildableReference>
+         </TestableReference>
+      </Testables>
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "1860F411177C91B500C7B3C9"
+            BuildableName = "ReactiveCocoa-iOS-UIKitTestHost.app"
+            BlueprintName = "ReactiveCocoa-iOS-UIKitTestHost"
+            ReferencedContainer = "container:ReactiveCocoa.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+   </TestAction>
+   <LaunchAction
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      buildConfiguration = "Debug"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      allowLocationSimulation = "YES">
+      <BuildableProductRunnable>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "1860F411177C91B500C7B3C9"
+            BuildableName = "ReactiveCocoa-iOS-UIKitTestHost.app"
+            BlueprintName = "ReactiveCocoa-iOS-UIKitTestHost"
+            ReferencedContainer = "container:ReactiveCocoa.xcodeproj">
+         </BuildableReference>
+      </BuildableProductRunnable>
+      <AdditionalOptions>
+      </AdditionalOptions>
+   </LaunchAction>
+   <ProfileAction
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      buildConfiguration = "Profile"
+      debugDocumentVersioning = "YES">
+      <BuildableProductRunnable>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "1860F411177C91B500C7B3C9"
+            BuildableName = "ReactiveCocoa-iOS-UIKitTestHost.app"
+            BlueprintName = "ReactiveCocoa-iOS-UIKitTestHost"
+            ReferencedContainer = "container:ReactiveCocoa.xcodeproj">
+         </BuildableReference>
+      </BuildableProductRunnable>
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>
diff --git a/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/xcshareddata/xcschemes/ReactiveCocoa-iOS.xcscheme b/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/xcshareddata/xcschemes/ReactiveCocoa-iOS.xcscheme
new file mode 100644
index 0000000..a31da25
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/xcshareddata/xcschemes/ReactiveCocoa-iOS.xcscheme
@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "0510"
+   version = "1.3">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "88F440AA153DAC820097B4C3"
+               BuildableName = "libReactiveCocoa-iOS.a"
+               BlueprintName = "ReactiveCocoa-iOS"
+               ReferencedContainer = "container:ReactiveCocoa.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "NO"
+            buildForArchiving = "NO"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "5FAF5222174D4C2000CAC810"
+               BuildableName = "ReactiveCocoaTests-iOS.octest"
+               BlueprintName = "ReactiveCocoaTests-iOS"
+               ReferencedContainer = "container:ReactiveCocoa.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      buildConfiguration = "Test">
+      <Testables>
+         <TestableReference
+            skipped = "NO">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "5FAF5222174D4C2000CAC810"
+               BuildableName = "ReactiveCocoaTests-iOS.octest"
+               BlueprintName = "ReactiveCocoaTests-iOS"
+               ReferencedContainer = "container:ReactiveCocoa.xcodeproj">
+            </BuildableReference>
+         </TestableReference>
+      </Testables>
+   </TestAction>
+   <LaunchAction
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      buildConfiguration = "Debug"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      allowLocationSimulation = "YES">
+      <AdditionalOptions>
+      </AdditionalOptions>
+   </LaunchAction>
+   <ProfileAction
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      buildConfiguration = "Profile"
+      debugDocumentVersioning = "YES">
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>
diff --git a/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/xcshareddata/xcschemes/ReactiveCocoa.xcscheme b/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/xcshareddata/xcschemes/ReactiveCocoa.xcscheme
new file mode 100644
index 0000000..12209cd
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/xcshareddata/xcschemes/ReactiveCocoa.xcscheme
@@ -0,0 +1,99 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "0510"
+   version = "1.3">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "88037F8215056328001A5B19"
+               BuildableName = "ReactiveCocoa.framework"
+               BlueprintName = "ReactiveCocoa"
+               ReferencedContainer = "container:ReactiveCocoa.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "NO"
+            buildForArchiving = "NO"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "88CDF7DB15000FCF00163A9F"
+               BuildableName = "ReactiveCocoaTests.octest"
+               BlueprintName = "ReactiveCocoaTests"
+               ReferencedContainer = "container:ReactiveCocoa.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      shouldUseLaunchSchemeArgsEnv = "NO"
+      buildConfiguration = "Test">
+      <Testables>
+         <TestableReference
+            skipped = "NO">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "88CDF7DB15000FCF00163A9F"
+               BuildableName = "ReactiveCocoaTests.octest"
+               BlueprintName = "ReactiveCocoaTests"
+               ReferencedContainer = "container:ReactiveCocoa.xcodeproj">
+            </BuildableReference>
+         </TestableReference>
+      </Testables>
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "88037F8215056328001A5B19"
+            BuildableName = "ReactiveCocoa.framework"
+            BlueprintName = "ReactiveCocoa"
+            ReferencedContainer = "container:ReactiveCocoa.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+      <EnvironmentVariables>
+         <EnvironmentVariable
+            key = "DYLD_INSERT_LIBRARIES"
+            value = "$(BUILT_PRODUCTS_DIR)/ReactiveCocoa.framework/ReactiveCocoa"
+            isEnabled = "YES">
+         </EnvironmentVariable>
+      </EnvironmentVariables>
+   </TestAction>
+   <LaunchAction
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      buildConfiguration = "Debug"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      allowLocationSimulation = "YES">
+      <AdditionalOptions>
+      </AdditionalOptions>
+   </LaunchAction>
+   <ProfileAction
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      buildConfiguration = "Profile"
+      debugDocumentVersioning = "YES">
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>
diff --git a/ReactiveCocoaFramework/ReactiveCocoa.xcworkspace/contents.xcworkspacedata b/ReactiveCocoaFramework/ReactiveCocoa.xcworkspace/contents.xcworkspacedata
new file mode 100644
index 0000000..4fb1f75
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa.xcworkspace/contents.xcworkspacedata
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Workspace
+   version = "1.0">
+   <FileRef
+      location = "group:ReactiveCocoa.xcodeproj">
+   </FileRef>
+   <FileRef
+      location = "group:../external/expecta/Expecta.xcodeproj">
+   </FileRef>
+   <FileRef
+      location = "group:../external/specta/Specta.xcodeproj">
+   </FileRef>
+</Workspace>
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSArray+RACSequenceAdditions.h b/ReactiveCocoaFramework/ReactiveCocoa/NSArray+RACSequenceAdditions.h
new file mode 100644
index 0000000..d2d0b3f
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSArray+RACSequenceAdditions.h
@@ -0,0 +1,20 @@
+//
+//  NSArray+RACSequenceAdditions.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-10-29.
+//  Copyright (c) 2012 GitHub. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+@class RACSequence;
+
+@interface NSArray (RACSequenceAdditions)
+
+/// Creates and returns a sequence corresponding to the receiver.
+///
+/// Mutating the receiver will not affect the sequence after it's been created.
+@property (nonatomic, copy, readonly) RACSequence *rac_sequence;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSArray+RACSequenceAdditions.m b/ReactiveCocoaFramework/ReactiveCocoa/NSArray+RACSequenceAdditions.m
new file mode 100644
index 0000000..ca2b951
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSArray+RACSequenceAdditions.m
@@ -0,0 +1,18 @@
+//
+//  NSArray+RACSequenceAdditions.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-10-29.
+//  Copyright (c) 2012 GitHub. All rights reserved.
+//
+
+#import "NSArray+RACSequenceAdditions.h"
+#import "RACArraySequence.h"
+
+@implementation NSArray (RACSequenceAdditions)
+
+- (RACSequence *)rac_sequence {
+	return [RACArraySequence sequenceWithArray:self offset:0];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSControl+RACCommandSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/NSControl+RACCommandSupport.h
new file mode 100644
index 0000000..4e51577
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSControl+RACCommandSupport.h
@@ -0,0 +1,22 @@
+//
+//  NSControl+RACCommandSupport.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 3/3/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import <Cocoa/Cocoa.h>
+
+@class RACCommand;
+
+@interface NSControl (RACCommandSupport)
+
+/// Sets the control's command. When the control is clicked, the command is
+/// executed with the sender of the event. The control's enabledness is bound
+/// to the command's `canExecute`.
+///
+/// Note: this will reset the control's target and action.
+@property (nonatomic, strong) RACCommand *rac_command;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSControl+RACCommandSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/NSControl+RACCommandSupport.m
new file mode 100644
index 0000000..8778f69
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSControl+RACCommandSupport.m
@@ -0,0 +1,59 @@
+//
+//  NSControl+RACCommandSupport.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 3/3/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "NSControl+RACCommandSupport.h"
+#import "EXTScope.h"
+#import "NSObject+RACPropertySubscribing.h"
+#import "RACCommand.h"
+#import "RACScopedDisposable.h"
+#import "RACSignal+Operations.h"
+#import <objc/runtime.h>
+
+static void *NSControlRACCommandKey = &NSControlRACCommandKey;
+static void *NSControlEnabledDisposableKey = &NSControlEnabledDisposableKey;
+
+@implementation NSControl (RACCommandSupport)
+
+- (RACCommand *)rac_command {
+	return objc_getAssociatedObject(self, NSControlRACCommandKey);
+}
+
+- (void)setRac_command:(RACCommand *)command {
+	objc_setAssociatedObject(self, NSControlRACCommandKey, command, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+
+	// Tear down any previous binding before setting up our new one, or else we
+	// might get assertion failures.
+	[objc_getAssociatedObject(self, NSControlEnabledDisposableKey) dispose];
+	objc_setAssociatedObject(self, NSControlEnabledDisposableKey, nil, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+
+	if (command == nil) {
+		self.enabled = YES;
+		return;
+	}
+	
+	[self rac_hijackActionAndTargetIfNeeded];
+
+	RACScopedDisposable *disposable = [[command.enabled setKeyPath:@"enabled" onObject:self] asScopedDisposable];
+	objc_setAssociatedObject(self, NSControlEnabledDisposableKey, disposable, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+}
+
+- (void)rac_hijackActionAndTargetIfNeeded {
+	SEL hijackSelector = @selector(rac_commandPerformAction:);
+	if (self.target == self && self.action == hijackSelector) return;
+	
+	if (self.target != nil) NSLog(@"WARNING: NSControl.rac_command hijacks the control's existing target and action.");
+	
+	self.target = self;
+	self.action = hijackSelector;
+}
+
+- (void)rac_commandPerformAction:(id)sender {
+	[self.rac_command execute:sender];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSControl+RACTextSignalSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/NSControl+RACTextSignalSupport.h
new file mode 100644
index 0000000..3d3618d
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSControl+RACTextSignalSupport.h
@@ -0,0 +1,24 @@
+//
+//  NSControl+RACTextSignalSupport.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-03-08.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <Cocoa/Cocoa.h>
+
+@class RACSignal;
+
+@interface NSControl (RACTextSignalSupport)
+
+/// Observes a text-based control for changes.
+///
+/// Using this method on a control without editable text is considered undefined
+/// behavior.
+///
+/// Returns a signal which sends the current string value of the receiver, then
+/// the new value any time it changes.
+- (RACSignal *)rac_textSignal;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSControl+RACTextSignalSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/NSControl+RACTextSignalSupport.m
new file mode 100644
index 0000000..3541bc2
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSControl+RACTextSignalSupport.m
@@ -0,0 +1,38 @@
+//
+//  NSControl+RACTextSignalSupport.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-03-08.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "NSControl+RACTextSignalSupport.h"
+#import "EXTScope.h"
+#import "RACDisposable.h"
+#import "RACSignal.h"
+#import "RACSubscriber.h"
+#import "NSObject+RACDescription.h"
+
+@implementation NSControl (RACTextSignalSupport)
+
+- (RACSignal *)rac_textSignal {
+	@weakify(self);
+	return [[[[RACSignal
+		createSignal:^(id<RACSubscriber> subscriber) {
+			@strongify(self);
+			id observer = [NSNotificationCenter.defaultCenter addObserverForName:NSControlTextDidChangeNotification object:self queue:nil usingBlock:^(NSNotification *note) {
+				[subscriber sendNext:note.object];
+			}];
+
+			return [RACDisposable disposableWithBlock:^{
+				[NSNotificationCenter.defaultCenter removeObserver:observer];
+			}];
+		}]
+		map:^(NSControl *control) {
+			return [control.stringValue copy];
+		}]
+		startWith:[self.stringValue copy]]
+		setNameWithFormat:@"%@ -rac_textSignal", [self rac_description]];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSData+RACSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/NSData+RACSupport.h
new file mode 100644
index 0000000..42198a6
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSData+RACSupport.h
@@ -0,0 +1,22 @@
+//
+//  NSData+RACSupport.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 5/11/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+@class RACSignal;
+@class RACScheduler;
+
+@interface NSData (RACSupport)
+
+// Read the data at the URL using -[NSData initWithContentsOfURL:options:error:].
+// Sends the data or the error.
+//
+// scheduler - cannot be nil.
++ (RACSignal *)rac_readContentsOfURL:(NSURL *)URL options:(NSDataReadingOptions)options scheduler:(RACScheduler *)scheduler;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSData+RACSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/NSData+RACSupport.m
new file mode 100644
index 0000000..227eb4d
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSData+RACSupport.m
@@ -0,0 +1,35 @@
+//
+//  NSData+RACSupport.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 5/11/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "NSData+RACSupport.h"
+#import "RACReplaySubject.h"
+#import "RACScheduler.h"
+
+@implementation NSData (RACSupport)
+
++ (RACSignal *)rac_readContentsOfURL:(NSURL *)URL options:(NSDataReadingOptions)options scheduler:(RACScheduler *)scheduler {
+	NSCParameterAssert(scheduler != nil);
+	
+	RACReplaySubject *subject = [RACReplaySubject subject];
+	[subject setNameWithFormat:@"+rac_readContentsOfURL: %@ options: %lu scheduler: %@", URL, (unsigned long)options, scheduler];
+	
+	[scheduler schedule:^{
+		NSError *error = nil;
+		NSData *data = [[NSData alloc] initWithContentsOfURL:URL options:options error:&error];
+		if(data == nil) {
+			[subject sendError:error];
+		} else {
+			[subject sendNext:data];
+			[subject sendCompleted];
+		}
+	}];
+	
+	return subject;
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSDictionary+RACSequenceAdditions.h b/ReactiveCocoaFramework/ReactiveCocoa/NSDictionary+RACSequenceAdditions.h
new file mode 100644
index 0000000..4871fe7
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSDictionary+RACSequenceAdditions.h
@@ -0,0 +1,31 @@
+//
+//  NSDictionary+RACSequenceAdditions.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-10-29.
+//  Copyright (c) 2012 GitHub. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+@class RACSequence;
+
+@interface NSDictionary (RACSequenceAdditions)
+
+/// Creates and returns a sequence of RACTuple key/value pairs. The key will be
+/// the first element in the tuple, and the value will be the second.
+///
+/// Mutating the receiver will not affect the sequence after it's been created.
+@property (nonatomic, copy, readonly) RACSequence *rac_sequence;
+
+/// Creates and returns a sequence corresponding to the keys in the receiver.
+///
+/// Mutating the receiver will not affect the sequence after it's been created.
+@property (nonatomic, copy, readonly) RACSequence *rac_keySequence;
+
+/// Creates and returns a sequence corresponding to the values in the receiver.
+///
+/// Mutating the receiver will not affect the sequence after it's been created.
+@property (nonatomic, copy, readonly) RACSequence *rac_valueSequence;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSDictionary+RACSequenceAdditions.m b/ReactiveCocoaFramework/ReactiveCocoa/NSDictionary+RACSequenceAdditions.m
new file mode 100644
index 0000000..192e6fd
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSDictionary+RACSequenceAdditions.m
@@ -0,0 +1,34 @@
+//
+//  NSDictionary+RACSequenceAdditions.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-10-29.
+//  Copyright (c) 2012 GitHub. All rights reserved.
+//
+
+#import "NSDictionary+RACSequenceAdditions.h"
+#import "NSArray+RACSequenceAdditions.h"
+#import "RACSequence.h"
+#import "RACTuple.h"
+
+@implementation NSDictionary (RACSequenceAdditions)
+
+- (RACSequence *)rac_sequence {
+	NSDictionary *immutableDict = [self copy];
+
+	// TODO: First class support for dictionary sequences.
+	return [immutableDict.allKeys.rac_sequence map:^(id key) {
+		id value = immutableDict[key];
+		return [RACTuple tupleWithObjects:key, value, nil];
+	}];
+}
+
+- (RACSequence *)rac_keySequence {
+	return self.allKeys.rac_sequence;
+}
+
+- (RACSequence *)rac_valueSequence {
+	return self.allValues.rac_sequence;
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSEnumerator+RACSequenceAdditions.h b/ReactiveCocoaFramework/ReactiveCocoa/NSEnumerator+RACSequenceAdditions.h
new file mode 100644
index 0000000..1d8fc84
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSEnumerator+RACSequenceAdditions.h
@@ -0,0 +1,20 @@
+//
+//  NSEnumerator+RACSequenceAdditions.h
+//  ReactiveCocoa
+//
+//  Created by Uri Baghin on 07/01/2013.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+@class RACSequence;
+
+@interface NSEnumerator (RACSequenceAdditions)
+
+/// Creates and returns a sequence corresponding to the receiver.
+///
+/// The receiver is exhausted lazily as the sequence is enumerated.
+@property (nonatomic, copy, readonly) RACSequence *rac_sequence;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSEnumerator+RACSequenceAdditions.m b/ReactiveCocoaFramework/ReactiveCocoa/NSEnumerator+RACSequenceAdditions.m
new file mode 100644
index 0000000..aa56eaa
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSEnumerator+RACSequenceAdditions.m
@@ -0,0 +1,22 @@
+//
+//  NSEnumerator+RACSequenceAdditions.m
+//  ReactiveCocoa
+//
+//  Created by Uri Baghin on 07/01/2013.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "NSEnumerator+RACSequenceAdditions.h"
+#import "RACSequence.h"
+
+@implementation NSEnumerator (RACSequenceAdditions)
+
+- (RACSequence *)rac_sequence {
+	return [RACSequence sequenceWithHeadBlock:^{
+		return [self nextObject];
+	} tailBlock:^{
+		return self.rac_sequence;
+	}];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSFileHandle+RACSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/NSFileHandle+RACSupport.h
new file mode 100644
index 0000000..985398d
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSFileHandle+RACSupport.h
@@ -0,0 +1,19 @@
+//
+//  NSFileHandle+RACSupport.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 5/10/12.
+//  Copyright (c) 2012 GitHub. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+@class RACSignal;
+
+@interface NSFileHandle (RACSupport)
+
+// Read any available data in the background and send it. Completes when data
+// length is <= 0.
+- (RACSignal *)rac_readInBackground;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSFileHandle+RACSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/NSFileHandle+RACSupport.m
new file mode 100644
index 0000000..a258789
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSFileHandle+RACSupport.m
@@ -0,0 +1,39 @@
+//
+//  NSFileHandle+RACSupport.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 5/10/12.
+//  Copyright (c) 2012 GitHub. All rights reserved.
+//
+
+#import "NSFileHandle+RACSupport.h"
+#import "NSNotificationCenter+RACSupport.h"
+#import "RACReplaySubject.h"
+#import "RACDisposable.h"
+
+@implementation NSFileHandle (RACSupport)
+
+- (RACSignal *)rac_readInBackground {
+	RACReplaySubject *subject = [RACReplaySubject subject];
+	[subject setNameWithFormat:@"%@ -rac_readInBackground", self];
+
+	RACSignal *dataNotification = [[[NSNotificationCenter defaultCenter] rac_addObserverForName:NSFileHandleReadCompletionNotification object:self] map:^(NSNotification *note) {
+		return [note.userInfo objectForKey:NSFileHandleNotificationDataItem];
+	}];
+	
+	__block RACDisposable *subscription = [dataNotification subscribeNext:^(NSData *data) {
+		if(data.length > 0) {
+			[subject sendNext:data];
+			[self readInBackgroundAndNotify];
+		} else {
+			[subject sendCompleted];
+			[subscription dispose];
+		}
+	}];
+	
+	[self readInBackgroundAndNotify];
+	
+	return subject;
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSIndexSet+RACSequenceAdditions.h b/ReactiveCocoaFramework/ReactiveCocoa/NSIndexSet+RACSequenceAdditions.h
new file mode 100644
index 0000000..b2066e4
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSIndexSet+RACSequenceAdditions.h
@@ -0,0 +1,20 @@
+//
+//  NSIndexSet+RACSequenceAdditions.h
+//  ReactiveCocoa
+//
+//  Created by Sergey Gavrilyuk on 12/17/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "RACSequence.h"
+
+@interface NSIndexSet (RACSequenceAdditions)
+
+/// Creates and returns a sequence of indexes (as `NSNumber`s) corresponding to
+/// the receiver.
+///
+/// Mutating the receiver will not affect the sequence after it's been created.
+@property (nonatomic, copy, readonly) RACSequence *rac_sequence;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSIndexSet+RACSequenceAdditions.m b/ReactiveCocoaFramework/ReactiveCocoa/NSIndexSet+RACSequenceAdditions.m
new file mode 100644
index 0000000..b3557e6
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSIndexSet+RACSequenceAdditions.m
@@ -0,0 +1,18 @@
+//
+//  NSIndexSet+RACSequenceAdditions.m
+//  ReactiveCocoa
+//
+//  Created by Sergey Gavrilyuk on 12/17/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "NSIndexSet+RACSequenceAdditions.h"
+#import "RACIndexSetSequence.h"
+
+@implementation NSIndexSet (RACSequenceAdditions)
+
+- (RACSequence *)rac_sequence {
+	return [RACIndexSetSequence sequenceWithIndexSet:self];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSInvocation+RACTypeParsing.h b/ReactiveCocoaFramework/ReactiveCocoa/NSInvocation+RACTypeParsing.h
new file mode 100644
index 0000000..d1e72bf
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSInvocation+RACTypeParsing.h
@@ -0,0 +1,56 @@
+//
+//  NSInvocation+RACTypeParsing.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 11/17/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+@class RACTuple;
+
+// A private category of methods to handle wrapping and unwrapping of values.
+@interface NSInvocation (RACTypeParsing)
+
+// Sets the argument for the invocation at the given index by unboxing the given
+// object based on the type signature of the argument.
+//
+// This does not support C arrays or unions.
+//
+// Note that calling this on a char * or const char * argument can cause all
+// arguments to be retained.
+//
+// object - The object to unbox and set as the argument.
+// index  - The index of the argument to set.
+- (void)rac_setArgument:(id)object atIndex:(NSUInteger)index;
+
+// Gets the argument for the invocation at the given index based on the
+// invocation's method signature. The value is then wrapped in the appropriate
+// object type.
+//
+// This does not support C arrays or unions.
+//
+// index  - The index of the argument to get.
+//
+// Returns the argument of the invocation, wrapped in an object.
+- (id)rac_argumentAtIndex:(NSUInteger)index;
+
+// Arguments tuple for the invocation.
+//
+// The arguments tuple excludes implicit variables `self` and `_cmd`.
+//
+// See -rac_argumentAtIndex: and -rac_setArgumentAtIndex: for further
+// description of the underlying behavior.
+@property (nonatomic, copy) RACTuple *rac_argumentsTuple;
+
+// Gets the return value from the invocation based on the invocation's method
+// signature. The value is then wrapped in the appropriate object type.
+//
+// This does not support C arrays or unions.
+//
+// Returns the return value of the invocation, wrapped in an object. Voids are
+// returned as `RACUnit.defaultUnit`.
+- (id)rac_returnValue;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSInvocation+RACTypeParsing.m b/ReactiveCocoaFramework/ReactiveCocoa/NSInvocation+RACTypeParsing.m
new file mode 100644
index 0000000..a5318e7
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSInvocation+RACTypeParsing.m
@@ -0,0 +1,232 @@
+//
+//  NSInvocation+RACTypeParsing.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 11/17/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "NSInvocation+RACTypeParsing.h"
+#import "RACTuple.h"
+#import "RACUnit.h"
+#import <CoreGraphics/CoreGraphics.h>
+
+@implementation NSInvocation (RACTypeParsing)
+
+- (void)rac_setArgument:(id)object atIndex:(NSUInteger)index {
+#define PULL_AND_SET(type, selector) \
+	do { \
+		type val = [object selector]; \
+		[self setArgument:&val atIndex:(NSInteger)index]; \
+	} while(0)
+
+	const char *argType = [self.methodSignature getArgumentTypeAtIndex:index];
+	// Skip const type qualifier.
+	if (argType[0] == 'r') {
+		argType++;
+	}
+
+	if (strcmp(argType, @encode(id)) == 0 || strcmp(argType, @encode(Class)) == 0) {
+		[self setArgument:&object atIndex:(NSInteger)index];
+	} else if (strcmp(argType, @encode(char)) == 0) {
+		PULL_AND_SET(char, charValue);
+	} else if (strcmp(argType, @encode(int)) == 0) {
+		PULL_AND_SET(int, intValue);
+	} else if (strcmp(argType, @encode(short)) == 0) {
+		PULL_AND_SET(short, shortValue);
+	} else if (strcmp(argType, @encode(long)) == 0) {
+		PULL_AND_SET(long, longValue);
+	} else if (strcmp(argType, @encode(long long)) == 0) {
+		PULL_AND_SET(long long, longLongValue);
+	} else if (strcmp(argType, @encode(unsigned char)) == 0) {
+		PULL_AND_SET(unsigned char, unsignedCharValue);
+	} else if (strcmp(argType, @encode(unsigned int)) == 0) {
+		PULL_AND_SET(unsigned int, unsignedIntValue);
+	} else if (strcmp(argType, @encode(unsigned short)) == 0) {
+		PULL_AND_SET(unsigned short, unsignedShortValue);
+	} else if (strcmp(argType, @encode(unsigned long)) == 0) {
+		PULL_AND_SET(unsigned long, unsignedLongValue);
+	} else if (strcmp(argType, @encode(unsigned long long)) == 0) {
+		PULL_AND_SET(unsigned long long, unsignedLongLongValue);
+	} else if (strcmp(argType, @encode(float)) == 0) {
+		PULL_AND_SET(float, floatValue);
+	} else if (strcmp(argType, @encode(double)) == 0) {
+		PULL_AND_SET(double, doubleValue);
+	} else if (strcmp(argType, @encode(BOOL)) == 0) {
+		PULL_AND_SET(BOOL, boolValue);
+	} else if (strcmp(argType, @encode(char *)) == 0) {
+		const char *cString = [object UTF8String];
+		[self setArgument:&cString atIndex:(NSInteger)index];
+		[self retainArguments];
+	} else if (strcmp(argType, @encode(void (^)(void))) == 0) {
+		[self setArgument:&object atIndex:(NSInteger)index];
+	} else {
+		NSCParameterAssert([object isKindOfClass:NSValue.class]);
+
+		NSUInteger valueSize = 0;
+		NSGetSizeAndAlignment([object objCType], &valueSize, NULL);
+
+#if DEBUG
+		NSUInteger argSize = 0;
+		NSGetSizeAndAlignment(argType, &argSize, NULL);
+		NSCAssert(valueSize == argSize, @"Value size does not match argument size in -rac_setArgument: %@ atIndex: %lu", object, (unsigned long)index);
+#endif
+		
+		unsigned char valueBytes[valueSize];
+		[object getValue:valueBytes];
+
+		[self setArgument:valueBytes atIndex:(NSInteger)index];
+	}
+
+#undef PULL_AND_SET
+}
+
+- (id)rac_argumentAtIndex:(NSUInteger)index {
+#define WRAP_AND_RETURN(type) \
+	do { \
+		type val = 0; \
+		[self getArgument:&val atIndex:(NSInteger)index]; \
+		return @(val); \
+	} while (0)
+
+	const char *argType = [self.methodSignature getArgumentTypeAtIndex:index];
+	// Skip const type qualifier.
+	if (argType[0] == 'r') {
+		argType++;
+	}
+
+	if (strcmp(argType, @encode(id)) == 0 || strcmp(argType, @encode(Class)) == 0) {
+		__autoreleasing id returnObj;
+		[self getArgument:&returnObj atIndex:(NSInteger)index];
+		return returnObj;
+	} else if (strcmp(argType, @encode(char)) == 0) {
+		WRAP_AND_RETURN(char);
+	} else if (strcmp(argType, @encode(int)) == 0) {
+		WRAP_AND_RETURN(int);
+	} else if (strcmp(argType, @encode(short)) == 0) {
+		WRAP_AND_RETURN(short);
+	} else if (strcmp(argType, @encode(long)) == 0) {
+		WRAP_AND_RETURN(long);
+	} else if (strcmp(argType, @encode(long long)) == 0) {
+		WRAP_AND_RETURN(long long);
+	} else if (strcmp(argType, @encode(unsigned char)) == 0) {
+		WRAP_AND_RETURN(unsigned char);
+	} else if (strcmp(argType, @encode(unsigned int)) == 0) {
+		WRAP_AND_RETURN(unsigned int);
+	} else if (strcmp(argType, @encode(unsigned short)) == 0) {
+		WRAP_AND_RETURN(unsigned short);
+	} else if (strcmp(argType, @encode(unsigned long)) == 0) {
+		WRAP_AND_RETURN(unsigned long);
+	} else if (strcmp(argType, @encode(unsigned long long)) == 0) {
+		WRAP_AND_RETURN(unsigned long long);
+	} else if (strcmp(argType, @encode(float)) == 0) {
+		WRAP_AND_RETURN(float);
+	} else if (strcmp(argType, @encode(double)) == 0) {
+		WRAP_AND_RETURN(double);
+	} else if (strcmp(argType, @encode(BOOL)) == 0) {
+		WRAP_AND_RETURN(BOOL);
+	} else if (strcmp(argType, @encode(char *)) == 0) {
+		WRAP_AND_RETURN(const char *);
+	} else if (strcmp(argType, @encode(void (^)(void))) == 0) {
+		__unsafe_unretained id block = nil;
+		[self getArgument:&block atIndex:(NSInteger)index];
+		return [block copy];
+	} else {
+		NSUInteger valueSize = 0;
+		NSGetSizeAndAlignment(argType, &valueSize, NULL);
+
+		unsigned char valueBytes[valueSize];
+		[self getArgument:valueBytes atIndex:(NSInteger)index];
+		
+		return [NSValue valueWithBytes:valueBytes objCType:argType];
+	}
+
+	return nil;
+
+#undef WRAP_AND_RETURN
+}
+
+- (RACTuple *)rac_argumentsTuple {
+	NSUInteger numberOfArguments = self.methodSignature.numberOfArguments;
+	NSMutableArray *argumentsArray = [NSMutableArray arrayWithCapacity:numberOfArguments - 2];
+	for (NSUInteger index = 2; index < numberOfArguments; index++) {
+		[argumentsArray addObject:[self rac_argumentAtIndex:index] ?: RACTupleNil.tupleNil];
+	}
+
+	return [RACTuple tupleWithObjectsFromArray:argumentsArray];
+}
+
+- (void)setRac_argumentsTuple:(RACTuple *)arguments {
+	NSCAssert(arguments.count == self.methodSignature.numberOfArguments - 2, @"Number of supplied arguments (%lu), does not match the number expected by the signature (%lu)", (unsigned long)arguments.count, (unsigned long)self.methodSignature.numberOfArguments - 2);
+
+	NSUInteger index = 2;
+	for (id arg in arguments) {
+		[self rac_setArgument:(arg == RACTupleNil.tupleNil ? nil : arg) atIndex:index];
+		index++;
+	}
+}
+
+- (id)rac_returnValue {
+#define WRAP_AND_RETURN(type) \
+	do { \
+		type val = 0; \
+		[self getReturnValue:&val]; \
+		return @(val); \
+	} while (0)
+
+	const char *returnType = self.methodSignature.methodReturnType;
+	// Skip const type qualifier.
+	if (returnType[0] == 'r') {
+		returnType++;
+	}
+
+	if (strcmp(returnType, @encode(id)) == 0 || strcmp(returnType, @encode(Class)) == 0 || strcmp(returnType, @encode(void (^)(void))) == 0) {
+		__autoreleasing id returnObj;
+		[self getReturnValue:&returnObj];
+		return returnObj;
+	} else if (strcmp(returnType, @encode(char)) == 0) {
+		WRAP_AND_RETURN(char);
+	} else if (strcmp(returnType, @encode(int)) == 0) {
+		WRAP_AND_RETURN(int);
+	} else if (strcmp(returnType, @encode(short)) == 0) {
+		WRAP_AND_RETURN(short);
+	} else if (strcmp(returnType, @encode(long)) == 0) {
+		WRAP_AND_RETURN(long);
+	} else if (strcmp(returnType, @encode(long long)) == 0) {
+		WRAP_AND_RETURN(long long);
+	} else if (strcmp(returnType, @encode(unsigned char)) == 0) {
+		WRAP_AND_RETURN(unsigned char);
+	} else if (strcmp(returnType, @encode(unsigned int)) == 0) {
+		WRAP_AND_RETURN(unsigned int);
+	} else if (strcmp(returnType, @encode(unsigned short)) == 0) {
+		WRAP_AND_RETURN(unsigned short);
+	} else if (strcmp(returnType, @encode(unsigned long)) == 0) {
+		WRAP_AND_RETURN(unsigned long);
+	} else if (strcmp(returnType, @encode(unsigned long long)) == 0) {
+		WRAP_AND_RETURN(unsigned long long);
+	} else if (strcmp(returnType, @encode(float)) == 0) {
+		WRAP_AND_RETURN(float);
+	} else if (strcmp(returnType, @encode(double)) == 0) {
+		WRAP_AND_RETURN(double);
+	} else if (strcmp(returnType, @encode(BOOL)) == 0) {
+		WRAP_AND_RETURN(BOOL);
+	} else if (strcmp(returnType, @encode(char *)) == 0) {
+		WRAP_AND_RETURN(const char *);
+	} else if (strcmp(returnType, @encode(void)) == 0) {
+		return RACUnit.defaultUnit;
+	} else {
+		NSUInteger valueSize = 0;
+		NSGetSizeAndAlignment(returnType, &valueSize, NULL);
+
+		unsigned char valueBytes[valueSize];
+		[self getReturnValue:valueBytes];
+
+		return [NSValue valueWithBytes:valueBytes objCType:returnType];
+	}
+
+	return nil;
+
+#undef WRAP_AND_RETURN
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSNotificationCenter+RACSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/NSNotificationCenter+RACSupport.h
new file mode 100644
index 0000000..ddb3954
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSNotificationCenter+RACSupport.h
@@ -0,0 +1,18 @@
+//
+//  NSNotificationCenter+RACSupport.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 5/10/12.
+//  Copyright (c) 2012 GitHub. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+@class RACSignal;
+
+@interface NSNotificationCenter (RACSupport)
+
+// Sends the NSNotification every time the notification is posted.
+- (RACSignal *)rac_addObserverForName:(NSString *)notificationName object:(id)object;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSNotificationCenter+RACSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/NSNotificationCenter+RACSupport.m
new file mode 100644
index 0000000..a0112e9
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSNotificationCenter+RACSupport.m
@@ -0,0 +1,31 @@
+//
+//  NSNotificationCenter+RACSupport.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 5/10/12.
+//  Copyright (c) 2012 GitHub. All rights reserved.
+//
+
+#import "NSNotificationCenter+RACSupport.h"
+#import "EXTScope.h"
+#import "RACSignal.h"
+#import "RACSubscriber.h"
+#import "RACDisposable.h"
+
+@implementation NSNotificationCenter (RACSupport)
+
+- (RACSignal *)rac_addObserverForName:(NSString *)notificationName object:(id)object {
+	@unsafeify(object);
+	return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+		@strongify(object);
+		id observer = [self addObserverForName:notificationName object:object queue:nil usingBlock:^(NSNotification *note) {
+			[subscriber sendNext:note];
+		}];
+
+		return [RACDisposable disposableWithBlock:^{
+			[self removeObserver:observer];
+		}];
+	}] setNameWithFormat:@"-rac_addObserverForName: %@ object: <%@: %p>", notificationName, [object class], object];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACAppKitBindings.h b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACAppKitBindings.h
new file mode 100644
index 0000000..eaec439
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACAppKitBindings.h
@@ -0,0 +1,40 @@
+//
+//  NSObject+RACAppKitBindings.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 4/17/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import <Cocoa/Cocoa.h>
+
+@class RACChannelTerminal;
+
+@interface NSObject (RACAppKitBindings)
+
+/// Invokes -rac_channelToBinding:options: without any options.
+- (RACChannelTerminal *)rac_channelToBinding:(NSString *)binding;
+
+/// Applies a Cocoa binding to the receiver, then exposes a RACChannel-based
+/// interface for manipulating it.
+///
+/// Creating two of the same bindings on the same object will result in undefined
+/// behavior.
+///
+/// binding - The name of the binding. This must not be nil.
+/// options - Any options to pass to Cocoa Bindings. This may be nil.
+///
+/// Returns a RACChannelTerminal which will send future values from the receiver,
+/// and update the receiver when values are sent to the terminal.
+- (RACChannelTerminal *)rac_channelToBinding:(NSString *)binding options:(NSDictionary *)options;
+
+@end
+
+@interface NSObject (RACAppKitBindingsDeprecated)
+
+- (void)rac_bind:(NSString *)binding toObject:(id)object withKeyPath:(NSString *)keyPath __attribute__((deprecated("Use -rac_bind:options: instead")));
+- (void)rac_bind:(NSString *)binding toObject:(id)object withKeyPath:(NSString *)keyPath nilValue:(id)nilValue __attribute__((deprecated("Use -rac_bind:options: instead")));
+- (void)rac_bind:(NSString *)binding toObject:(id)object withKeyPath:(NSString *)keyPath transform:(id (^)(id value))transformBlock __attribute__((deprecated("Use -rac_bind:options: instead")));
+- (void)rac_bind:(NSString *)binding toObject:(id)object withNegatedKeyPath:(NSString *)keyPath __attribute__((deprecated("Use -rac_bind:options: instead")));
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACAppKitBindings.m b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACAppKitBindings.m
new file mode 100644
index 0000000..ea80f83
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACAppKitBindings.m
@@ -0,0 +1,175 @@
+//
+//  NSObject+RACAppKitBindings.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 4/17/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "NSObject+RACAppKitBindings.h"
+#import "EXTKeyPathCoding.h"
+#import "EXTScope.h"
+#import "NSObject+RACDeallocating.h"
+#import "RACChannel.h"
+#import "RACCompoundDisposable.h"
+#import "RACDisposable.h"
+#import "RACKVOChannel.h"
+#import "RACMulticastConnection.h"
+#import "RACSignal+Operations.h"
+#import "RACValueTransformer.h"
+#import <objc/runtime.h>
+
+// Used as an object to bind to, so we can hide the object creation and just
+// expose a RACChannel instead.
+@interface RACChannelProxy : NSObject
+
+// The RACChannel used for this Cocoa binding.
+@property (nonatomic, strong, readonly) RACChannel *channel;
+
+// The KVC- and KVO-compliant property to be read and written by the Cocoa
+// binding.
+//
+// This should not be set manually.
+@property (nonatomic, strong) id value;
+
+// The target of the Cocoa binding.
+//
+// This should be set to nil when the target deallocates.
+@property (atomic, unsafe_unretained) id target;
+
+// The name of the Cocoa binding used.
+@property (nonatomic, copy, readonly) NSString *bindingName;
+
+// Improves the performance of KVO on the receiver.
+//
+// See the documentation for <NSKeyValueObserving> for more information.
+@property (atomic, assign) void *observationInfo;
+
+// Initializes the receiver and binds to the given target.
+//
+// target      - The target of the Cocoa binding. This must not be nil.
+// bindingName - The name of the Cocoa binding to use. This must not be nil.
+// options     - Any options to pass to the binding. This may be nil.
+//
+// Returns an initialized channel proxy.
+- (id)initWithTarget:(id)target bindingName:(NSString *)bindingName options:(NSDictionary *)options;
+
+@end
+
+@implementation NSObject (RACAppKitBindings)
+
+- (RACChannelTerminal *)rac_channelToBinding:(NSString *)binding {
+	return [self rac_channelToBinding:binding options:nil];
+}
+
+- (RACChannelTerminal *)rac_channelToBinding:(NSString *)binding options:(NSDictionary *)options {
+	NSCParameterAssert(binding != nil);
+
+	RACChannelProxy *proxy = [[RACChannelProxy alloc] initWithTarget:self bindingName:binding options:options];
+	return proxy.channel.leadingTerminal;
+}
+
+@end
+
+@implementation RACChannelProxy
+
+#pragma mark Properties
+
+- (void)setValue:(id)value {
+	[self willChangeValueForKey:@keypath(self.value)];
+	_value = value;
+	[self didChangeValueForKey:@keypath(self.value)];
+}
+
+#pragma mark Lifecycle
+
+- (id)initWithTarget:(id)target bindingName:(NSString *)bindingName options:(NSDictionary *)options {
+	NSCParameterAssert(target != nil);
+	NSCParameterAssert(bindingName != nil);
+
+	self = [super init];
+	if (self == nil) return nil;
+
+	_target = target;
+	_bindingName = [bindingName copy];
+	_channel = [[RACChannel alloc] init];
+
+	@weakify(self);
+
+	void (^cleanUp)() = ^{
+		@strongify(self);
+
+		id target = self.target;
+		if (target == nil) return;
+
+		self.target = nil;
+
+		[target unbind:bindingName];
+		objc_setAssociatedObject(target, (__bridge void *)self, nil, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+	};
+
+	// When the channel terminates, tear down this proxy.
+	[self.channel.followingTerminal subscribeError:^(NSError *error) {
+		cleanUp();
+	} completed:cleanUp];
+
+	[self.target bind:bindingName toObject:self withKeyPath:@keypath(self.value) options:options];
+
+	// Keep the proxy alive as long as the target, or until the property subject
+	// terminates.
+	objc_setAssociatedObject(self.target, (__bridge void *)self, self, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+
+	[[self.target rac_deallocDisposable] addDisposable:[RACDisposable disposableWithBlock:^{
+		@strongify(self);
+		[self.channel.followingTerminal sendCompleted];
+	}]];
+
+	RACChannelTo(self, value, options[NSNullPlaceholderBindingOption]) = self.channel.followingTerminal;
+	return self;
+}
+
+- (void)dealloc {
+	[self.channel.followingTerminal sendCompleted];
+}
+
+#pragma mark NSObject
+
+- (NSString *)description {
+	return [NSString stringWithFormat:@"<%@: %p>{ target: %@, binding: %@ }", self.class, self, self.target, self.bindingName];
+}
+
+#pragma mark NSKeyValueObserving
+
++ (BOOL)automaticallyNotifiesObserversForKey:(NSString *)key {
+	// Generating manual notifications for `value` is simpler and more
+	// performant than having KVO swizzle our class and add its own logic.
+	return NO;
+}
+
+@end
+
+@implementation NSObject (RACAppKitBindingsDeprecated)
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-implementations"
+
+- (void)rac_bind:(NSString *)binding toObject:(id)object withKeyPath:(NSString *)keyPath {
+	[self rac_bind:binding toObject:object withKeyPath:keyPath nilValue:nil];
+}
+
+- (void)rac_bind:(NSString *)binding toObject:(id)object withKeyPath:(NSString *)keyPath nilValue:(id)nilValue {
+	[self bind:binding toObject:object withKeyPath:keyPath options:[NSDictionary dictionaryWithObjectsAndKeys:[NSNumber numberWithBool:YES], NSContinuouslyUpdatesValueBindingOption, nilValue, NSNullPlaceholderBindingOption, nil]];
+}
+
+- (void)rac_bind:(NSString *)binding toObject:(id)object withKeyPath:(NSString *)keyPath transform:(id (^)(id value))transformBlock {
+	RACValueTransformer *transformer = [RACValueTransformer transformerWithBlock:transformBlock];
+	[self bind:binding toObject:object withKeyPath:keyPath options:[NSDictionary dictionaryWithObjectsAndKeys:[NSNumber numberWithBool:YES], NSContinuouslyUpdatesValueBindingOption, transformer, NSValueTransformerBindingOption, nil]];
+}
+
+- (void)rac_bind:(NSString *)binding toObject:(id)object withNegatedKeyPath:(NSString *)keyPath {
+	[self bind:binding toObject:object withKeyPath:keyPath options:[NSDictionary dictionaryWithObjectsAndKeys:[NSNumber numberWithBool:YES], NSContinuouslyUpdatesValueBindingOption, NSNegateBooleanTransformerName, NSValueTransformerNameBindingOption, nil]];
+}
+
+#pragma clang diagnostic pop
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACDeallocating.h b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACDeallocating.h
new file mode 100644
index 0000000..1530eb4
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACDeallocating.h
@@ -0,0 +1,34 @@
+//
+//  NSObject+RACDeallocating.h
+//  ReactiveCocoa
+//
+//  Created by Kazuo Koga on 2013/03/15.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+@class RACCompoundDisposable;
+@class RACDisposable;
+@class RACSignal;
+
+@interface NSObject (RACDeallocating)
+
+/// The compound disposable which will be disposed of when the receiver is
+/// deallocated.
+@property (atomic, readonly, strong) RACCompoundDisposable *rac_deallocDisposable;
+
+/// Returns a signal that will complete immediately before the receiver is fully
+/// deallocated. If already deallocated when the signal is subscribed to,
+/// a `completed` event will be sent immediately.
+- (RACSignal *)rac_willDeallocSignal;
+
+@end
+
+@interface NSObject (RACDeallocatingDeprecated)
+
+- (RACSignal *)rac_didDeallocSignal __attribute__((deprecated("Use -rac_willDeallocSignal")));
+
+- (void)rac_addDeallocDisposable:(RACDisposable *)disposable __attribute__((deprecated("Add disposables to -rac_deallocDisposable instead")));
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACDeallocating.m b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACDeallocating.m
new file mode 100644
index 0000000..a81d89c
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACDeallocating.m
@@ -0,0 +1,129 @@
+//
+//  NSObject+RACDeallocating.m
+//  ReactiveCocoa
+//
+//  Created by Kazuo Koga on 2013/03/15.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "NSObject+RACDeallocating.h"
+#import "RACCompoundDisposable.h"
+#import "RACDisposable.h"
+#import "RACReplaySubject.h"
+#import <objc/message.h>
+#import <objc/runtime.h>
+
+static const void *RACObjectCompoundDisposable = &RACObjectCompoundDisposable;
+
+static NSMutableSet *swizzledClasses() {
+	static dispatch_once_t onceToken;
+	static NSMutableSet *swizzledClasses = nil;
+	dispatch_once(&onceToken, ^{
+		swizzledClasses = [[NSMutableSet alloc] init];
+	});
+	
+	return swizzledClasses;
+}
+
+static void swizzleDeallocIfNeeded(Class classToSwizzle) {
+	@synchronized (swizzledClasses()) {
+		NSString *className = NSStringFromClass(classToSwizzle);
+		if ([swizzledClasses() containsObject:className]) return;
+
+		SEL deallocSelector = sel_registerName("dealloc");
+
+		__block void (*originalDealloc)(__unsafe_unretained id, SEL) = NULL;
+
+		id newDealloc = ^(__unsafe_unretained id self) {
+			RACCompoundDisposable *compoundDisposable = objc_getAssociatedObject(self, RACObjectCompoundDisposable);
+			[compoundDisposable dispose];
+
+			if (originalDealloc == NULL) {
+				struct objc_super superInfo = {
+					.receiver = self,
+					.super_class = class_getSuperclass(classToSwizzle)
+				};
+
+				void (*msgSend)(struct objc_super *, SEL) = (__typeof__(msgSend))objc_msgSendSuper;
+				msgSend(&superInfo, deallocSelector);
+			} else {
+				originalDealloc(self, deallocSelector);
+			}
+		};
+		
+		IMP newDeallocIMP = imp_implementationWithBlock(newDealloc);
+		
+		if (!class_addMethod(classToSwizzle, deallocSelector, newDeallocIMP, "v@:")) {
+			// The class already contains a method implementation.
+			Method deallocMethod = class_getInstanceMethod(classToSwizzle, deallocSelector);
+			
+			// We need to store original implementation before setting new implementation
+			// in case method is called at the time of setting.
+			originalDealloc = (__typeof__(originalDealloc))method_getImplementation(deallocMethod);
+			
+			// We need to store original implementation again, in case it just changed.
+			originalDealloc = (__typeof__(originalDealloc))method_setImplementation(deallocMethod, newDeallocIMP);
+		}
+
+		[swizzledClasses() addObject:className];
+	}
+}
+
+@implementation NSObject (RACDeallocating)
+
+- (RACSignal *)rac_willDeallocSignal {
+	RACSignal *signal = objc_getAssociatedObject(self, _cmd);
+	if (signal != nil) return signal;
+
+	RACReplaySubject *subject = [RACReplaySubject subject];
+
+	[self.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+		[subject sendCompleted];
+	}]];
+
+	objc_setAssociatedObject(self, _cmd, subject, OBJC_ASSOCIATION_RETAIN);
+
+	return subject;
+}
+
+- (RACCompoundDisposable *)rac_deallocDisposable {
+	@synchronized (self) {
+		RACCompoundDisposable *compoundDisposable = objc_getAssociatedObject(self, RACObjectCompoundDisposable);
+		if (compoundDisposable != nil) return compoundDisposable;
+
+		swizzleDeallocIfNeeded(self.class);
+
+		compoundDisposable = [RACCompoundDisposable compoundDisposable];
+		objc_setAssociatedObject(self, RACObjectCompoundDisposable, compoundDisposable, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+
+		return compoundDisposable;
+	}
+}
+
+@end
+
+@implementation NSObject (RACDeallocatingDeprecated)
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-implementations"
+
+- (RACSignal *)rac_didDeallocSignal {
+	RACSubject *subject = [RACSubject subject];
+
+	RACScopedDisposable *disposable = [[RACDisposable
+		disposableWithBlock:^{
+			[subject sendCompleted];
+		}]
+		asScopedDisposable];
+	
+	objc_setAssociatedObject(self, (__bridge void *)disposable, disposable, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+	return subject;
+}
+
+- (void)rac_addDeallocDisposable:(RACDisposable *)disposable {
+	[self.rac_deallocDisposable addDisposable:disposable];
+}
+
+#pragma clang diagnostic pop
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACDescription.h b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACDescription.h
new file mode 100644
index 0000000..41e3d8a
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACDescription.h
@@ -0,0 +1,21 @@
+//
+//  NSObject+RACDescription.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-05-13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+// A private category providing a terser but faster alternative to -description.
+@interface NSObject (RACDescription)
+
+// A simplified description of the receiver, which does not invoke -description
+// (and thus should be much faster in many cases).
+//
+// This is for debugging purposes only, and will return a constant string
+// unless the RAC_DEBUG_SIGNAL_NAMES environment variable is set.
+- (NSString *)rac_description;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACDescription.m b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACDescription.m
new file mode 100644
index 0000000..0088880
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACDescription.m
@@ -0,0 +1,46 @@
+//
+//  NSObject+RACDescription.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-05-13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "NSObject+RACDescription.h"
+#import "RACTuple.h"
+
+@implementation NSObject (RACDescription)
+
+- (NSString *)rac_description {
+	if (getenv("RAC_DEBUG_SIGNAL_NAMES") != NULL) {
+		return [[NSString alloc] initWithFormat:@"<%@: %p>", self.class, self];
+	} else {
+		return @"(description skipped)";
+	}
+}
+
+@end
+
+@implementation NSValue (RACDescription)
+
+- (NSString *)rac_description {
+	return self.description;
+}
+
+@end
+
+@implementation NSString (RACDescription)
+
+- (NSString *)rac_description {
+	return self.description;
+}
+
+@end
+
+@implementation RACTuple (RACDescription)
+
+- (NSString *)rac_description {
+	return self.allObjects.description;
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACKVOWrapper.h b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACKVOWrapper.h
new file mode 100644
index 0000000..3b9ff2f
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACKVOWrapper.h
@@ -0,0 +1,56 @@
+//
+//  NSObject+RACKVOWrapper.h
+//  GitHub
+//
+//  Created by Josh Abernathy on 10/11/11.
+//  Copyright (c) 2011 GitHub. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+
+// RAC-specific KVO change dictionary key: Will be @YES if the change was caused
+// by the value at the key path or an intermediate value deallocating, @NO
+// otherwise.
+extern NSString * const RACKeyValueChangeCausedByDeallocationKey;
+
+// RAC-specific KVO change dictionary key: Will be @YES if the change only
+// affected the value of the last key path component leaving the values of the
+// intermediate key path components unaltered, @NO otherwise.
+extern NSString * const RACKeyValueChangeAffectedOnlyLastComponentKey;
+
+@class RACDisposable, RACKVOTrampoline;
+
+// A private category providing a block based interface to KVO.
+@interface NSObject (RACKVOWrapper)
+
+// Adds the given block as the callbacks for when the key path changes.
+//
+// Unlike direct KVO observation, this handles deallocation of `weak` properties
+// by generating an appropriate notification. This will only occur if there is
+// an `@property` declaration visible in the observed class, with the `weak`
+// memory management attribute.
+//
+// The observation does not need to be explicitly removed. It will be removed
+// when the observer or the receiver deallocate.
+//
+// keyPath  - The key path to observe. Must not be nil.
+// options  - The KVO observation options.
+// observer - The object that requested the observation. May be nil.
+// block    - The block called when the value at the key path changes. It is
+//            passed the current value of the key path and the extended KVO
+//            change dictionary including RAC-specific keys and values. Must not
+//            be nil.
+//
+// Returns a disposable that can be used to stop the observation.
+- (RACDisposable *)rac_observeKeyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options observer:(NSObject *)observer block:(void (^)(id value, NSDictionary *change))block;
+
+@end
+
+typedef void (^RACKVOBlock)(id target, id observer, NSDictionary *change);
+
+@interface NSObject (RACKVOWrapperDeprecated)
+
+- (RACKVOTrampoline *)rac_addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options block:(RACKVOBlock)block __attribute((deprecated("Use rac_observeKeyPath:options:observer:block: instead.")));
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACKVOWrapper.m b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACKVOWrapper.m
new file mode 100644
index 0000000..7f12312
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACKVOWrapper.m
@@ -0,0 +1,237 @@
+//
+//  NSObject+RACKVOWrapper.m
+//  GitHub
+//
+//  Created by Josh Abernathy on 10/11/11.
+//  Copyright (c) 2011 GitHub. All rights reserved.
+//
+
+#import "NSObject+RACKVOWrapper.h"
+#import "EXTRuntimeExtensions.h"
+#import "EXTScope.h"
+#import "NSObject+RACDeallocating.h"
+#import "NSString+RACKeyPathUtilities.h"
+#import "RACCompoundDisposable.h"
+#import "RACDisposable.h"
+#import "RACKVOTrampoline.h"
+#import "RACSerialDisposable.h"
+
+NSString * const RACKeyValueChangeCausedByDeallocationKey = @"RACKeyValueChangeCausedByDeallocationKey";
+NSString * const RACKeyValueChangeAffectedOnlyLastComponentKey = @"RACKeyValueChangeAffectedOnlyLastComponentKey";
+
+@implementation NSObject (RACKVOWrapper)
+
+- (RACDisposable *)rac_observeKeyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options observer:(NSObject *)observer block:(void (^)(id, NSDictionary *))block {
+	NSCParameterAssert(block != nil);
+	NSCParameterAssert(keyPath.rac_keyPathComponents.count > 0);
+
+	keyPath = [keyPath copy];
+
+	@unsafeify(observer);
+
+	NSArray *keyPathComponents = keyPath.rac_keyPathComponents;
+	BOOL keyPathHasOneComponent = (keyPathComponents.count == 1);
+	NSString *keyPathHead = keyPathComponents[0];
+	NSString *keyPathTail = keyPath.rac_keyPathByDeletingFirstKeyPathComponent;
+
+	RACCompoundDisposable *disposable = [RACCompoundDisposable compoundDisposable];
+
+	// The disposable that groups all disposal necessary to clean up the callbacks
+	// added to the value of the first key path component.
+	RACSerialDisposable *firstComponentSerialDisposable = [RACSerialDisposable serialDisposableWithDisposable:[RACCompoundDisposable compoundDisposable]];
+	RACCompoundDisposable * (^firstComponentDisposable)(void) = ^{
+		return (RACCompoundDisposable *)firstComponentSerialDisposable.disposable;
+	};
+
+	[disposable addDisposable:firstComponentSerialDisposable];
+
+	// Adds the callback block to the value's deallocation. Also adds the logic to
+	// clean up the callback to the firstComponentDisposable.
+	void (^addDeallocObserverToPropertyValue)(NSObject *, NSString *, NSObject *) = ^(NSObject *parent, NSString *propertyKey, NSObject *value) {
+		// If a key path value is the observer, commonly when a key path begins
+		// with "self", we prevent deallocation triggered callbacks for any such key
+		// path components. Thus, the observer's deallocation is not considered a
+		// change to the key path.
+		@strongify(observer);
+		if (value == observer) return;
+
+		objc_property_t property = class_getProperty(object_getClass(parent), propertyKey.UTF8String);
+		if (property == NULL) {
+			// If we can't find an Objective-C property for this key, we assume
+			// that we don't need to observe its deallocation (thus matching
+			// vanilla KVO behavior).
+			//
+			// Even if we wanted to, there's not enough type information on
+			// ivars to figure out its memory management.
+			return;
+		}
+
+		rac_propertyAttributes *attributes = rac_copyPropertyAttributes(property);
+		if (attributes == NULL) return;
+
+		@onExit {
+			free(attributes);
+		};
+
+		BOOL isNonObject = attributes->objectClass == nil && strstr(attributes->type, @encode(id)) != attributes->type;
+		BOOL isProtocol = attributes->objectClass == NSClassFromString(@"Protocol");
+		BOOL isBlock = strcmp(attributes->type, @encode(void(^)())) == 0;
+		if (isNonObject || isProtocol || isBlock) {
+			// If this property isn't actually an object (or is a Class object),
+			// no point in observing the deallocation of the wrapper returned by
+			// KVC.
+			return;
+		}
+
+		if (!attributes->weak) {
+			// If this property is an object, but not declared `weak`, we
+			// don't need to watch for it spontaneously being set to nil.
+			//
+			// Attempting to observe non-weak properties will result in
+			// broken behavior for dynamic getters, so don't even try.
+			return;
+		}
+
+		NSDictionary *change = @{
+			NSKeyValueChangeKindKey: @(NSKeyValueChangeSetting),
+			NSKeyValueChangeNewKey: NSNull.null,
+			RACKeyValueChangeCausedByDeallocationKey: @YES,
+			RACKeyValueChangeAffectedOnlyLastComponentKey: @(keyPathHasOneComponent)
+		};
+
+		RACCompoundDisposable *valueDisposable = value.rac_deallocDisposable;
+		RACDisposable *deallocDisposable = [RACDisposable disposableWithBlock:^{
+			block(nil, change);
+		}];
+
+		[valueDisposable addDisposable:deallocDisposable];
+		[firstComponentDisposable() addDisposable:[RACDisposable disposableWithBlock:^{
+			[valueDisposable removeDisposable:deallocDisposable];
+		}]];
+	};
+
+	// Adds the callback block to the remaining path components on the value. Also
+	// adds the logic to clean up the callbacks to the firstComponentDisposable.
+	void (^addObserverToValue)(NSObject *) = ^(NSObject *value) {
+		@strongify(observer);
+		RACDisposable *observerDisposable = [value rac_observeKeyPath:keyPathTail options:(options & ~NSKeyValueObservingOptionInitial) observer:observer block:block];
+		[firstComponentDisposable() addDisposable:observerDisposable];
+	};
+
+	// Observe only the first key path component, when the value changes clean up
+	// the callbacks on the old value, add callbacks to the new value and call the
+	// callback block as needed.
+	//
+	// Note this does not use NSKeyValueObservingOptionInitial so this only
+	// handles changes to the value, callbacks to the initial value must be added
+	// separately.
+	NSKeyValueObservingOptions trampolineOptions = (options | NSKeyValueObservingOptionPrior) & ~NSKeyValueObservingOptionInitial;
+	RACKVOTrampoline *trampoline = [[RACKVOTrampoline alloc] initWithTarget:self observer:observer keyPath:keyPathHead options:trampolineOptions block:^(id trampolineTarget, id trampolineObserver, NSDictionary *change) {
+		// Prepare the change dictionary by adding the RAC specific keys
+		{
+			NSMutableDictionary *newChange = [change mutableCopy];
+			newChange[RACKeyValueChangeCausedByDeallocationKey] = @NO;
+			newChange[RACKeyValueChangeAffectedOnlyLastComponentKey] = @(keyPathHasOneComponent);
+			change = newChange.copy;
+		}
+
+		// If this is a prior notification, clean up all the callbacks added to the
+		// previous value and call the callback block. Everything else is deferred
+		// until after we get the notification after the change.
+		if ([change[NSKeyValueChangeNotificationIsPriorKey] boolValue]) {
+			[firstComponentDisposable() dispose];
+
+			if ((options & NSKeyValueObservingOptionPrior) != 0) {
+				block([trampolineTarget valueForKeyPath:keyPath], change);
+			}
+
+			return;
+		}
+
+		// From here the notification is not prior.
+		NSObject *value = [trampolineTarget valueForKey:keyPathHead];
+
+		// If the value has changed but is nil, there is no need to add callbacks to
+		// it, just call the callback block.
+		if (value == nil) {
+			block(nil, change);
+			return;
+		}
+
+		// From here the notification is not prior and the value is not nil.
+
+		// Create a new firstComponentDisposable while getting rid of the old one at
+		// the same time, in case this is being called concurrently.
+		RACDisposable *oldFirstComponentDisposable = [firstComponentSerialDisposable swapInDisposable:[RACCompoundDisposable compoundDisposable]];
+		[oldFirstComponentDisposable dispose];
+
+		addDeallocObserverToPropertyValue(trampolineTarget, keyPathHead, value);
+
+		// If there are no further key path components, there is no need to add the
+		// other callbacks, just call the callback block with the value itself.
+		if (keyPathHasOneComponent) {
+			block(value, change);
+			return;
+		}
+
+		// The value has changed, is not nil, and there are more key path components
+		// to consider. Add the callbacks to the value for the remaining key path
+		// components and call the callback block with the current value of the full
+		// key path.
+		addObserverToValue(value);
+		block([value valueForKeyPath:keyPathTail], change);
+	}];
+
+	// Stop the KVO observation when this one is disposed of.
+	[disposable addDisposable:trampoline];
+
+	// Add the callbacks to the initial value if needed.
+	NSObject *value = [self valueForKey:keyPathHead];
+	if (value != nil) {
+		addDeallocObserverToPropertyValue(self, keyPathHead, value);
+
+		if (!keyPathHasOneComponent) {
+			addObserverToValue(value);
+		}
+	}
+
+	// Call the block with the initial value if needed.
+	if ((options & NSKeyValueObservingOptionInitial) != 0) {
+		id initialValue = [self valueForKeyPath:keyPath];
+		NSDictionary *initialChange = @{
+			NSKeyValueChangeKindKey: @(NSKeyValueChangeSetting),
+			NSKeyValueChangeNewKey: initialValue ?: NSNull.null,
+			RACKeyValueChangeCausedByDeallocationKey: @NO,
+			RACKeyValueChangeAffectedOnlyLastComponentKey: @(keyPathHasOneComponent)
+		};
+		block(initialValue, initialChange);
+	}
+
+
+	RACCompoundDisposable *observerDisposable = observer.rac_deallocDisposable;
+	RACCompoundDisposable *selfDisposable = self.rac_deallocDisposable;
+	// Dispose of this observation if the receiver or the observer deallocate.
+	[observerDisposable addDisposable:disposable];
+	[selfDisposable addDisposable:disposable];
+
+	return [RACDisposable disposableWithBlock:^{
+		[disposable dispose];
+		[observerDisposable removeDisposable:disposable];
+		[selfDisposable removeDisposable:disposable];
+	}];
+}
+
+@end
+
+@implementation NSObject (RACKVOWrapperDeprecated)
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-implementations"
+
+- (RACKVOTrampoline *)rac_addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options block:(RACKVOBlock)block {
+	return [[RACKVOTrampoline alloc] initWithTarget:self observer:observer keyPath:keyPath options:options block:block];
+}
+
+#pragma clang diagnostic pop
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACLifting.h b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACLifting.h
new file mode 100644
index 0000000..0feb272
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACLifting.h
@@ -0,0 +1,55 @@
+//
+//  NSObject+RACLifting.h
+//  iOSDemo
+//
+//  Created by Josh Abernathy on 10/13/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+@class RACSignal;
+
+@interface NSObject (RACLifting)
+
+/// Lifts the selector on the receiver into the reactive world. The selector will
+/// be invoked whenever any signal argument sends a value, but only after each
+/// signal has sent an initial value.
+///
+/// It will replay the most recently sent value to new subscribers.
+///
+/// This does not support C arrays or unions.
+///
+/// selector    - The selector on self to invoke.
+/// firstSignal - The signal corresponding to the first method argument. This
+///               must not be nil.
+/// ...         - A list of RACSignals corresponding to the remaining arguments.
+///               There must be a non-nil signal for each method argument.
+///
+/// Examples
+///
+///   [button rac_liftSelector:@selector(setTitleColor:forState:) withSignals:textColorSignal, [RACSignal return:@(UIControlStateNormal)], nil];
+///
+/// Returns a signal which sends the return value from each invocation of the
+/// selector. If the selector returns void, it instead sends RACUnit.defaultUnit.
+/// It completes only after all the signal arguments complete.
+- (RACSignal *)rac_liftSelector:(SEL)selector withSignals:(RACSignal *)firstSignal, ... NS_REQUIRES_NIL_TERMINATION;
+
+/// Like -rac_liftSelector:withSignals:, but accepts an array instead of
+/// a variadic list of arguments.
+- (RACSignal *)rac_liftSelector:(SEL)selector withSignalsFromArray:(NSArray *)signals;
+
+@end
+
+@interface NSObject (RACLiftingDeprecated)
+
+- (RACSignal *)rac_liftSelector:(SEL)selector withObjects:(id)arg, ... __attribute__((deprecated("Use -rac_liftSelector:withSignals: instead")));
+- (RACSignal *)rac_liftSelector:(SEL)selector withObjectsFromArray:(NSArray *)args __attribute__((deprecated("Use -rac_liftSelector:withSignalsFromArray: instead")));
+- (RACSignal *)rac_liftBlock:(id)block withArguments:(id)arg, ... NS_REQUIRES_NIL_TERMINATION __attribute__((deprecated("Use +combineLatest:reduce: instead")));
+- (RACSignal *)rac_liftBlock:(id)block withArgumentsFromArray:(NSArray *)args __attribute__((deprecated("Use +combineLatest:reduce: instead")));
+
+@end
+
+@interface NSObject (RACLiftingUnavailable)
+
+- (instancetype)rac_lift __attribute__((unavailable("Use -rac_liftSelector:withSignals: instead")));
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACLifting.m b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACLifting.m
new file mode 100644
index 0000000..96fea76
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACLifting.m
@@ -0,0 +1,132 @@
+//
+//  NSObject+RACLifting.m
+//  iOSDemo
+//
+//  Created by Josh Abernathy on 10/13/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "NSObject+RACLifting.h"
+#import "EXTScope.h"
+#import "NSInvocation+RACTypeParsing.h"
+#import "NSObject+RACDeallocating.h"
+#import "RACSignal+Operations.h"
+#import "RACTuple.h"
+#import "NSObject+RACDescription.h"
+
+@implementation NSObject (RACLifting)
+
+- (RACSignal *)rac_liftSelector:(SEL)selector withSignalsFromArray:(NSArray *)signals {
+	NSCParameterAssert(selector != NULL);
+	NSCParameterAssert(signals != nil);
+	NSCParameterAssert(signals.count > 0);
+
+	NSMethodSignature *methodSignature = [self methodSignatureForSelector:selector];
+	NSCAssert(methodSignature != nil, @"%@ does not respond to %@", self, NSStringFromSelector(selector));
+
+	NSUInteger numberOfArguments __attribute__((unused)) = methodSignature.numberOfArguments - 2;
+	NSCAssert(numberOfArguments == signals.count, @"Wrong number of signals for %@ (expected %lu, got %lu)", NSStringFromSelector(selector), (unsigned long)numberOfArguments, (unsigned long)signals.count);
+
+	@unsafeify(self);
+
+	return [[[[[RACSignal
+		combineLatest:signals]
+		takeUntil:self.rac_willDeallocSignal]
+		map:^(RACTuple *arguments) {
+			@strongify(self);
+
+			NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:methodSignature];
+			invocation.selector = selector;
+			invocation.rac_argumentsTuple = arguments;
+			[invocation invokeWithTarget:self];
+
+			return invocation.rac_returnValue;
+		}]
+		replayLast]
+		setNameWithFormat:@"%@ -rac_liftSelector: %s withSignalsFromArray: %@", [self rac_description], sel_getName(selector), signals];
+}
+
+- (RACSignal *)rac_liftSelector:(SEL)selector withSignals:(RACSignal *)firstSignal, ... {
+	NSCParameterAssert(firstSignal != nil);
+
+	NSMutableArray *signals = [NSMutableArray array];
+
+	va_list args;
+	va_start(args, firstSignal);
+	for (id currentSignal = firstSignal; currentSignal != nil; currentSignal = va_arg(args, id)) {
+		NSCAssert([currentSignal isKindOfClass:RACSignal.class], @"Argument %@ is not a RACSignal", currentSignal);
+
+		[signals addObject:currentSignal];
+	}
+	va_end(args);
+
+	return [[self
+		rac_liftSelector:selector withSignalsFromArray:signals]
+		setNameWithFormat:@"%@ -rac_liftSelector: %s withSignals: %@", [self rac_description], sel_getName(selector), signals];
+}
+
+@end
+
+@implementation NSObject (RACLiftingDeprecated)
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-implementations"
+
+static NSArray *RACMapArgumentsToSignals(NSArray *args) {
+	NSMutableArray *mappedArgs = [NSMutableArray array];
+	for (id arg in args) {
+		if ([arg isEqual:RACTupleNil.tupleNil]) {
+			[mappedArgs addObject:[RACSignal return:nil]];
+		} else if ([arg isKindOfClass:RACSignal.class]) {
+			[mappedArgs addObject:arg];
+		} else {
+			[mappedArgs addObject:[RACSignal return:arg]];
+		}
+	}
+
+	return mappedArgs;
+}
+
+- (RACSignal *)rac_liftSelector:(SEL)selector withObjects:(id)arg, ... {
+	NSMethodSignature *methodSignature = [self methodSignatureForSelector:selector];
+	NSMutableArray *arguments = [NSMutableArray array];
+
+	va_list args;
+	va_start(args, arg);
+	for (NSUInteger i = 2; i < methodSignature.numberOfArguments; i++) {
+		id currentObject = (i == 2 ? arg : va_arg(args, id));
+		[arguments addObject:currentObject ?: RACTupleNil.tupleNil];
+	}
+
+	va_end(args);
+	return [self rac_liftSelector:selector withObjectsFromArray:arguments];
+}
+
+- (RACSignal *)rac_liftSelector:(SEL)selector withObjectsFromArray:(NSArray *)args {
+	return [self rac_liftSelector:selector withSignalsFromArray:RACMapArgumentsToSignals(args)];
+}
+
+- (RACSignal *)rac_liftBlock:(id)block withArguments:(id)arg, ... {
+	NSMutableArray *arguments = [NSMutableArray array];
+
+	va_list args;
+	va_start(args, arg);
+	for (id currentObject = arg; currentObject != nil; currentObject = va_arg(args, id)) {
+		[arguments addObject:currentObject];
+	}
+
+	va_end(args);
+	return [self rac_liftBlock:block withArgumentsFromArray:arguments];
+}
+
+- (RACSignal *)rac_liftBlock:(id)block withArgumentsFromArray:(NSArray *)args {
+	return [[[[RACSignal
+		combineLatest:RACMapArgumentsToSignals(args)]
+		reduceEach:block]
+		takeUntil:self.rac_willDeallocSignal]
+		replayLast];
+}
+
+#pragma clang diagnostic pop
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACPropertySubscribing.h b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACPropertySubscribing.h
new file mode 100644
index 0000000..2f55195
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACPropertySubscribing.h
@@ -0,0 +1,102 @@
+//
+//  NSObject+RACPropertySubscribing.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 3/2/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "EXTKeyPathCoding.h"
+#import "metamacros.h"
+
+/// Creates a signal which observes `KEYPATH` on `TARGET` for changes.
+///
+/// In either case, the observation continues until `TARGET` _or self_ is
+/// deallocated. If any intermediate object is deallocated instead, it will be
+/// assumed to have been set to nil.
+///
+/// Make sure to `@strongify(self)` when using this macro within a block! The
+/// macro will _always_ reference `self`, which can silently introduce a retain
+/// cycle within a block. As a result, you should make sure that `self` is a weak
+/// reference (e.g., created by `@weakify` and `@strongify`) before the
+/// expression that uses `RACObserve`.
+///
+/// Examples
+///
+///    // Observes self, and doesn't stop until self is deallocated.
+///    RACSignal *selfSignal = RACObserve(self, arrayController.items);
+///
+///    // Observes the array controller, and stops when self _or_ the array
+///    // controller is deallocated.
+///    RACSignal *arrayControllerSignal = RACObserve(self.arrayController, items);
+///
+///    // Observes obj.arrayController, and stops when self _or_ the array
+///    // controller is deallocated.
+///    RACSignal *signal2 = RACObserve(obj.arrayController, items);
+///
+///    @weakify(self);
+///    RACSignal *signal3 = [anotherSignal flattenMap:^(NSArrayController *arrayController) {
+///        // Avoids a retain cycle because of RACObserve implicitly referencing
+///        // self.
+///        @strongify(self);
+///        return RACObserve(arrayController, items);
+///    }];
+///
+/// Returns a signal which sends the current value of the key path on
+/// subscription, then sends the new value every time it changes, and sends
+/// completed if self or observer is deallocated.
+#define RACObserve(TARGET, KEYPATH) \
+    [(id)(TARGET) rac_valuesForKeyPath:@keypath(TARGET, KEYPATH) observer:self]
+
+@class RACDisposable;
+@class RACSignal;
+
+@interface NSObject (RACPropertySubscribing)
+
+/// Creates a signal to observe the value at the given key path.
+///
+/// The initial value is sent on subscription, the subsequent values are sent
+/// from whichever thread the change occured on, even if it doesn't have a valid
+/// scheduler.
+///
+/// Returns a signal that immediately sends the receiver's current value at the
+/// given keypath, then any changes thereafter.
+- (RACSignal *)rac_valuesForKeyPath:(NSString *)keyPath observer:(NSObject *)observer;
+
+/// Creates a signal to observe the changes of the given key path.
+///
+/// The initial value is sent on subscription, the subsequent values are sent
+/// from whichever thread the change occured on, even if it doesn't have a valid
+/// scheduler.
+///
+/// Returns a signal that sends tuples containing the current value at the key
+/// path and the change dictionary for each KVO callback.
+- (RACSignal *)rac_valuesAndChangesForKeyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options observer:(NSObject *)observer;
+
+@end
+
+#define RACAble(...) \
+    metamacro_if_eq(1, metamacro_argcount(__VA_ARGS__)) \
+        (_RACAbleObject(self, __VA_ARGS__)) \
+        (_RACAbleObject(__VA_ARGS__))
+
+#define _RACAbleObject(object, property) [object rac_signalForKeyPath:@keypath(object, property) observer:self]
+
+#define RACAbleWithStart(...) \
+    metamacro_if_eq(1, metamacro_argcount(__VA_ARGS__)) \
+        (_RACAbleWithStartObject(self, __VA_ARGS__)) \
+        (_RACAbleWithStartObject(__VA_ARGS__))
+
+#define _RACAbleWithStartObject(object, property) [object rac_signalWithStartingValueForKeyPath:@keypath(object, property) observer:self]
+
+@interface NSObject (RACPropertySubscribingDeprecated)
+
++ (RACSignal *)rac_signalFor:(NSObject *)object keyPath:(NSString *)keyPath observer:(NSObject *)observer __attribute__((deprecated("Use -rac_valuesForKeyPath:observer: or RACObserve() instead.")));
++ (RACSignal *)rac_signalWithStartingValueFor:(NSObject *)object keyPath:(NSString *)keyPath observer:(NSObject *)observer __attribute__((deprecated("Use -rac_valuesForKeyPath:observer: or RACObserve() instead.")));
++ (RACSignal *)rac_signalWithChangesFor:(NSObject *)object keyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options observer:(NSObject *)observer __attribute__((deprecated("Use -rac_valuesAndChangesForKeyPath:options:observer: instead.")));
+- (RACSignal *)rac_signalForKeyPath:(NSString *)keyPath observer:(NSObject *)observer __attribute__((deprecated("Use -rac_valuesForKeyPath:observer: or RACObserve() instead.")));
+- (RACSignal *)rac_signalWithStartingValueForKeyPath:(NSString *)keyPath observer:(NSObject *)observer __attribute__((deprecated("Use -rac_valuesForKeyPath:observer: or RACObserve() instead.")));
+- (RACDisposable *)rac_deriveProperty:(NSString *)keyPath from:(RACSignal *)signal __attribute__((deprecated("Use -[RACSignal setKeyPath:onObject:] instead")));
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACPropertySubscribing.m b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACPropertySubscribing.m
new file mode 100644
index 0000000..edd2acb
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACPropertySubscribing.m
@@ -0,0 +1,161 @@
+//
+//  NSObject+RACPropertySubscribing.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 3/2/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "NSObject+RACPropertySubscribing.h"
+#import "EXTScope.h"
+#import "NSObject+RACDeallocating.h"
+#import "NSObject+RACDescription.h"
+#import "NSObject+RACKVOWrapper.h"
+#import "RACCompoundDisposable.h"
+#import "RACDisposable.h"
+#import "RACKVOTrampoline.h"
+#import "RACSubscriber.h"
+#import "RACSignal+Operations.h"
+#import "RACTuple.h"
+#import <libkern/OSAtomic.h>
+
+@implementation NSObject (RACPropertySubscribing)
+
+- (RACSignal *)rac_valuesForKeyPath:(NSString *)keyPath observer:(NSObject *)observer {
+	return [[[self
+		rac_valuesAndChangesForKeyPath:keyPath options:NSKeyValueObservingOptionInitial observer:observer]
+		reduceEach:^(id value, NSDictionary *change) {
+			return value;
+		}]
+		setNameWithFormat:@"RACObserve(%@, %@)", self.rac_description, keyPath];
+}
+
+- (RACSignal *)rac_valuesAndChangesForKeyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options observer:(NSObject *)observer {
+	keyPath = [keyPath copy];
+
+	NSRecursiveLock *objectLock = [[NSRecursiveLock alloc] init];
+	objectLock.name = @"com.github.ReactiveCocoa.NSObjectRACPropertySubscribing";
+
+	__block __unsafe_unretained NSObject *unsafeSelf = self;
+	__block __unsafe_unretained NSObject *unsafeObserver = observer;
+
+	RACSignal *deallocSignal = [[RACSignal
+		zip:@[
+			self.rac_willDeallocSignal,
+			observer.rac_willDeallocSignal ?: [RACSignal never]
+		]]
+		doCompleted:^{
+			// Forces deallocation to wait if the object variables are currently
+			// being read on another thread.
+			[objectLock lock];
+			@onExit {
+				[objectLock unlock];
+			};
+
+			unsafeSelf = nil;
+			unsafeObserver = nil;
+		}];
+
+	return [[[RACSignal
+		createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) {
+			// Hold onto the lock the whole time we're setting up the KVO
+			// observation, because any resurrection that might be caused by our
+			// retaining below must be balanced out by the time -dealloc returns
+			// (if another thread is waiting on the lock above).
+			[objectLock lock];
+			@onExit {
+				[objectLock unlock];
+			};
+
+			__strong NSObject *observer __attribute__((objc_precise_lifetime)) = unsafeObserver;
+			__strong NSObject *self __attribute__((objc_precise_lifetime)) = unsafeSelf;
+
+			if (self == nil) {
+				[subscriber sendCompleted];
+				return nil;
+			}
+
+			return [self rac_observeKeyPath:keyPath options:options observer:observer block:^(id value, NSDictionary *change) {
+				[subscriber sendNext:RACTuplePack(value, change)];
+			}];
+		}]
+		takeUntil:deallocSignal]
+		setNameWithFormat:@"%@ -rac_valueAndChangesForKeyPath: %@ options: %lu observer: %@", self.rac_description, keyPath, (unsigned long)options, observer.rac_description];
+}
+
+@end
+
+static RACSignal *signalWithoutChangesFor(Class class, NSObject *object, NSString *keyPath, NSKeyValueObservingOptions options, NSObject *observer) {
+	NSCParameterAssert(object != nil);
+	NSCParameterAssert(keyPath != nil);
+	NSCParameterAssert(observer != nil);
+
+	keyPath = [keyPath copy];
+
+	@unsafeify(object);
+
+	return [[class
+		rac_signalWithChangesFor:object keyPath:keyPath options:options observer:observer]
+		map:^(NSDictionary *change) {
+			@strongify(object);
+			return [object valueForKeyPath:keyPath];
+		}];
+}
+
+@implementation NSObject (RACPropertySubscribingDeprecated)
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-implementations"
+
++ (RACSignal *)rac_signalFor:(NSObject *)object keyPath:(NSString *)keyPath observer:(NSObject *)observer {
+	return signalWithoutChangesFor(self, object, keyPath, 0, observer);
+}
+
++ (RACSignal *)rac_signalWithStartingValueFor:(NSObject *)object keyPath:(NSString *)keyPath observer:(NSObject *)observer {
+	return signalWithoutChangesFor(self, object, keyPath, NSKeyValueObservingOptionInitial, observer);
+}
+
++ (RACSignal *)rac_signalWithChangesFor:(NSObject *)object keyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options observer:(NSObject *)observer {
+	@unsafeify(observer, object);
+	return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+
+		@strongify(observer, object);
+		RACKVOTrampoline *KVOTrampoline = [object rac_addObserver:observer forKeyPath:keyPath options:options block:^(id target, id observer, NSDictionary *change) {
+			[subscriber sendNext:change];
+		}];
+
+		@weakify(subscriber);
+		RACDisposable *deallocDisposable = [RACDisposable disposableWithBlock:^{
+			@strongify(subscriber);
+			[KVOTrampoline dispose];
+			[subscriber sendCompleted];
+		}];
+
+		[observer.rac_deallocDisposable addDisposable:deallocDisposable];
+		[object.rac_deallocDisposable addDisposable:deallocDisposable];
+
+		RACCompoundDisposable *observerDisposable = observer.rac_deallocDisposable;
+		RACCompoundDisposable *objectDisposable = object.rac_deallocDisposable;
+		return [RACDisposable disposableWithBlock:^{
+			[observerDisposable removeDisposable:deallocDisposable];
+			[objectDisposable removeDisposable:deallocDisposable];
+			[KVOTrampoline dispose];
+		}];
+	}] setNameWithFormat:@"RACAble(%@, %@)", object.rac_description, keyPath];
+}
+
+- (RACSignal *)rac_signalForKeyPath:(NSString *)keyPath observer:(NSObject *)observer {
+	return [self.class rac_signalFor:self keyPath:keyPath observer:observer];
+}
+
+- (RACSignal *)rac_signalWithStartingValueForKeyPath:(NSString *)keyPath observer:(NSObject *)observer {
+	return [self.class rac_signalWithStartingValueFor:self keyPath:keyPath observer:observer];
+}
+
+- (RACDisposable *)rac_deriveProperty:(NSString *)keyPath from:(RACSignal *)signal {
+	return [signal setKeyPath:keyPath onObject:self];
+}
+
+#pragma clang diagnostic pop
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACSelectorSignal.h b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACSelectorSignal.h
new file mode 100644
index 0000000..c6f3de5
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACSelectorSignal.h
@@ -0,0 +1,79 @@
+//
+//  NSObject+RACSelectorSignal.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 3/18/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+@class RACSignal;
+
+/// The domain for any errors originating from -rac_signalForSelector:.
+extern NSString * const RACSelectorSignalErrorDomain;
+
+/// -rac_signalForSelector: was going to add a new method implementation for
+/// `selector`, but another thread added an implementation before it was able to.
+///
+/// This will _not_ occur for cases where a method implementation exists before
+/// -rac_signalForSelector: is invoked.
+extern const NSInteger RACSelectorSignalErrorMethodSwizzlingRace;
+
+@interface NSObject (RACSelectorSignal)
+
+/// Creates a signal associated with the receiver, which will send a tuple of the
+/// method's arguments each time the given selector is invoked.
+///
+/// If the selector is already implemented on the receiver, the existing
+/// implementation will be invoked _before_ the signal fires.
+///
+/// If the selector is not yet implemented on the receiver, the injected
+/// implementation will have a `void` return type and accept only object
+/// arguments. Invoking the added implementation with non-object values, or
+/// expecting a return value, will result in undefined behavior.
+///
+/// This is useful for changing an event or delegate callback into a signal. For
+/// example, on an NSView:
+///
+///     [[view rac_signalForSelector:@selector(mouseDown:)] subscribeNext:^(RACTuple *args) {
+///         NSEvent *event = args.first;
+///         NSLog(@"mouse button pressed: %@", event);
+///     }];
+///
+/// selector - The selector for whose invocations are to be observed. If it
+///            doesn't exist, it will be implemented to accept object arguments
+///            and return void. This cannot have C arrays or unions as arguments
+///            or C arrays, unions, structs, complex or vector types as return
+///            type.
+///
+/// Returns a signal which will send a tuple of arguments upon each invocation of
+/// the selector, then completes when the receiver is deallocated. `next` events
+/// will be sent synchronously from the thread that invoked the method. If
+/// a runtime call fails, the signal will send an error in the
+/// RACSelectorSignalErrorDomain.
+- (RACSignal *)rac_signalForSelector:(SEL)selector;
+
+/// Behaves like -rac_signalForSelector:, but if the selector is not yet
+/// implemented on the receiver, its method signature is looked up within
+/// `protocol`, and may accept non-object arguments.
+///
+/// If the selector is not yet implemented and has a return value, the injected
+/// method will return all zero bits (equal to `nil`, `NULL`, 0, 0.0f, etc.).
+///
+/// selector - The selector for whose invocations are to be observed. If it
+///            doesn't exist, it will be implemented using information from
+///            `protocol`, and may accept non-object arguments and return
+///            a value. This cannot have C arrays or unions as arguments or
+///            return type.
+/// protocol - The protocol in which `selector` is declared. This will be used
+///            for type information if the selector is not already implemented on
+///            the receiver. This must not be `NULL`, and `selector` must exist
+///            in this protocol.
+///
+/// Returns a signal which will send a tuple of arguments on each invocation of
+/// the selector, or an error in RACSelectorSignalErrorDomain if a runtime
+/// call fails.
+- (RACSignal *)rac_signalForSelector:(SEL)selector fromProtocol:(Protocol *)protocol;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACSelectorSignal.m b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACSelectorSignal.m
new file mode 100644
index 0000000..4c3aab9
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACSelectorSignal.m
@@ -0,0 +1,322 @@
+//
+//  NSObject+RACSelectorSignal.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 3/18/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "NSObject+RACSelectorSignal.h"
+#import "EXTRuntimeExtensions.h"
+#import "NSInvocation+RACTypeParsing.h"
+#import "NSObject+RACDeallocating.h"
+#import "RACCompoundDisposable.h"
+#import "RACDisposable.h"
+#import "RACObjCRuntime.h"
+#import "RACSubject.h"
+#import "RACTuple.h"
+#import "NSObject+RACDescription.h"
+#import <objc/message.h>
+#import <objc/runtime.h>
+
+NSString * const RACSelectorSignalErrorDomain = @"RACSelectorSignalErrorDomain";
+const NSInteger RACSelectorSignalErrorMethodSwizzlingRace = 1;
+
+static NSString * const RACSignalForSelectorAliasPrefix = @"rac_alias_";
+static NSString * const RACSubclassSuffix = @"_RACSelectorSignal";
+
+static NSMutableSet *swizzledClasses() {
+	static NSMutableSet *set;
+	static dispatch_once_t pred;
+	
+	dispatch_once(&pred, ^{
+		set = [[NSMutableSet alloc] init];
+	});
+
+	return set;
+}
+
+@implementation NSObject (RACSelectorSignal)
+
+static BOOL RACForwardInvocation(id self, NSInvocation *invocation) {
+	SEL aliasSelector = RACAliasForSelector(invocation.selector);
+	RACSubject *subject = objc_getAssociatedObject(self, aliasSelector);
+
+	Class class = object_getClass(invocation.target);
+	BOOL respondsToAlias = [class instancesRespondToSelector:aliasSelector];
+	if (respondsToAlias) {
+		invocation.selector = aliasSelector;
+		[invocation invoke];
+	}
+
+	if (subject == nil) return respondsToAlias;
+
+	[subject sendNext:invocation.rac_argumentsTuple];
+	return YES;
+}
+
+static void RACSwizzleForwardInvocation(Class class) {
+	SEL forwardInvocationSEL = @selector(forwardInvocation:);
+	Method forwardInvocationMethod = class_getInstanceMethod(class, forwardInvocationSEL);
+
+	// Preserve any existing implementation of -forwardInvocation:.
+	void (*originalForwardInvocation)(id, SEL, NSInvocation *) = NULL;
+	if (forwardInvocationMethod != NULL) {
+		originalForwardInvocation = (__typeof__(originalForwardInvocation))method_getImplementation(forwardInvocationMethod);
+	}
+
+	// Set up a new version of -forwardInvocation:.
+	//
+	// If the selector has been passed to -rac_signalForSelector:, invoke
+	// the aliased method, and forward the arguments to any attached signals.
+	//
+	// If the selector has not been passed to -rac_signalForSelector:,
+	// invoke any existing implementation of -forwardInvocation:. If there
+	// was no existing implementation, throw an unrecognized selector
+	// exception.
+	id newForwardInvocation = ^(id self, NSInvocation *invocation) {
+		BOOL matched = RACForwardInvocation(self, invocation);
+		if (matched) return;
+
+		if (originalForwardInvocation == NULL) {
+			[self doesNotRecognizeSelector:invocation.selector];
+		} else {
+			originalForwardInvocation(self, forwardInvocationSEL, invocation);
+		}
+	};
+
+	class_replaceMethod(class, forwardInvocationSEL, imp_implementationWithBlock(newForwardInvocation), "v@:@");
+}
+
+static void RACSwizzleRespondsToSelector(Class class) {
+	SEL respondsToSelectorSEL = @selector(respondsToSelector:);
+
+	// Preserve existing implementation of -respondsToSelector:.
+	Method respondsToSelectorMethod = class_getInstanceMethod(class, respondsToSelectorSEL);
+	BOOL (*originalRespondsToSelector)(id, SEL, SEL) = (__typeof__(originalRespondsToSelector))method_getImplementation(respondsToSelectorMethod);
+
+	// Set up a new version of -respondsToSelector: that returns YES for methods
+	// added by -rac_signalForSelector:.
+	//
+	// If the selector has a method defined on the receiver's actual class, and
+	// if that method's implementation is _objc_msgForward, then returns whether
+	// the instance has a signal for the selector.
+	// Otherwise, call the original -respondsToSelector:.
+	id newRespondsToSelector = ^ BOOL (id self, SEL selector) {
+		Method method = rac_getImmediateInstanceMethod(object_getClass(self), selector);
+
+		if (method != NULL && method_getImplementation(method) == _objc_msgForward) {
+			SEL aliasSelector = RACAliasForSelector(selector);
+			return objc_getAssociatedObject(self, aliasSelector) != nil;
+		}
+
+		return originalRespondsToSelector(self, respondsToSelectorSEL, selector);
+	};
+
+	class_replaceMethod(class, respondsToSelectorSEL, imp_implementationWithBlock(newRespondsToSelector), method_getTypeEncoding(respondsToSelectorMethod));
+}
+
+static void RACSwizzleGetClass(Class class, Class statedClass) {
+	SEL selector = @selector(class);
+	Method method = class_getInstanceMethod(class, selector);
+	IMP newIMP = imp_implementationWithBlock(^(id self) {
+		return statedClass;
+	});
+	class_replaceMethod(class, selector, newIMP, method_getTypeEncoding(method));
+}
+
+static void RACSwizzleMethodSignatureForSelector(Class class) {
+	IMP newIMP = imp_implementationWithBlock(^(id self, SEL selector) {
+		// Don't send the -class message to the receiver because we've changed
+		// that to return the original class.
+		Class actualClass = object_getClass(self);
+		Method method = class_getInstanceMethod(actualClass, selector);
+		if (method == NULL) {
+			// Messages that the original class dynamically implements fall
+			// here.
+			//
+			// Call the original class' -methodSignatureForSelector:.
+			struct objc_super target = {
+				.super_class = class_getSuperclass(class),
+				.receiver = self,
+			};
+			NSMethodSignature * (*messageSend)(struct objc_super *, SEL, SEL) = (__typeof__(messageSend))objc_msgSendSuper;
+			return messageSend(&target, @selector(methodSignatureForSelector:), selector);
+		}
+
+		char const *encoding = method_getTypeEncoding(method);
+		return [NSMethodSignature signatureWithObjCTypes:encoding];
+	});
+
+	SEL selector = @selector(methodSignatureForSelector:);
+	Method methodSignatureForSelectorMethod = class_getInstanceMethod(class, selector);
+	class_replaceMethod(class, selector, newIMP, method_getTypeEncoding(methodSignatureForSelectorMethod));
+}
+
+// It's hard to tell which struct return types use _objc_msgForward, and
+// which use _objc_msgForward_stret instead, so just exclude all struct, array,
+// union, complex and vector return types.
+static void RACCheckTypeEncoding(const char *typeEncoding) {
+#if !NS_BLOCK_ASSERTIONS
+	// Some types, including vector types, are not encoded. In these cases the
+	// signature starts with the size of the argument frame.
+	NSCAssert(*typeEncoding < '1' || *typeEncoding > '9', @"unknown method return type not supported in type encoding: %s", typeEncoding);
+	NSCAssert(strstr(typeEncoding, "(") != typeEncoding, @"union method return type not supported");
+	NSCAssert(strstr(typeEncoding, "{") != typeEncoding, @"struct method return type not supported");
+	NSCAssert(strstr(typeEncoding, "[") != typeEncoding, @"array method return type not supported");
+	NSCAssert(strstr(typeEncoding, @encode(_Complex float)) != typeEncoding, @"complex float method return type not supported");
+	NSCAssert(strstr(typeEncoding, @encode(_Complex double)) != typeEncoding, @"complex double method return type not supported");
+	NSCAssert(strstr(typeEncoding, @encode(_Complex long double)) != typeEncoding, @"complex long double method return type not supported");
+
+#endif // !NS_BLOCK_ASSERTIONS
+}
+
+static RACSignal *NSObjectRACSignalForSelector(NSObject *self, SEL selector, Protocol *protocol) {
+	SEL aliasSelector = RACAliasForSelector(selector);
+
+	@synchronized (self) {
+		RACSubject *subject = objc_getAssociatedObject(self, aliasSelector);
+		if (subject != nil) return subject;
+
+		Class class = RACSwizzleClass(self);
+		NSCAssert(class != nil, @"Could not swizzle class of %@", self);
+
+		subject = [[RACSubject subject] setNameWithFormat:@"%@ -rac_signalForSelector: %s", self.rac_description, sel_getName(selector)];
+		objc_setAssociatedObject(self, aliasSelector, subject, OBJC_ASSOCIATION_RETAIN);
+
+		[self.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+			[subject sendCompleted];
+		}]];
+
+		Method targetMethod = class_getInstanceMethod(class, selector);
+		if (targetMethod == NULL) {
+			const char *typeEncoding;
+			if (protocol == NULL) {
+				typeEncoding = RACSignatureForUndefinedSelector(selector);
+			} else {
+				// Look for the selector as an optional instance method.
+				struct objc_method_description methodDescription = protocol_getMethodDescription(protocol, selector, NO, YES);
+
+				if (methodDescription.name == NULL) {
+					// Then fall back to looking for a required instance
+					// method.
+					methodDescription = protocol_getMethodDescription(protocol, selector, YES, YES);
+					NSCAssert(methodDescription.name != NULL, @"Selector %@ does not exist in <%s>", NSStringFromSelector(selector), protocol_getName(protocol));
+				}
+
+				typeEncoding = methodDescription.types;
+			}
+
+			RACCheckTypeEncoding(typeEncoding);
+
+			// Define the selector to call -forwardInvocation:.
+			if (!class_addMethod(class, selector, _objc_msgForward, typeEncoding)) {
+				NSDictionary *userInfo = @{
+					NSLocalizedDescriptionKey: [NSString stringWithFormat:NSLocalizedString(@"A race condition occurred implementing %@ on class %@", nil), NSStringFromSelector(selector), class],
+					NSLocalizedRecoverySuggestionErrorKey: NSLocalizedString(@"Invoke -rac_signalForSelector: again to override the implementation.", nil)
+				};
+
+				return [RACSignal error:[NSError errorWithDomain:RACSelectorSignalErrorDomain code:RACSelectorSignalErrorMethodSwizzlingRace userInfo:userInfo]];
+			}
+		} else if (method_getImplementation(targetMethod) != _objc_msgForward) {
+			// Make a method alias for the existing method implementation.
+			const char *typeEncoding = method_getTypeEncoding(targetMethod);
+
+			RACCheckTypeEncoding(typeEncoding);
+
+			BOOL addedAlias __attribute__((unused)) = class_addMethod(class, aliasSelector, method_getImplementation(targetMethod), typeEncoding);
+			NSCAssert(addedAlias, @"Original implementation for %@ is already copied to %@ on %@", NSStringFromSelector(selector), NSStringFromSelector(aliasSelector), class);
+
+			// Redefine the selector to call -forwardInvocation:.
+			class_replaceMethod(class, selector, _objc_msgForward, method_getTypeEncoding(targetMethod));
+		}
+
+		return subject;
+	}
+}
+
+static SEL RACAliasForSelector(SEL originalSelector) {
+	NSString *selectorName = NSStringFromSelector(originalSelector);
+	return NSSelectorFromString([RACSignalForSelectorAliasPrefix stringByAppendingString:selectorName]);
+}
+
+static const char *RACSignatureForUndefinedSelector(SEL selector) {
+	const char *name = sel_getName(selector);
+	NSMutableString *signature = [NSMutableString stringWithString:@"v@:"];
+
+	while ((name = strchr(name, ':')) != NULL) {
+		[signature appendString:@"@"];
+		name++;
+	}
+
+	return signature.UTF8String;
+}
+
+static Class RACSwizzleClass(NSObject *self) {
+	Class statedClass = self.class;
+	Class baseClass = object_getClass(self);
+	NSString *className = NSStringFromClass(baseClass);
+
+	if ([className hasSuffix:RACSubclassSuffix]) {
+		return baseClass;
+	} else if (statedClass != baseClass) {
+		// If the class is already lying about what it is, it's probably a KVO
+		// dynamic subclass or something else that we shouldn't subclass
+		// ourselves.
+		//
+		// Just swizzle -forwardInvocation: in-place. Since the object's class
+		// was almost certainly dynamically changed, we shouldn't see another of
+		// these classes in the hierarchy.
+		//
+		// Additionally, swizzle -respondsToSelector: because the default
+		// implementation may be ignorant of methods added to this class.
+		@synchronized (swizzledClasses()) {
+			if (![swizzledClasses() containsObject:className]) {
+				RACSwizzleForwardInvocation(baseClass);
+				RACSwizzleRespondsToSelector(baseClass);
+				RACSwizzleGetClass(baseClass, statedClass);
+				RACSwizzleGetClass(object_getClass(baseClass), statedClass);
+				RACSwizzleMethodSignatureForSelector(baseClass);
+				[swizzledClasses() addObject:className];
+			}
+		}
+
+		return baseClass;
+	}
+
+	const char *subclassName = [className stringByAppendingString:RACSubclassSuffix].UTF8String;
+	Class subclass = objc_getClass(subclassName);
+
+	if (subclass == nil) {
+		subclass = [RACObjCRuntime createClass:subclassName inheritingFromClass:baseClass];
+		if (subclass == nil) return nil;
+
+		RACSwizzleForwardInvocation(subclass);
+		RACSwizzleRespondsToSelector(subclass);
+
+		RACSwizzleGetClass(subclass, statedClass);
+		RACSwizzleGetClass(object_getClass(subclass), statedClass);
+
+		RACSwizzleMethodSignatureForSelector(subclass);
+
+		objc_registerClassPair(subclass);
+	}
+
+	object_setClass(self, subclass);
+	return subclass;
+}
+
+- (RACSignal *)rac_signalForSelector:(SEL)selector {
+	NSCParameterAssert(selector != NULL);
+
+	return NSObjectRACSignalForSelector(self, selector, NULL);
+}
+
+- (RACSignal *)rac_signalForSelector:(SEL)selector fromProtocol:(Protocol *)protocol {
+	NSCParameterAssert(selector != NULL);
+	NSCParameterAssert(protocol != NULL);
+
+	return NSObjectRACSignalForSelector(self, selector, protocol);
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSOrderedSet+RACSequenceAdditions.h b/ReactiveCocoaFramework/ReactiveCocoa/NSOrderedSet+RACSequenceAdditions.h
new file mode 100644
index 0000000..8bea2db
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSOrderedSet+RACSequenceAdditions.h
@@ -0,0 +1,20 @@
+//
+//  NSOrderedSet+RACSequenceAdditions.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-10-29.
+//  Copyright (c) 2012 GitHub. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+@class RACSequence;
+
+@interface NSOrderedSet (RACSequenceAdditions)
+
+/// Creates and returns a sequence corresponding to the receiver.
+///
+/// Mutating the receiver will not affect the sequence after it's been created.
+@property (nonatomic, copy, readonly) RACSequence *rac_sequence;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSOrderedSet+RACSequenceAdditions.m b/ReactiveCocoaFramework/ReactiveCocoa/NSOrderedSet+RACSequenceAdditions.m
new file mode 100644
index 0000000..55dfd0b
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSOrderedSet+RACSequenceAdditions.m
@@ -0,0 +1,19 @@
+//
+//  NSOrderedSet+RACSequenceAdditions.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-10-29.
+//  Copyright (c) 2012 GitHub. All rights reserved.
+//
+
+#import "NSOrderedSet+RACSequenceAdditions.h"
+#import "NSArray+RACSequenceAdditions.h"
+
+@implementation NSOrderedSet (RACSequenceAdditions)
+
+- (RACSequence *)rac_sequence {
+	// TODO: First class support for ordered set sequences.
+	return self.array.rac_sequence;
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSSet+RACSequenceAdditions.h b/ReactiveCocoaFramework/ReactiveCocoa/NSSet+RACSequenceAdditions.h
new file mode 100644
index 0000000..6665501
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSSet+RACSequenceAdditions.h
@@ -0,0 +1,20 @@
+//
+//  NSSet+RACSequenceAdditions.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-10-29.
+//  Copyright (c) 2012 GitHub. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+@class RACSequence;
+
+@interface NSSet (RACSequenceAdditions)
+
+/// Creates and returns a sequence corresponding to the receiver.
+///
+/// Mutating the receiver will not affect the sequence after it's been created.
+@property (nonatomic, copy, readonly) RACSequence *rac_sequence;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSSet+RACSequenceAdditions.m b/ReactiveCocoaFramework/ReactiveCocoa/NSSet+RACSequenceAdditions.m
new file mode 100644
index 0000000..cc07f75
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSSet+RACSequenceAdditions.m
@@ -0,0 +1,19 @@
+//
+//  NSSet+RACSequenceAdditions.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-10-29.
+//  Copyright (c) 2012 GitHub. All rights reserved.
+//
+
+#import "NSSet+RACSequenceAdditions.h"
+#import "NSArray+RACSequenceAdditions.h"
+
+@implementation NSSet (RACSequenceAdditions)
+
+- (RACSequence *)rac_sequence {
+	// TODO: First class support for set sequences.
+	return self.allObjects.rac_sequence;
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACKeyPathUtilities.h b/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACKeyPathUtilities.h
new file mode 100644
index 0000000..d56cf59
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACKeyPathUtilities.h
@@ -0,0 +1,34 @@
+//
+//  NSString+RACKeyPathUtilities.h
+//  ReactiveCocoa
+//
+//  Created by Uri Baghin on 05/05/2013.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+// A private category of methods to extract parts of a key path.
+@interface NSString (RACKeyPathUtilities)
+
+// Returns an array of the components of the receiver.
+//
+// Calling this method on a string that isn't a key path is considered undefined
+// behavior.
+- (NSArray *)rac_keyPathComponents;
+
+// Returns a key path with all the components of the receiver except for the
+// last one.
+//
+// Calling this method on a string that isn't a key path is considered undefined
+// behavior.
+- (NSString *)rac_keyPathByDeletingLastKeyPathComponent;
+
+// Returns a key path with all the components of the receiver expect for the
+// first one.
+//
+// Calling this method on a string that isn't a key path is considered undefined
+// behavior.
+- (NSString *)rac_keyPathByDeletingFirstKeyPathComponent;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACKeyPathUtilities.m b/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACKeyPathUtilities.m
new file mode 100644
index 0000000..63a100c
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACKeyPathUtilities.m
@@ -0,0 +1,36 @@
+//
+//  NSString+RACKeyPathUtilities.m
+//  ReactiveCocoa
+//
+//  Created by Uri Baghin on 05/05/2013.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "NSString+RACKeyPathUtilities.h"
+
+@implementation NSString (RACKeyPathUtilities)
+
+- (NSArray *)rac_keyPathComponents {
+	if (self.length == 0) {
+		return nil;
+	}
+	return [self componentsSeparatedByString:@"."];
+}
+
+- (NSString *)rac_keyPathByDeletingLastKeyPathComponent {
+	NSUInteger lastDotIndex = [self rangeOfString:@"." options:NSBackwardsSearch].location;
+	if (lastDotIndex == NSNotFound) {
+		return nil;
+	}
+	return [self substringToIndex:lastDotIndex];
+}
+
+- (NSString *)rac_keyPathByDeletingFirstKeyPathComponent {
+	NSUInteger firstDotIndex = [self rangeOfString:@"."].location;
+	if (firstDotIndex == NSNotFound) {
+		return nil;
+	}
+	return [self substringFromIndex:firstDotIndex + 1];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACSequenceAdditions.h b/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACSequenceAdditions.h
new file mode 100644
index 0000000..0116231
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACSequenceAdditions.h
@@ -0,0 +1,21 @@
+//
+//  NSString+RACSequenceAdditions.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-10-29.
+//  Copyright (c) 2012 GitHub. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+@class RACSequence;
+
+@interface NSString (RACSequenceAdditions)
+
+/// Creates and returns a sequence containing strings corresponding to each
+/// composed character sequence in the receiver.
+///
+/// Mutating the receiver will not affect the sequence after it's been created.
+@property (nonatomic, copy, readonly) RACSequence *rac_sequence;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACSequenceAdditions.m b/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACSequenceAdditions.m
new file mode 100644
index 0000000..eb6a76e
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACSequenceAdditions.m
@@ -0,0 +1,18 @@
+//
+//  NSString+RACSequenceAdditions.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-10-29.
+//  Copyright (c) 2012 GitHub. All rights reserved.
+//
+
+#import "NSString+RACSequenceAdditions.h"
+#import "RACStringSequence.h"
+
+@implementation NSString (RACSequenceAdditions)
+
+- (RACSequence *)rac_sequence {
+	return [RACStringSequence sequenceWithString:self offset:0];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACSupport.h
new file mode 100644
index 0000000..d904a4c
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACSupport.h
@@ -0,0 +1,22 @@
+//
+//  NSString+RACSupport.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 5/11/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+@class RACSignal;
+@class RACScheduler;
+
+@interface NSString (RACSupport)
+
+// Reads in the contents of the file using +[NSString stringWithContentsOfURL:usedEncoding:error:].
+// Note that encoding won't be valid until the signal completes successfully.
+//
+// scheduler - cannot be nil.
++ (RACSignal *)rac_readContentsOfURL:(NSURL *)URL usedEncoding:(NSStringEncoding *)encoding scheduler:(RACScheduler *)scheduler;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACSupport.m
new file mode 100644
index 0000000..c6ebe0b
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACSupport.m
@@ -0,0 +1,35 @@
+//
+//  NSString+RACSupport.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 5/11/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "NSString+RACSupport.h"
+#import "RACReplaySubject.h"
+#import "RACScheduler.h"
+
+@implementation NSString (RACSupport)
+
++ (RACSignal *)rac_readContentsOfURL:(NSURL *)URL usedEncoding:(NSStringEncoding *)encoding scheduler:(RACScheduler *)scheduler {
+	NSCParameterAssert(scheduler != nil);
+	
+	RACReplaySubject *subject = [RACReplaySubject subject];
+	[subject setNameWithFormat:@"+rac_readContentsOfURL: %@ usedEncoding:scheduler: %@", URL, scheduler];
+	
+	[scheduler schedule:^{
+		NSError *error = nil;
+		NSString *string = [NSString stringWithContentsOfURL:URL usedEncoding:encoding error:&error];
+		if(string == nil) {
+			[subject sendError:error];
+		} else {
+			[subject sendNext:string];
+			[subject sendCompleted];
+		}
+	}];
+	
+	return subject;
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSText+RACSignalSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/NSText+RACSignalSupport.h
new file mode 100644
index 0000000..e3fc8ed
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSText+RACSignalSupport.h
@@ -0,0 +1,19 @@
+//
+//  NSText+RACSignalSupport.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-03-08.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <Cocoa/Cocoa.h>
+
+@class RACSignal;
+
+@interface NSText (RACSignalSupport)
+
+/// Returns a signal which sends the current `string` of the receiver, then the
+/// new value any time it changes.
+- (RACSignal *)rac_textSignal;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSText+RACSignalSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/NSText+RACSignalSupport.m
new file mode 100644
index 0000000..7e63f2a
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSText+RACSignalSupport.m
@@ -0,0 +1,38 @@
+//
+//  NSText+RACSignalSupport.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-03-08.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "NSText+RACSignalSupport.h"
+#import "EXTScope.h"
+#import "RACDisposable.h"
+#import "RACSignal.h"
+#import "RACSubscriber.h"
+#import "NSObject+RACDescription.h"
+
+@implementation NSText (RACSignalSupport)
+
+- (RACSignal *)rac_textSignal {
+	@unsafeify(self);
+	return [[[[RACSignal
+		createSignal:^(id<RACSubscriber> subscriber) {
+			@strongify(self);
+			id observer = [NSNotificationCenter.defaultCenter addObserverForName:NSTextDidChangeNotification object:self queue:nil usingBlock:^(NSNotification *note) {
+				[subscriber sendNext:note.object];
+			}];
+
+			return [RACDisposable disposableWithBlock:^{
+				[NSNotificationCenter.defaultCenter removeObserver:observer];
+			}];
+		}]
+		map:^(NSText *text) {
+			return [text.string copy];
+		}]
+		startWith:[self.string copy]]
+		setNameWithFormat:@"%@ -rac_textSignal", [self rac_description]];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSURLConnection+RACSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/NSURLConnection+RACSupport.h
new file mode 100644
index 0000000..e9bf04f
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSURLConnection+RACSupport.h
@@ -0,0 +1,25 @@
+//
+//  NSURLConnection+RACSupport.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-10-01.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+@class RACSignal;
+
+@interface NSURLConnection (RACSupport)
+
+// Lazily loads data for the given request in the background.
+//
+// request - The URL request to load. This must not be nil.
+//
+// Returns a signal which will begin loading the request upon each subscription,
+// then send a `RACTuple` of the received `NSURLResponse` and downloaded
+// `NSData`, and complete on a background thread. If any errors occur, the
+// returned signal will error out.
++ (RACSignal *)rac_sendAsynchronousRequest:(NSURLRequest *)request;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSURLConnection+RACSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/NSURLConnection+RACSupport.m
new file mode 100644
index 0000000..3eaa2c3
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSURLConnection+RACSupport.m
@@ -0,0 +1,53 @@
+//
+//  NSURLConnection+RACSupport.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-10-01.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "NSURLConnection+RACSupport.h"
+#import "RACDisposable.h"
+#import "RACSignal.h"
+#import "RACSignal+Operations.h"
+#import "RACSubscriber.h"
+#import "RACTuple.h"
+
+@implementation NSURLConnection (RACSupport)
+
++ (RACSignal *)rac_sendAsynchronousRequest:(NSURLRequest *)request {
+	NSCParameterAssert(request != nil);
+
+	return [[RACSignal
+		createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) {
+			NSOperationQueue *queue = [[NSOperationQueue alloc] init];
+			queue.name = @"com.github.ReactiveCocoa.NSURLConnectionRACSupport";
+
+			[NSURLConnection sendAsynchronousRequest:request queue:queue completionHandler:^(NSURLResponse *response, NSData *data, NSError *error) {
+				// The docs say that `nil` data means an error occurred, but
+				// `nil` responses can also occur in practice (circumstances
+				// unknown). Consider either to be an error.
+				//
+				// Note that _empty_ data is not necessarily erroneous, as there
+				// may be headers but no HTTP body.
+				if (response == nil || data == nil) {
+					[subscriber sendError:error];
+				} else {
+					[subscriber sendNext:RACTuplePack(response, data)];
+					[subscriber sendCompleted];
+				}
+			}];
+
+			return [RACDisposable disposableWithBlock:^{
+				// It's not clear if this will actually cancel the connection,
+				// but we can at least prevent _some_ unnecessary work --
+				// without writing all the code for a proper delegate, which
+				// doesn't really belong in RAC.
+				queue.suspended = YES;
+				[queue cancelAllOperations];
+			}];
+		}]
+		setNameWithFormat:@"+rac_sendAsynchronousRequest: %@", request];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSUserDefaults+RACSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/NSUserDefaults+RACSupport.h
new file mode 100644
index 0000000..8482fb3
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSUserDefaults+RACSupport.h
@@ -0,0 +1,27 @@
+//
+//  NSUserDefaults+RACSupport.h
+//  ReactiveCocoa
+//
+//  Created by Matt Diephouse on 12/19/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+@class RACChannelTerminal;
+
+@interface NSUserDefaults (RACSupport)
+
+/// Creates and returns a terminal for binding the user defaults key.
+///
+/// **Note:** The value in the user defaults is *asynchronously* updated with
+/// values sent to the channel.
+///
+/// key - The user defaults key to create the channel terminal for.
+///
+/// Returns a channel terminal that sends the value of the user defaults key
+/// upon subscription, sends an updated value whenever the default changes, and
+/// updates the default asynchronously with values it receives.
+- (RACChannelTerminal *)rac_channelTerminalForKey:(NSString *)key;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSUserDefaults+RACSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/NSUserDefaults+RACSupport.m
new file mode 100644
index 0000000..a8624a1
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/NSUserDefaults+RACSupport.m
@@ -0,0 +1,58 @@
+//
+//  NSUserDefaults+RACSupport.m
+//  ReactiveCocoa
+//
+//  Created by Matt Diephouse on 12/19/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "NSUserDefaults+RACSupport.h"
+
+#import "EXTScope.h"
+#import "RACChannel.h"
+#import "RACScheduler.h"
+#import "RACSignal+Operations.h"
+#import "NSNotificationCenter+RACSupport.h"
+#import "NSObject+RACDeallocating.h"
+#import "NSObject+RACLifting.h"
+
+@implementation NSUserDefaults (RACSupport)
+
+- (RACChannelTerminal *)rac_channelTerminalForKey:(NSString *)key {
+	RACChannel *channel = [RACChannel new];
+	
+	RACScheduler *scheduler = [RACScheduler scheduler];
+	__block BOOL ignoreNextValue = NO;
+	
+	@weakify(self);
+	[[[[[[[NSNotificationCenter.defaultCenter
+		rac_addObserverForName:NSUserDefaultsDidChangeNotification object:self]
+		map:^(id _) {
+			@strongify(self);
+			return [self objectForKey:key];
+		}]
+		startWith:[self objectForKey:key]]
+		// Don't send values that were set on the other side of the terminal.
+		filter:^ BOOL (id _) {
+			if (RACScheduler.currentScheduler == scheduler && ignoreNextValue) {
+				ignoreNextValue = NO;
+				return NO;
+			}
+			return YES;
+		}]
+		distinctUntilChanged]
+		takeUntil:self.rac_willDeallocSignal]
+		subscribe:channel.leadingTerminal];
+	
+	[[channel.leadingTerminal
+		deliverOn:scheduler]
+		subscribeNext:^(id value) {
+			@strongify(self);
+			ignoreNextValue = YES;
+			[self setObject:value forKey:key];
+		}];
+	
+	return channel.followingTerminal;
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACArraySequence.h b/ReactiveCocoaFramework/ReactiveCocoa/RACArraySequence.h
new file mode 100644
index 0000000..e9d948e
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACArraySequence.h
@@ -0,0 +1,18 @@
+//
+//  RACArraySequence.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-10-29.
+//  Copyright (c) 2012 GitHub. All rights reserved.
+//
+
+#import "RACSequence.h"
+
+// Private class that adapts an array to the RACSequence interface.
+@interface RACArraySequence : RACSequence
+
+// Returns a sequence for enumerating over the given array, starting from the
+// given offset. The array will be copied to prevent mutation.
++ (instancetype)sequenceWithArray:(NSArray *)array offset:(NSUInteger)offset;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACArraySequence.m b/ReactiveCocoaFramework/ReactiveCocoa/RACArraySequence.m
new file mode 100644
index 0000000..f7ca69d
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACArraySequence.m
@@ -0,0 +1,125 @@
+//
+//  RACArraySequence.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-10-29.
+//  Copyright (c) 2012 GitHub. All rights reserved.
+//
+
+#import "RACArraySequence.h"
+
+@interface RACArraySequence ()
+
+// Redeclared from the superclass and marked deprecated to prevent using `array`
+// where `backingArray` is intended.
+@property (nonatomic, copy, readonly) NSArray *array __attribute__((deprecated));
+
+// The array being sequenced.
+@property (nonatomic, copy, readonly) NSArray *backingArray;
+
+// The index in the array from which the sequence starts.
+@property (nonatomic, assign, readonly) NSUInteger offset;
+
+@end
+
+@implementation RACArraySequence
+
+#pragma mark Lifecycle
+
++ (instancetype)sequenceWithArray:(NSArray *)array offset:(NSUInteger)offset {
+	NSCParameterAssert(offset <= array.count);
+
+	if (offset == array.count) return self.empty;
+
+	RACArraySequence *seq = [[self alloc] init];
+	seq->_backingArray = [array copy];
+	seq->_offset = offset;
+	return seq;
+}
+
+#pragma mark RACSequence
+
+- (id)head {
+	return [self.backingArray objectAtIndex:self.offset];
+}
+
+- (RACSequence *)tail {
+	RACSequence *sequence = [self.class sequenceWithArray:self.backingArray offset:self.offset + 1];
+	sequence.name = self.name;
+	return sequence;
+}
+
+#pragma mark NSFastEnumeration
+
+- (NSUInteger)countByEnumeratingWithState:(NSFastEnumerationState *)state objects:(__unsafe_unretained id[])stackbuf count:(NSUInteger)len {
+	NSCParameterAssert(len > 0);
+
+	if (state->state >= self.backingArray.count) {
+		// Enumeration has completed.
+		return 0;
+	}
+
+	if (state->state == 0) {
+		state->state = self.offset;
+
+		// Since a sequence doesn't mutate, this just needs to be set to
+		// something non-NULL.
+		state->mutationsPtr = state->extra;
+	}
+
+	state->itemsPtr = stackbuf;
+
+	NSUInteger startIndex = state->state;
+	NSUInteger index = 0;
+
+	for (id value in self.backingArray) {
+		// Constructing an index set for -enumerateObjectsAtIndexes: can actually be
+		// slower than just skipping the items we don't care about.
+		if (index < startIndex) {
+			++index;
+			continue;
+		}
+
+		stackbuf[index - startIndex] = value;
+
+		++index;
+		if (index - startIndex >= len) break;
+	}
+
+	NSCAssert(index > startIndex, @"Final index (%lu) should be greater than start index (%lu)", (unsigned long)index, (unsigned long)startIndex);
+
+	state->state = index;
+	return index - startIndex;
+}
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-implementations"
+- (NSArray *)array {
+	return [self.backingArray subarrayWithRange:NSMakeRange(self.offset, self.backingArray.count - self.offset)];
+}
+#pragma clang diagnostic pop
+
+#pragma mark NSCoding
+
+- (id)initWithCoder:(NSCoder *)coder {
+	self = [super initWithCoder:coder];
+	if (self == nil) return nil;
+
+	_backingArray = [coder decodeObjectForKey:@"array"];
+	_offset = 0;
+
+	return self;
+}
+
+- (void)encodeWithCoder:(NSCoder *)coder {
+	// Encoding is handled in RACSequence.
+	[super encodeWithCoder:coder];
+}
+
+#pragma mark NSObject
+
+- (NSString *)description {
+	return [NSString stringWithFormat:@"<%@: %p>{ name = %@, array = %@ }", self.class, self, self.name, self.backingArray];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACBacktrace.h b/ReactiveCocoaFramework/ReactiveCocoa/RACBacktrace.h
new file mode 100644
index 0000000..8588c80
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACBacktrace.h
@@ -0,0 +1,70 @@
+//
+//  RACBacktrace.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-08-20.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#ifdef DEBUG
+
+extern void rac_dispatch_async(dispatch_queue_t queue, dispatch_block_t block);
+extern void rac_dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t block);
+extern void rac_dispatch_after(dispatch_time_t time, dispatch_queue_t queue, dispatch_block_t block);
+extern void rac_dispatch_async_f(dispatch_queue_t queue, void *context, dispatch_function_t function);
+extern void rac_dispatch_barrier_async_f(dispatch_queue_t queue, void *context, dispatch_function_t function);
+extern void rac_dispatch_after_f(dispatch_time_t time, dispatch_queue_t queue, void *context, dispatch_function_t function);
+
+#define dispatch_async rac_dispatch_async
+#define dispatch_barrier_async rac_dispatch_barrier_async
+#define dispatch_after rac_dispatch_after
+#define dispatch_async_f rac_dispatch_async_f
+#define dispatch_barrier_async_f rac_dispatch_barrier_async_f
+#define dispatch_after_f rac_dispatch_after_f
+
+/// Preserves backtraces across asynchronous calls.
+///
+/// On OS X, you can enable the automatic capturing of asynchronous backtraces
+/// (in Debug builds) by setting the `DYLD_INSERT_LIBRARIES` environment variable
+/// to `@executable_path/../Frameworks/ReactiveCocoa.framework/ReactiveCocoa` in
+/// your scheme's Run action settings.
+///
+/// On iOS, your project and RAC will automatically use the `rac_` GCD functions
+/// (declared above) for asynchronous work. Unfortunately, unlike OS X, it's
+/// impossible to capture backtraces inside NSOperationQueue or other code
+/// outside of your project.
+///
+/// Once backtraces are being captured, you can `po [RACBacktrace backtrace]` in
+/// the debugger to print them out at any time. You can even set up an alias in
+/// ~/.lldbinit to do so:
+///
+///    command alias racbt po [RACBacktrace backtrace]
+/// 
+@interface RACBacktrace : NSObject
+
+/// The backtrace from any previous thread.
+@property (nonatomic, strong, readonly) RACBacktrace *previousThreadBacktrace;
+
+/// The call stack of this backtrace's thread.
+@property (nonatomic, copy, readonly) NSArray *callStackSymbols;
+
+/// Captures the current thread's backtrace, appending it to any backtrace from
+/// a previous thread.
++ (instancetype)backtrace;
+
+/// Same as +backtrace, but omits the specified number of frames at the
+/// top of the stack (in addition to this method itself).
++ (instancetype)backtraceIgnoringFrames:(NSUInteger)ignoreCount;
+
+@end
+
+#else
+
+#define rac_dispatch_async dispatch_async
+#define rac_dispatch_barrier_async dispatch_barrier_async
+#define rac_dispatch_after dispatch_after
+#define rac_dispatch_async_f dispatch_async_f
+#define rac_dispatch_barrier_async_f dispatch_barrier_async_f
+#define rac_dispatch_after_f dispatch_after_f
+
+#endif
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACBacktrace.m b/ReactiveCocoaFramework/ReactiveCocoa/RACBacktrace.m
new file mode 100644
index 0000000..c2724d4
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACBacktrace.m
@@ -0,0 +1,249 @@
+//
+//  RACBacktrace.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-08-16.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import <execinfo.h>
+#import <pthread.h>
+#import "RACBacktrace.h"
+
+#define RAC_BACKTRACE_MAX_CALL_STACK_FRAMES 128
+
+#ifdef DEBUG
+
+// Undefine the macros that hide the real GCD functions.
+#undef dispatch_async
+#undef dispatch_barrier_async
+#undef dispatch_after
+#undef dispatch_async_f
+#undef dispatch_barrier_async_f
+#undef dispatch_after_f
+
+@interface RACBacktrace () {
+	void *_callStackAddresses[RAC_BACKTRACE_MAX_CALL_STACK_FRAMES];
+	int _callStackSize;
+}
+
+@property (nonatomic, strong, readwrite) RACBacktrace *previousThreadBacktrace;
+@end
+
+@interface RACDispatchInfo : NSObject
+
+// The recorded backtrace.
+@property (nonatomic, strong, readonly) RACBacktrace *backtrace;
+
+// The information for the original dispatch.
+@property (nonatomic, readonly) dispatch_function_t function;
+@property (nonatomic, readonly) void *context;
+@property (nonatomic, readonly) dispatch_queue_t queue;
+
+- (id)initWithQueue:(dispatch_queue_t)queue function:(dispatch_function_t)function context:(void *)context;
+
+@end
+
+// Function for use with dispatch_async_f and friends, which will save the
+// backtrace onto the current queue, then call through to the original dispatch.
+static void RACTraceDispatch (void *ptr) {
+	// Balance out the retain necessary for async calls.
+	RACDispatchInfo *info __attribute__((objc_precise_lifetime)) = CFBridgingRelease(ptr);
+
+	dispatch_queue_set_specific(info.queue, (void *)pthread_self(), (__bridge void *)info.backtrace, NULL);
+	info.function(info.context);
+	dispatch_queue_set_specific(info.queue, (void *)pthread_self(), NULL, NULL);
+}
+
+// Always inline this function, for consistency in backtraces.
+__attribute__((always_inline))
+static dispatch_block_t RACBacktraceBlock (dispatch_queue_t queue, dispatch_block_t block) {
+	RACBacktrace *backtrace = [RACBacktrace backtrace];
+
+	return [^{
+		RACBacktrace *backtraceKeptAlive __attribute__((objc_precise_lifetime)) = backtrace;
+
+		dispatch_queue_set_specific(queue, (void *)pthread_self(), (__bridge void *)backtraceKeptAlive, NULL);
+		block();
+		dispatch_queue_set_specific(queue, (void *)pthread_self(), NULL, NULL);
+	} copy];
+}
+
+void rac_dispatch_async(dispatch_queue_t queue, dispatch_block_t block) {
+	dispatch_async(queue, RACBacktraceBlock(queue, block));
+}
+
+void rac_dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t block) {
+	dispatch_barrier_async(queue, RACBacktraceBlock(queue, block));
+}
+
+void rac_dispatch_after(dispatch_time_t time, dispatch_queue_t queue, dispatch_block_t block) {
+	dispatch_after(time, queue, RACBacktraceBlock(queue, block));
+}
+
+void rac_dispatch_async_f(dispatch_queue_t queue, void *context, dispatch_function_t function) {
+	RACDispatchInfo *info = [[RACDispatchInfo alloc] initWithQueue:queue function:function context:context];
+	dispatch_async_f(queue, (void *)CFBridgingRetain(info), &RACTraceDispatch);
+}
+
+void rac_dispatch_barrier_async_f(dispatch_queue_t queue, void *context, dispatch_function_t function) {
+	RACDispatchInfo *info = [[RACDispatchInfo alloc] initWithQueue:queue function:function context:context];
+	dispatch_barrier_async_f(queue, (void *)CFBridgingRetain(info), &RACTraceDispatch);
+}
+
+void rac_dispatch_after_f(dispatch_time_t time, dispatch_queue_t queue, void *context, dispatch_function_t function) {
+	RACDispatchInfo *info = [[RACDispatchInfo alloc] initWithQueue:queue function:function context:context];
+	dispatch_after_f(time, queue, (void *)CFBridgingRetain(info), &RACTraceDispatch);
+}
+
+// This is what actually performs the injection.
+//
+// The DYLD_INSERT_LIBRARIES environment variable must include the RAC dynamic
+// library in order for this to work.
+__attribute__((used)) static struct { const void *replacement; const void *replacee; } interposers[] __attribute__((section("__DATA,__interpose"))) = {
+	{ (const void *)&rac_dispatch_async, (const void *)&dispatch_async },
+	{ (const void *)&rac_dispatch_barrier_async, (const void *)&dispatch_barrier_async },
+	{ (const void *)&rac_dispatch_after, (const void *)&dispatch_after },
+	{ (const void *)&rac_dispatch_async_f, (const void *)&dispatch_async_f },
+	{ (const void *)&rac_dispatch_barrier_async_f, (const void *)&dispatch_barrier_async_f },
+	{ (const void *)&rac_dispatch_after_f, (const void *)&dispatch_after_f },
+};
+
+static void RACSignalHandler (int sig) {
+	NSLog(@"Backtrace: %@", [RACBacktrace backtrace]);
+	fflush(stdout);
+
+	// Restore the default action and raise the signal again.
+	signal(sig, SIG_DFL);
+	raise(sig);
+}
+
+static void RACExceptionHandler (NSException *ex) {
+	NSLog(@"Uncaught exception %@", ex);
+	NSLog(@"Backtrace: %@", [RACBacktrace backtrace]);
+	fflush(stdout);
+}
+
+@implementation RACBacktrace
+
+#pragma mark Properties
+
+- (NSArray *)callStackSymbols {
+	if (_callStackSize == 0) return @[];
+
+	char **symbols = backtrace_symbols(_callStackAddresses, _callStackSize);
+	NSMutableArray *array = [NSMutableArray arrayWithCapacity:(NSUInteger)_callStackSize];
+
+	for (int i = 0; i < _callStackSize; i++) {
+		NSString *str = @(symbols[i]);
+		[array addObject:str];
+	}
+
+	free(symbols);
+	return array;
+}
+
+#pragma mark Lifecycle
+
++ (void)load {
+	@autoreleasepool {
+		NSString *libraries = [[[NSProcessInfo processInfo] environment] objectForKey:@"DYLD_INSERT_LIBRARIES"];
+
+		// Don't install our handlers if we're not actually intercepting function
+		// calls.
+		if ([libraries rangeOfString:@"ReactiveCocoa"].length == 0) return;
+
+		NSLog(@"*** Enabling asynchronous backtraces");
+
+		NSSetUncaughtExceptionHandler(&RACExceptionHandler);
+	}
+
+	signal(SIGILL, &RACSignalHandler);
+	signal(SIGTRAP, &RACSignalHandler);
+	signal(SIGABRT, &RACSignalHandler);
+	signal(SIGFPE, &RACSignalHandler);
+	signal(SIGBUS, &RACSignalHandler);
+	signal(SIGSEGV, &RACSignalHandler);
+	signal(SIGSYS, &RACSignalHandler);
+	signal(SIGPIPE, &RACSignalHandler);
+}
+
+- (void)dealloc {
+	__autoreleasing RACBacktrace *previous __attribute__((unused)) = self.previousThreadBacktrace;
+	self.previousThreadBacktrace = nil;
+}
+
+#pragma mark Backtraces
+
++ (instancetype)backtrace {
+	return [self backtraceIgnoringFrames:1];
+}
+
++ (instancetype)backtraceIgnoringFrames:(NSUInteger)ignoreCount {
+	@autoreleasepool {
+		RACBacktrace *oldBacktrace = (__bridge id)dispatch_get_specific((void *)pthread_self());
+
+		RACBacktrace *newBacktrace = [[RACBacktrace alloc] init];
+		newBacktrace.previousThreadBacktrace = oldBacktrace;
+
+		int size = backtrace(newBacktrace->_callStackAddresses, RAC_BACKTRACE_MAX_CALL_STACK_FRAMES);
+
+		// Omit this method plus however many others from the backtrace.
+		++ignoreCount;
+		if ((NSUInteger)size > ignoreCount) {
+			memmove(newBacktrace->_callStackAddresses, newBacktrace->_callStackAddresses + ignoreCount, ((NSUInteger)size - ignoreCount) * sizeof(char *));
+			size -= (int)ignoreCount;
+		}
+
+		newBacktrace->_callStackSize = size;
+		return newBacktrace;
+	}
+}
+
+#pragma mark NSObject
+
+- (NSString *)description {
+	NSString *str = [NSString stringWithFormat:@"%@", self.callStackSymbols];
+	if (self.previousThreadBacktrace != nil) {
+		str = [str stringByAppendingFormat:@"\n\n... asynchronously invoked from: %@", self.previousThreadBacktrace];
+	}
+
+	return str;
+}
+
+@end
+
+@implementation RACDispatchInfo
+
+#pragma mark Lifecycle
+
+- (id)initWithQueue:(dispatch_queue_t)queue function:(dispatch_function_t)function context:(void *)context {
+	@autoreleasepool {
+		NSCParameterAssert(queue != NULL);
+		NSCParameterAssert(function != NULL);
+
+		self = [super init];
+		if (self == nil) return nil;
+
+		_backtrace = [RACBacktrace backtraceIgnoringFrames:1];
+
+		dispatch_retain(queue);
+		_queue = queue;
+
+		_function = function;
+		_context = context;
+
+		return self;
+	}
+}
+
+- (void)dealloc {
+	if (_queue != NULL) {
+		dispatch_release(_queue);
+		_queue = NULL;
+	}
+}
+
+@end
+
+#endif
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACBehaviorSubject.h b/ReactiveCocoaFramework/ReactiveCocoa/RACBehaviorSubject.h
new file mode 100644
index 0000000..2f9e0db
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACBehaviorSubject.h
@@ -0,0 +1,19 @@
+//
+//  RACBehaviorSubject.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 3/16/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSubject.h"
+
+
+/// A behavior subject sends the last value it received when it is subscribed to.
+@interface RACBehaviorSubject : RACSubject
+
+/// Creates a new behavior subject with a default value. If it hasn't received
+/// any values when it gets subscribed to, it sends the default value.
++ (instancetype)behaviorSubjectWithDefaultValue:(id)value;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACBehaviorSubject.m b/ReactiveCocoaFramework/ReactiveCocoa/RACBehaviorSubject.m
new file mode 100644
index 0000000..dfda2ac
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACBehaviorSubject.m
@@ -0,0 +1,56 @@
+//
+//  RACBehaviorSubject.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 3/16/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACBehaviorSubject.h"
+#import "RACDisposable.h"
+#import "RACScheduler+Private.h"
+
+@interface RACBehaviorSubject ()
+
+// This property should only be used while synchronized on self.
+@property (nonatomic, strong) id currentValue;
+
+@end
+
+@implementation RACBehaviorSubject
+
+#pragma mark Lifecycle
+
++ (instancetype)behaviorSubjectWithDefaultValue:(id)value {
+	RACBehaviorSubject *subject = [self subject];
+	subject.currentValue = value;
+	return subject;
+}
+
+#pragma mark RACSignal
+
+- (RACDisposable *)subscribe:(id<RACSubscriber>)subscriber {
+	RACDisposable *subscriptionDisposable = [super subscribe:subscriber];
+
+	RACDisposable *schedulingDisposable = [RACScheduler.subscriptionScheduler schedule:^{
+		@synchronized (self) {
+			[subscriber sendNext:self.currentValue];
+		}
+	}];
+	
+	return [RACDisposable disposableWithBlock:^{
+		[subscriptionDisposable dispose];
+		[schedulingDisposable dispose];
+	}];
+}
+
+#pragma mark RACSubscriber
+
+- (void)sendNext:(id)value {
+	@synchronized (self) {
+		self.currentValue = value;
+		[super sendNext:value];
+	}
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACBlockTrampoline.h b/ReactiveCocoaFramework/ReactiveCocoa/RACBlockTrampoline.h
new file mode 100644
index 0000000..3857d7c
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACBlockTrampoline.h
@@ -0,0 +1,30 @@
+//
+//  RACBlockTrampoline.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 10/21/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+@class RACTuple;
+
+// A private class that allows a limited type of dynamic block invocation.
+@interface RACBlockTrampoline : NSObject
+
+// Invokes the given block with the given arguments. All of the block's
+// argument types must be objects and it must be typed to return an object.
+//
+// At this time, it only supports blocks that take up to 15 arguments. Any more
+// is just cray.
+//
+// block     - The block to invoke. Must accept as many arguments as are given in
+//             the arguments array. Cannot be nil.
+// arguments - The arguments with which to invoke the block. `RACTupleNil`s will
+//             be passed as nils.
+//
+// Returns the return value of invoking the block.
++ (id)invokeBlock:(id)block withArguments:(RACTuple *)arguments;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACBlockTrampoline.m b/ReactiveCocoaFramework/ReactiveCocoa/RACBlockTrampoline.m
new file mode 100644
index 0000000..07903dd
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACBlockTrampoline.m
@@ -0,0 +1,156 @@
+//
+//  RACBlockTrampoline.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 10/21/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACBlockTrampoline.h"
+#import "RACTuple.h"
+
+@interface RACBlockTrampoline ()
+@property (nonatomic, readonly, copy) id block;
+@end
+
+@implementation RACBlockTrampoline
+
+#pragma mark API
+
+- (id)initWithBlock:(id)block {
+	self = [super init];
+	if (self == nil) return nil;
+
+	_block = [block copy];
+
+	return self;
+}
+
++ (id)invokeBlock:(id)block withArguments:(RACTuple *)arguments {
+	NSCParameterAssert(block != NULL);
+
+	RACBlockTrampoline *trampoline = [[self alloc] initWithBlock:block];
+	return [trampoline invokeWithArguments:arguments];
+}
+
+- (id)invokeWithArguments:(RACTuple *)arguments {
+	SEL selector = [self selectorForArgumentCount:arguments.count];
+	NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:[self methodSignatureForSelector:selector]];
+	invocation.selector = selector;
+	invocation.target = self;
+
+	for (NSUInteger i = 0; i < arguments.count; i++) {
+		id arg = arguments[i];
+		NSInteger argIndex = (NSInteger)(i + 2);
+		[invocation setArgument:&arg atIndex:argIndex];
+	}
+
+	[invocation invoke];
+	
+	__unsafe_unretained id returnVal;
+	[invocation getReturnValue:&returnVal];
+	return returnVal;
+}
+
+- (SEL)selectorForArgumentCount:(NSUInteger)count {
+	NSCParameterAssert(count > 0);
+
+	switch (count) {
+		case 0: return NULL;
+		case 1: return @selector(performWith:);
+		case 2: return @selector(performWith::);
+		case 3: return @selector(performWith:::);
+		case 4: return @selector(performWith::::);
+		case 5: return @selector(performWith:::::);
+		case 6: return @selector(performWith::::::);
+		case 7: return @selector(performWith:::::::);
+		case 8: return @selector(performWith::::::::);
+		case 9: return @selector(performWith:::::::::);
+		case 10: return @selector(performWith::::::::::);
+		case 11: return @selector(performWith:::::::::::);
+		case 12: return @selector(performWith::::::::::::);
+		case 13: return @selector(performWith:::::::::::::);
+		case 14: return @selector(performWith::::::::::::::);
+		case 15: return @selector(performWith:::::::::::::::);
+	}
+
+	NSCAssert(NO, @"The argument count is too damn high! Only blocks of up to 15 arguments are currently supported.");
+	return NULL;
+}
+
+- (id)performWith:(id)obj1 {
+	id (^block)(id) = self.block;
+	return block(obj1);
+}
+
+- (id)performWith:(id)obj1 :(id)obj2 {
+	id (^block)(id, id) = self.block;
+	return block(obj1, obj2);
+}
+
+- (id)performWith:(id)obj1 :(id)obj2 :(id)obj3 {
+	id (^block)(id, id, id) = self.block;
+	return block(obj1, obj2, obj3);
+}
+
+- (id)performWith:(id)obj1 :(id)obj2 :(id)obj3 :(id)obj4 {
+	id (^block)(id, id, id, id) = self.block;
+	return block(obj1, obj2, obj3, obj4);
+}
+
+- (id)performWith:(id)obj1 :(id)obj2 :(id)obj3 :(id)obj4 :(id)obj5 {
+	id (^block)(id, id, id, id, id) = self.block;
+	return block(obj1, obj2, obj3, obj4, obj5);
+}
+
+- (id)performWith:(id)obj1 :(id)obj2 :(id)obj3 :(id)obj4 :(id)obj5 :(id)obj6 {
+	id (^block)(id, id, id, id, id, id) = self.block;
+	return block(obj1, obj2, obj3, obj4, obj5, obj6);
+}
+
+- (id)performWith:(id)obj1 :(id)obj2 :(id)obj3 :(id)obj4 :(id)obj5 :(id)obj6 :(id)obj7 {
+	id (^block)(id, id, id, id, id, id, id) = self.block;
+	return block(obj1, obj2, obj3, obj4, obj5, obj6, obj7);
+}
+
+- (id)performWith:(id)obj1 :(id)obj2 :(id)obj3 :(id)obj4 :(id)obj5 :(id)obj6 :(id)obj7 :(id)obj8 {
+	id (^block)(id, id, id, id, id, id, id, id) = self.block;
+	return block(obj1, obj2, obj3, obj4, obj5, obj6, obj7, obj8);
+}
+
+- (id)performWith:(id)obj1 :(id)obj2 :(id)obj3 :(id)obj4 :(id)obj5 :(id)obj6 :(id)obj7 :(id)obj8 :(id)obj9 {
+	id (^block)(id, id, id, id, id, id, id, id, id) = self.block;
+	return block(obj1, obj2, obj3, obj4, obj5, obj6, obj7, obj8, obj9);
+}
+
+- (id)performWith:(id)obj1 :(id)obj2 :(id)obj3 :(id)obj4 :(id)obj5 :(id)obj6 :(id)obj7 :(id)obj8 :(id)obj9 :(id)obj10 {
+	id (^block)(id, id, id, id, id, id, id, id, id, id) = self.block;
+	return block(obj1, obj2, obj3, obj4, obj5, obj6, obj7, obj8, obj9, obj10);
+}
+
+- (id)performWith:(id)obj1 :(id)obj2 :(id)obj3 :(id)obj4 :(id)obj5 :(id)obj6 :(id)obj7 :(id)obj8 :(id)obj9 :(id)obj10 :(id)obj11 {
+	id (^block)(id, id, id, id, id, id, id, id, id, id, id) = self.block;
+	return block(obj1, obj2, obj3, obj4, obj5, obj6, obj7, obj8, obj9, obj10, obj11);
+}
+
+- (id)performWith:(id)obj1 :(id)obj2 :(id)obj3 :(id)obj4 :(id)obj5 :(id)obj6 :(id)obj7 :(id)obj8 :(id)obj9 :(id)obj10 :(id)obj11 :(id)obj12 {
+	id (^block)(id, id, id, id, id, id, id, id, id, id, id, id) = self.block;
+	return block(obj1, obj2, obj3, obj4, obj5, obj6, obj7, obj8, obj9, obj10, obj11, obj12);
+}
+
+- (id)performWith:(id)obj1 :(id)obj2 :(id)obj3 :(id)obj4 :(id)obj5 :(id)obj6 :(id)obj7 :(id)obj8 :(id)obj9 :(id)obj10 :(id)obj11 :(id)obj12 :(id)obj13 {
+	id (^block)(id, id, id, id, id, id, id, id, id, id, id, id, id) = self.block;
+	return block(obj1, obj2, obj3, obj4, obj5, obj6, obj7, obj8, obj9, obj10, obj11, obj12, obj13);
+}
+
+- (id)performWith:(id)obj1 :(id)obj2 :(id)obj3 :(id)obj4 :(id)obj5 :(id)obj6 :(id)obj7 :(id)obj8 :(id)obj9 :(id)obj10 :(id)obj11 :(id)obj12 :(id)obj13 :(id)obj14 {
+	id (^block)(id, id, id, id, id, id, id, id, id, id, id, id, id, id) = self.block;
+	return block(obj1, obj2, obj3, obj4, obj5, obj6, obj7, obj8, obj9, obj10, obj11, obj12, obj13, obj14);
+}
+
+- (id)performWith:(id)obj1 :(id)obj2 :(id)obj3 :(id)obj4 :(id)obj5 :(id)obj6 :(id)obj7 :(id)obj8 :(id)obj9 :(id)obj10 :(id)obj11 :(id)obj12 :(id)obj13 :(id)obj14 :(id)obj15 {
+	id (^block)(id, id, id, id, id, id, id, id, id, id, id, id, id, id, id) = self.block;
+	return block(obj1, obj2, obj3, obj4, obj5, obj6, obj7, obj8, obj9, obj10, obj11, obj12, obj13, obj14, obj15);
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACChannel.h b/ReactiveCocoaFramework/ReactiveCocoa/RACChannel.h
new file mode 100644
index 0000000..ef1d6f1
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACChannel.h
@@ -0,0 +1,70 @@
+//
+//  RACChannel.h
+//  ReactiveCocoa
+//
+//  Created by Uri Baghin on 01/01/2013.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSignal.h"
+#import "RACSubscriber.h"
+
+@class RACChannelTerminal;
+
+/// A two-way channel.
+///
+/// Conceptually, RACChannel can be thought of as a bidirectional connection,
+/// composed of two controllable signals that work in parallel.
+///
+/// For example, when connecting between a view and a model:
+///
+///        Model                      View
+///  `leadingTerminal` ------> `followingTerminal`
+///  `leadingTerminal` <------ `followingTerminal`
+///
+/// The initial value of the model and all future changes to it are _sent on_ the
+/// `leadingTerminal`, and _received by_ subscribers of the `followingTerminal`.
+///
+/// Likewise, whenever the user changes the value of the view, that value is sent
+/// on the `followingTerminal`, and received in the model from the
+/// `leadingTerminal`. However, the initial value of the view is not received
+/// from the `leadingTerminal` (only future changes).
+@interface RACChannel : NSObject
+
+/// The terminal which "leads" the channel, by sending its latest value
+/// immediately to new subscribers of the `followingTerminal`.
+///
+/// New subscribers to this terminal will not receive a starting value, but will
+/// receive all future values that are sent to the `followingTerminal`.
+@property (nonatomic, strong, readonly) RACChannelTerminal *leadingTerminal;
+
+/// The terminal which "follows" the lead of the other terminal, only sending
+/// _future_ values to the subscribers of the `leadingTerminal`.
+///
+/// The latest value sent to the `leadingTerminal` (if any) will be sent
+/// immediately to new subscribers of this terminal, and then all future values
+/// as well.
+@property (nonatomic, strong, readonly) RACChannelTerminal *followingTerminal;
+
+@end
+
+/// Represents one end of a RACChannel.
+///
+/// An terminal is similar to a socket or pipe -- it represents one end of
+/// a connection (the RACChannel, in this case). Values sent to this terminal
+/// will _not_ be received by its subscribers. Instead, the values will be sent
+/// to the subscribers of the RACChannel's _other_ terminal.
+///
+/// For example, when using the `followingTerminal`, _sent_ values can only be
+/// _received_ from the `leadingTerminal`, and vice versa.
+///
+/// To make it easy to terminate a RACChannel, `error` and `completed` events
+/// sent to either terminal will be received by the subscribers of _both_
+/// terminals.
+///
+/// Do not instantiate this class directly. Create a RACChannel instead.
+@interface RACChannelTerminal : RACSignal <RACSubscriber>
+
+- (id)init __attribute__((unavailable("Instantiate a RACChannel instead")));
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACChannel.m b/ReactiveCocoaFramework/ReactiveCocoa/RACChannel.m
new file mode 100644
index 0000000..7222858
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACChannel.m
@@ -0,0 +1,91 @@
+//
+//  RACChannel.m
+//  ReactiveCocoa
+//
+//  Created by Uri Baghin on 01/01/2013.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACChannel.h"
+#import "RACDisposable.h"
+#import "RACReplaySubject.h"
+#import "RACSignal+Operations.h"
+#import "RACUnit.h"
+
+@interface RACChannelTerminal ()
+
+// The values for this terminal.
+@property (nonatomic, strong, readonly) RACSignal *values;
+
+// A subscriber will will send values to the other terminal.
+@property (nonatomic, strong, readonly) id<RACSubscriber> otherTerminal;
+
+- (id)initWithValues:(RACSignal *)values otherTerminal:(id<RACSubscriber>)otherTerminal;
+
+@end
+
+@implementation RACChannel
+
+- (id)init {
+	self = [super init];
+	if (self == nil) return nil;
+
+	// We don't want any starting value from the leadingSubject, but we do want
+	// error and completion to be replayed.
+	RACReplaySubject *leadingSubject = [[RACReplaySubject replaySubjectWithCapacity:0] setNameWithFormat:@"leadingSubject"];
+	RACReplaySubject *followingSubject = [[RACReplaySubject replaySubjectWithCapacity:1] setNameWithFormat:@"followingSubject"];
+
+	// Propagate errors and completion to everything.
+	[[leadingSubject ignoreValues] subscribe:followingSubject];
+	[[followingSubject ignoreValues] subscribe:leadingSubject];
+
+	_leadingTerminal = [[[RACChannelTerminal alloc] initWithValues:leadingSubject otherTerminal:followingSubject] setNameWithFormat:@"leadingTerminal"];
+	_followingTerminal = [[[RACChannelTerminal alloc] initWithValues:followingSubject otherTerminal:leadingSubject] setNameWithFormat:@"followingTerminal"];
+
+	return self;
+}
+
+@end
+
+@implementation RACChannelTerminal
+
+#pragma mark Lifecycle
+
+- (id)initWithValues:(RACSignal *)values otherTerminal:(id<RACSubscriber>)otherTerminal {
+	NSCParameterAssert(values != nil);
+	NSCParameterAssert(otherTerminal != nil);
+
+	self = [super init];
+	if (self == nil) return nil;
+
+	_values = values;
+	_otherTerminal = otherTerminal;
+
+	return self;
+}
+
+#pragma mark RACSignal
+
+- (RACDisposable *)subscribe:(id<RACSubscriber>)subscriber {
+	return [self.values subscribe:subscriber];
+}
+
+#pragma mark <RACSubscriber>
+
+- (void)sendNext:(id)value {
+	[self.otherTerminal sendNext:value];
+}
+
+- (void)sendError:(NSError *)error {
+	[self.otherTerminal sendError:error];
+}
+
+- (void)sendCompleted {
+	[self.otherTerminal sendCompleted];
+}
+
+- (void)didSubscribeWithDisposable:(RACCompoundDisposable *)disposable {
+	[self.otherTerminal didSubscribeWithDisposable:disposable];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACCommand.h b/ReactiveCocoaFramework/ReactiveCocoa/RACCommand.h
new file mode 100644
index 0000000..653d46b
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACCommand.h
@@ -0,0 +1,123 @@
+//
+//  RACCommand.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 3/3/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+@class RACSignal;
+
+/// The domain for errors originating within `RACCommand`.
+extern NSString * const RACCommandErrorDomain;
+
+/// -execute: was invoked while the command was disabled.
+extern const NSInteger RACCommandErrorNotEnabled;
+
+/// A `userInfo` key for an error, associated with the `RACCommand` that the
+/// error originated from.
+///
+/// This is included only when the error code is `RACCommandErrorNotEnabled`.
+extern NSString * const RACUnderlyingCommandErrorKey;
+
+/// A command is a signal triggered in response to some action, typically
+/// UI-related.
+@interface RACCommand : NSObject
+
+/// A signal of the signals returned by successful invocations of -execute:
+/// (i.e., while the receiver is `enabled`).
+///
+/// Errors will be automatically caught upon the inner signals, and sent upon
+/// `errors` instead. If you _want_ to receive inner errors, use -execute: or
+/// -[RACSignal materialize].
+/// 
+/// Only executions that begin _after_ subscription will be sent upon this
+/// signal. All inner signals will arrive upon the main thread.
+@property (nonatomic, strong, readonly) RACSignal *executionSignals;
+
+/// A signal of whether this command is currently executing.
+///
+/// This will send YES whenever -execute: is invoked and the created signal has
+/// not yet terminated. Once all executions have terminated, `executing` will
+/// send NO.
+///
+/// This signal will send its current value upon subscription, and then all
+/// future values on the main thread.
+@property (nonatomic, strong, readonly) RACSignal *executing;
+
+/// A signal of whether this command is able to execute.
+///
+/// This will send NO if:
+///
+///  - The command was created with an `enabledSignal`, and NO is sent upon that
+///    signal, or
+///  - `allowsConcurrentExecution` is NO and the command has started executing.
+///
+/// Once the above conditions are no longer met, the signal will send YES.
+///
+/// This signal will send its current value upon subscription, and then all
+/// future values on the main thread.
+@property (nonatomic, strong, readonly) RACSignal *enabled;
+
+/// Forwards any errors that occur within signals returned by -execute:.
+///
+/// When an error occurs on a signal returned from -execute:, this signal will
+/// send the associated NSError value as a `next` event (since an `error` event
+/// would terminate the stream).
+///
+/// After subscription, this signal will send all future errors on the main
+/// thread.
+@property (nonatomic, strong, readonly) RACSignal *errors;
+
+/// Whether the command allows multiple executions to proceed concurrently.
+///
+/// The default value for this property is NO.
+@property (atomic, assign) BOOL allowsConcurrentExecution;
+
+/// Invokes -initWithEnabled:signalBlock: with a nil `enabledSignal`.
+- (id)initWithSignalBlock:(RACSignal * (^)(id input))signalBlock;
+
+/// Initializes a command that is conditionally enabled.
+///
+/// This is the designated initializer for this class.
+///
+/// enabledSignal - A signal of BOOLs which indicate whether the command should
+///                 be enabled. `enabled` will be based on the latest value sent
+///                 from this signal. Before any values are sent, `enabled` will
+///                 default to YES. This argument may be nil.
+/// signalBlock   - A block which will map each input value (passed to -execute:)
+///                 to a signal of work. The returned signal will be multicasted
+///                 to a replay subject, sent on `executionSignals`, then
+///                 subscribed to synchronously. Neither the block nor the
+///                 returned signal may be nil.
+- (id)initWithEnabled:(RACSignal *)enabledSignal signalBlock:(RACSignal * (^)(id input))signalBlock;
+
+/// If the receiver is enabled, this method will:
+///
+///  1. Invoke the `signalBlock` given at the time of initialization.
+///  2. Multicast the returned signal to a RACReplaySubject.
+///  3. Send the multicasted signal on `executionSignals`.
+///  4. Subscribe (connect) to the original signal on the main thread.
+///
+/// input - The input value to pass to the receiver's `signalBlock`. This may be
+///         nil.
+///
+/// Returns the multicasted signal, after subscription. If the receiver is not
+/// enabled, returns a signal that will send an error with code
+/// RACCommandErrorNotEnabled.
+- (RACSignal *)execute:(id)input;
+
+@end
+
+@interface RACCommand (Unavailable)
+
+@property (atomic, readonly) BOOL canExecute __attribute__((unavailable("Use the 'enabled' signal instead")));
+
++ (instancetype)command __attribute__((unavailable("Use -initWithSignalBlock: instead")));
++ (instancetype)commandWithCanExecuteSignal:(RACSignal *)canExecuteSignal __attribute__((unavailable("Use -initWithEnabled:signalBlock: instead")));
+- (id)initWithCanExecuteSignal:(RACSignal *)canExecuteSignal __attribute__((unavailable("Use -initWithEnabled:signalBlock: instead")));
+- (RACSignal *)addSignalBlock:(RACSignal * (^)(id value))signalBlock __attribute__((unavailable("Pass the signalBlock to -initWithSignalBlock: instead")));
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACCommand.m b/ReactiveCocoaFramework/ReactiveCocoa/RACCommand.m
new file mode 100644
index 0000000..0bc864b
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACCommand.m
@@ -0,0 +1,268 @@
+//
+//  RACCommand.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 3/3/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACCommand.h"
+#import "EXTScope.h"
+#import "NSArray+RACSequenceAdditions.h"
+#import "NSObject+RACDeallocating.h"
+#import "NSObject+RACDescription.h"
+#import "NSObject+RACPropertySubscribing.h"
+#import "RACMulticastConnection.h"
+#import "RACReplaySubject.h"
+#import "RACScheduler.h"
+#import "RACSequence.h"
+#import "RACSerialDisposable.h"
+#import "RACSignal+Operations.h"
+#import <libkern/OSAtomic.h>
+
+NSString * const RACCommandErrorDomain = @"RACCommandErrorDomain";
+NSString * const RACUnderlyingCommandErrorKey = @"RACUnderlyingCommandErrorKey";
+
+const NSInteger RACCommandErrorNotEnabled = 1;
+
+@interface RACCommand () {
+	// The mutable array backing `activeExecutionSignals`.
+	//
+	// This should only be used while synchronized on `self`.
+	NSMutableArray *_activeExecutionSignals;
+
+	// Atomic backing variable for `allowsConcurrentExecution`.
+	volatile uint32_t _allowsConcurrentExecution;
+}
+
+// An array of signals representing in-flight executions, in the order they
+// began.
+//
+// This property is KVO-compliant.
+@property (atomic, copy, readonly) NSArray *activeExecutionSignals;
+
+// `enabled`, but without a hop to the main thread.
+//
+// Values from this signal may arrive on any thread.
+@property (nonatomic, strong, readonly) RACSignal *immediateEnabled;
+
+// The signal block that the receiver was initialized with.
+@property (nonatomic, copy, readonly) RACSignal * (^signalBlock)(id input);
+
+// Adds a signal to `activeExecutionSignals` and generates a KVO notification.
+- (void)addActiveExecutionSignal:(RACSignal *)signal;
+
+// Removes a signal from `activeExecutionSignals` and generates a KVO
+// notification.
+- (void)removeActiveExecutionSignal:(RACSignal *)signal;
+
+@end
+
+@implementation RACCommand
+
+#pragma mark Properties
+
+- (BOOL)allowsConcurrentExecution {
+	return _allowsConcurrentExecution != 0;
+}
+
+- (void)setAllowsConcurrentExecution:(BOOL)allowed {
+	[self willChangeValueForKey:@keypath(self.allowsConcurrentExecution)];
+
+	if (allowed) {
+		OSAtomicOr32Barrier(1, &_allowsConcurrentExecution);
+	} else {
+		OSAtomicAnd32Barrier(0, &_allowsConcurrentExecution);
+	}
+
+	[self didChangeValueForKey:@keypath(self.allowsConcurrentExecution)];
+}
+
+- (NSArray *)activeExecutionSignals {
+	@synchronized (self) {
+		return [_activeExecutionSignals copy];
+	}
+}
+
+- (void)addActiveExecutionSignal:(RACSignal *)signal {
+	NSCParameterAssert([signal isKindOfClass:RACSignal.class]);
+
+	@synchronized (self) {
+		// The KVO notification has to be generated while synchronized, because
+		// it depends on the index remaining consistent.
+		NSIndexSet *indexes = [NSIndexSet indexSetWithIndex:_activeExecutionSignals.count];
+		[self willChange:NSKeyValueChangeInsertion valuesAtIndexes:indexes forKey:@keypath(self.activeExecutionSignals)];
+		[_activeExecutionSignals addObject:signal];
+		[self didChange:NSKeyValueChangeInsertion valuesAtIndexes:indexes forKey:@keypath(self.activeExecutionSignals)];
+	}
+}
+
+- (void)removeActiveExecutionSignal:(RACSignal *)signal {
+	NSCParameterAssert([signal isKindOfClass:RACSignal.class]);
+
+	@synchronized (self) {
+		// The indexes have to be calculated and the notification generated
+		// while synchronized, because they depend on the indexes remaining
+		// consistent.
+		NSIndexSet *indexes = [_activeExecutionSignals indexesOfObjectsPassingTest:^ BOOL (RACSignal *obj, NSUInteger index, BOOL *stop) {
+			return obj == signal;
+		}];
+
+		if (indexes.count == 0) return;
+
+		[self willChange:NSKeyValueChangeRemoval valuesAtIndexes:indexes forKey:@keypath(self.activeExecutionSignals)];
+		[_activeExecutionSignals removeObjectsAtIndexes:indexes];
+		[self didChange:NSKeyValueChangeRemoval valuesAtIndexes:indexes forKey:@keypath(self.activeExecutionSignals)];
+	}
+}
+
+#pragma mark Lifecycle
+
+- (id)init {
+	NSCAssert(NO, @"Use -initWithSignalBlock: instead");
+	return nil;
+}
+
+- (id)initWithSignalBlock:(RACSignal * (^)(id input))signalBlock {
+	return [self initWithEnabled:nil signalBlock:signalBlock];
+}
+
+- (id)initWithEnabled:(RACSignal *)enabledSignal signalBlock:(RACSignal * (^)(id input))signalBlock {
+	NSCParameterAssert(signalBlock != nil);
+
+	self = [super init];
+	if (self == nil) return nil;
+
+	_activeExecutionSignals = [[NSMutableArray alloc] init];
+	_signalBlock = [signalBlock copy];
+
+	// A signal of additions to `activeExecutionSignals`.
+	RACSignal *newActiveExecutionSignals = [[[[[self
+		rac_valuesAndChangesForKeyPath:@keypath(self.activeExecutionSignals) options:NSKeyValueObservingOptionNew observer:nil]
+		reduceEach:^(id _, NSDictionary *change) {
+			NSArray *signals = change[NSKeyValueChangeNewKey];
+			if (signals == nil) return [RACSignal empty];
+
+			return [signals.rac_sequence signalWithScheduler:RACScheduler.immediateScheduler];
+		}]
+		concat]
+		publish]
+		autoconnect];
+
+	_executionSignals = [[[newActiveExecutionSignals
+		map:^(RACSignal *signal) {
+			return [signal catchTo:[RACSignal empty]];
+		}]
+		deliverOn:RACScheduler.mainThreadScheduler]
+		setNameWithFormat:@"%@ -executionSignals", self];
+	
+	// `errors` needs to be multicasted so that it picks up all
+	// `activeExecutionSignals` that are added.
+	//
+	// In other words, if someone subscribes to `errors` _after_ an execution
+	// has started, it should still receive any error from that execution.
+	RACMulticastConnection *errorsConnection = [[[newActiveExecutionSignals
+		flattenMap:^(RACSignal *signal) {
+			return [[signal
+				ignoreValues]
+				catch:^(NSError *error) {
+					return [RACSignal return:error];
+				}];
+		}]
+		deliverOn:RACScheduler.mainThreadScheduler]
+		publish];
+	
+	_errors = [errorsConnection.signal setNameWithFormat:@"%@ -errors", self];
+	[errorsConnection connect];
+
+	RACSignal *immediateExecuting = [RACObserve(self, activeExecutionSignals) map:^(NSArray *activeSignals) {
+		return @(activeSignals.count > 0);
+	}];
+
+	_executing = [[[[[immediateExecuting
+		deliverOn:RACScheduler.mainThreadScheduler]
+		// This is useful before the first value arrives on the main thread.
+		startWith:@NO]
+		distinctUntilChanged]
+		replayLast]
+		setNameWithFormat:@"%@ -executing", self];
+
+	RACSignal *moreExecutionsAllowed = [RACSignal
+		if:RACObserve(self, allowsConcurrentExecution)
+		then:[RACSignal return:@YES]
+		else:[immediateExecuting not]];
+	
+	if (enabledSignal == nil) {
+		enabledSignal = [RACSignal return:@YES];
+	} else {
+		enabledSignal = [[[enabledSignal
+			startWith:@YES]
+			takeUntil:self.rac_willDeallocSignal]
+			replayLast];
+	}
+	
+	_immediateEnabled = [[RACSignal
+		combineLatest:@[ enabledSignal, moreExecutionsAllowed ]]
+		and];
+	
+	_enabled = [[[[[self.immediateEnabled
+		take:1]
+		concat:[[self.immediateEnabled skip:1] deliverOn:RACScheduler.mainThreadScheduler]]
+		distinctUntilChanged]
+		replayLast]
+		setNameWithFormat:@"%@ -enabled", self];
+
+	return self;
+}
+
+#pragma mark Execution
+
+- (RACSignal *)execute:(id)input {
+	// `immediateEnabled` is guaranteed to send a value upon subscription, so
+	// -first is acceptable here.
+	BOOL enabled = [[self.immediateEnabled first] boolValue];
+	if (!enabled) {
+		NSError *error = [NSError errorWithDomain:RACCommandErrorDomain code:RACCommandErrorNotEnabled userInfo:@{
+			NSLocalizedDescriptionKey: NSLocalizedString(@"The command is disabled and cannot be executed", nil),
+			RACUnderlyingCommandErrorKey: self
+		}];
+
+		return [RACSignal error:error];
+	}
+
+	RACSignal *signal = self.signalBlock(input);
+	NSCAssert(signal != nil, @"nil signal returned from signal block for value: %@", input);
+
+	// We subscribe to the signal on the main thread so that it occurs _after_
+	// -addActiveExecutionSignal: completes below.
+	//
+	// This means that `executing` and `enabled` will send updated values before
+	// the signal actually starts performing work.
+	RACMulticastConnection *connection = [[signal
+		subscribeOn:RACScheduler.mainThreadScheduler]
+		multicast:[RACReplaySubject subject]];
+	
+	@weakify(self);
+
+	[self addActiveExecutionSignal:connection.signal];
+	[connection.signal subscribeError:^(NSError *error) {
+		@strongify(self);
+		[self removeActiveExecutionSignal:connection.signal];
+	} completed:^{
+		@strongify(self);
+		[self removeActiveExecutionSignal:connection.signal];
+	}];
+
+	[connection connect];
+	return [connection.signal setNameWithFormat:@"%@ -execute: %@", self, [input rac_description]];
+}
+
+#pragma mark NSKeyValueObserving
+
++ (BOOL)automaticallyNotifiesObserversForKey:(NSString *)key {
+	// Generate all KVO notifications manually to avoid the performance impact
+	// of unnecessary swizzling.
+	return NO;
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACCompoundDisposable.h b/ReactiveCocoaFramework/ReactiveCocoa/RACCompoundDisposable.h
new file mode 100644
index 0000000..bb25f7d
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACCompoundDisposable.h
@@ -0,0 +1,48 @@
+//
+//  RACCompoundDisposable.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 11/30/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACDisposable.h"
+
+/// A disposable of disposables. When it is disposed, it disposes of all its
+/// contained disposables.
+///
+/// If -addDisposable: is called after the compound disposable has been disposed
+/// of, the given disposable is immediately disposed. This allows a compound
+/// disposable to act as a stand-in for a disposable that will be delivered
+/// asynchronously.
+@interface RACCompoundDisposable : RACDisposable
+
+/// Creates and returns a new compound disposable.
++ (instancetype)compoundDisposable;
+
+/// Creates and returns a new compound disposable containing the given
+/// disposables.
++ (instancetype)compoundDisposableWithDisposables:(NSArray *)disposables;
+
+/// Adds the given disposable. If the receiving disposable has already been
+/// disposed of, the given disposable is disposed immediately.
+///
+/// This method is thread-safe.
+///
+/// disposable - The disposable to add. This may be nil, in which case nothing
+///              happens.
+- (void)addDisposable:(RACDisposable *)disposable;
+
+/// Removes the specified disposable from the compound disposable (regardless of
+/// its disposed status), or does nothing if it's not in the compound disposable.
+///
+/// This is mainly useful for limiting the memory usage of the compound
+/// disposable for long-running operations.
+///
+/// This method is thread-safe.
+///
+/// disposable - The disposable to remove. This argument may be nil (to make the
+///              use of weak references easier).
+- (void)removeDisposable:(RACDisposable *)disposable;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACCompoundDisposable.m b/ReactiveCocoaFramework/ReactiveCocoa/RACCompoundDisposable.m
new file mode 100644
index 0000000..3b0471c
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACCompoundDisposable.m
@@ -0,0 +1,239 @@
+//
+//  RACCompoundDisposable.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 11/30/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACCompoundDisposable.h"
+#import "RACCompoundDisposableProvider.h"
+#import <libkern/OSAtomic.h>
+
+// The number of child disposables for which space will be reserved directly in
+// `RACCompoundDisposable`.
+//
+// This number has been empirically determined to provide a good tradeoff
+// between performance, memory usage, and `RACCompoundDisposable` instance size
+// in a moderately complex GUI application.
+//
+// Profile any change!
+#define RACCompoundDisposableInlineCount 2
+
+static CFMutableArrayRef RACCreateDisposablesArray(void) {
+	// Compare values using only pointer equality.
+	CFArrayCallBacks callbacks = kCFTypeArrayCallBacks;
+	callbacks.equal = NULL;
+
+	return CFArrayCreateMutable(NULL, 0, &callbacks);
+}
+
+@interface RACCompoundDisposable () {
+	// Used for synchronization.
+	OSSpinLock _spinLock;
+
+	#if RACCompoundDisposableInlineCount
+	// A fast array to the first N of the receiver's disposables.
+	//
+	// Once this is full, `_disposables` will be created and used for additional
+	// disposables.
+	//
+	// This array should only be manipulated while _spinLock is held.
+	RACDisposable *_inlineDisposables[RACCompoundDisposableInlineCount];
+	#endif
+
+	// Contains the receiver's disposables.
+	//
+	// This array should only be manipulated while _spinLock is held. If
+	// `_disposed` is YES, this may be NULL.
+	CFMutableArrayRef _disposables;
+
+	// Whether the receiver has already been disposed.
+	//
+	// This ivar should only be accessed while _spinLock is held.
+	BOOL _disposed;
+}
+
+@end
+
+@implementation RACCompoundDisposable
+
+#pragma mark Properties
+
+- (BOOL)isDisposed {
+	OSSpinLockLock(&_spinLock);
+	BOOL disposed = _disposed;
+	OSSpinLockUnlock(&_spinLock);
+
+	return disposed;
+}
+
+#pragma mark Lifecycle
+
++ (instancetype)compoundDisposable {
+	return [[self alloc] initWithDisposables:nil];
+}
+
++ (instancetype)compoundDisposableWithDisposables:(NSArray *)disposables {
+	return [[self alloc] initWithDisposables:disposables];
+}
+
+- (id)initWithDisposables:(NSArray *)otherDisposables {
+	self = [self init];
+	if (self == nil) return nil;
+
+	#if RACCompoundDisposableInlineCount
+	[otherDisposables enumerateObjectsUsingBlock:^(RACDisposable *disposable, NSUInteger index, BOOL *stop) {
+		_inlineDisposables[index] = disposable;
+
+		// Stop after this iteration if we've reached the end of the inlined
+		// array.
+		if (index == RACCompoundDisposableInlineCount - 1) *stop = YES;
+	}];
+	#endif
+
+	if (otherDisposables.count > RACCompoundDisposableInlineCount) {
+		_disposables = RACCreateDisposablesArray();
+
+		CFRange range = CFRangeMake(RACCompoundDisposableInlineCount, (CFIndex)otherDisposables.count - RACCompoundDisposableInlineCount);
+		CFArrayAppendArray(_disposables, (__bridge CFArrayRef)otherDisposables, range);
+	}
+
+	return self;
+}
+
+- (id)initWithBlock:(void (^)(void))block {
+	RACDisposable *disposable = [RACDisposable disposableWithBlock:block];
+	return [self initWithDisposables:@[ disposable ]];
+}
+
+- (void)dealloc {
+	#if RACCompoundDisposableInlineCount
+	for (unsigned i = 0; i < RACCompoundDisposableInlineCount; i++) {
+		_inlineDisposables[i] = nil;
+	}
+	#endif
+
+	if (_disposables != NULL) {
+		CFRelease(_disposables);
+		_disposables = NULL;
+	}
+}
+
+#pragma mark Addition and Removal
+
+- (void)addDisposable:(RACDisposable *)disposable {
+	NSCParameterAssert(disposable != self);
+	if (disposable == nil) return;
+
+	BOOL shouldDispose = NO;
+
+	OSSpinLockLock(&_spinLock);
+	{
+		if (_disposed) {
+			shouldDispose = YES;
+		} else {
+			#if RACCompoundDisposableInlineCount
+			for (unsigned i = 0; i < RACCompoundDisposableInlineCount; i++) {
+				if (_inlineDisposables[i] == nil) {
+					_inlineDisposables[i] = disposable;
+					goto foundSlot;
+				}
+			}
+			#endif
+
+			if (_disposables == NULL) _disposables = RACCreateDisposablesArray();
+			CFArrayAppendValue(_disposables, (__bridge void *)disposable);
+
+			if (RACCOMPOUNDDISPOSABLE_ADDED_ENABLED()) {
+				RACCOMPOUNDDISPOSABLE_ADDED(self.description.UTF8String, disposable.description.UTF8String, CFArrayGetCount(_disposables) + RACCompoundDisposableInlineCount);
+			}
+
+		#if RACCompoundDisposableInlineCount
+		foundSlot:;
+		#endif
+		}
+	}
+	OSSpinLockUnlock(&_spinLock);
+
+	// Performed outside of the lock in case the compound disposable is used
+	// recursively.
+	if (shouldDispose) [disposable dispose];
+}
+
+- (void)removeDisposable:(RACDisposable *)disposable {
+	if (disposable == nil) return;
+
+	OSSpinLockLock(&_spinLock);
+	{
+		if (!_disposed) {
+			#if RACCompoundDisposableInlineCount
+			for (unsigned i = 0; i < RACCompoundDisposableInlineCount; i++) {
+				if (_inlineDisposables[i] == disposable) _inlineDisposables[i] = nil;
+			}
+			#endif
+
+			if (_disposables != NULL) {
+				CFIndex count = CFArrayGetCount(_disposables);
+				for (CFIndex i = count - 1; i >= 0; i--) {
+					const void *item = CFArrayGetValueAtIndex(_disposables, i);
+					if (item == (__bridge void *)disposable) {
+						CFArrayRemoveValueAtIndex(_disposables, i);
+					}
+				}
+
+				if (RACCOMPOUNDDISPOSABLE_REMOVED_ENABLED()) {
+					RACCOMPOUNDDISPOSABLE_REMOVED(self.description.UTF8String, disposable.description.UTF8String, CFArrayGetCount(_disposables) + RACCompoundDisposableInlineCount);
+				}
+			}
+		}
+	}
+	OSSpinLockUnlock(&_spinLock);
+}
+
+#pragma mark RACDisposable
+
+static void disposeEach(const void *value, void *context) {
+	RACDisposable *disposable = (__bridge id)value;
+	[disposable dispose];
+}
+
+- (void)dispose {
+	#if RACCompoundDisposableInlineCount
+	RACDisposable *inlineCopy[RACCompoundDisposableInlineCount];
+	#endif
+
+	CFArrayRef remainingDisposables = NULL;
+
+	OSSpinLockLock(&_spinLock);
+	{
+		_disposed = YES;
+
+		#if RACCompoundDisposableInlineCount
+		for (unsigned i = 0; i < RACCompoundDisposableInlineCount; i++) {
+			inlineCopy[i] = _inlineDisposables[i];
+			_inlineDisposables[i] = nil;
+		}
+		#endif
+
+		remainingDisposables = _disposables;
+		_disposables = NULL;
+	}
+	OSSpinLockUnlock(&_spinLock);
+
+	#if RACCompoundDisposableInlineCount
+	// Dispose outside of the lock in case the compound disposable is used
+	// recursively.
+	for (unsigned i = 0; i < RACCompoundDisposableInlineCount; i++) {
+		[inlineCopy[i] dispose];
+	}
+	#endif
+
+	if (remainingDisposables == NULL) return;
+
+	CFIndex count = CFArrayGetCount(remainingDisposables);
+	CFArrayApplyFunction(remainingDisposables, CFRangeMake(0, count), &disposeEach, NULL);
+	CFRelease(remainingDisposables);
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACCompoundDisposableProvider.d b/ReactiveCocoaFramework/ReactiveCocoa/RACCompoundDisposableProvider.d
new file mode 100644
index 0000000..847db19
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACCompoundDisposableProvider.d
@@ -0,0 +1,4 @@
+provider RACCompoundDisposable {
+    probe added(char *compoundDisposable, char *disposable, long newTotal);
+    probe removed(char *compoundDisposable, char *disposable, long newTotal);
+};
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACDelegateProxy.h b/ReactiveCocoaFramework/ReactiveCocoa/RACDelegateProxy.h
new file mode 100644
index 0000000..9ec96bd
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACDelegateProxy.h
@@ -0,0 +1,28 @@
+//
+//  RACDelegateProxy.h
+//  ReactiveCocoa
+//
+//  Created by Cody Krieger on 5/19/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+@class RACSignal;
+
+// A private delegate object suitable for using
+// -rac_signalForSelector:fromProtocol: upon.
+@interface RACDelegateProxy : NSObject
+
+// The delegate to which messages should be forwarded if not handled by
+// any -signalForSelector: applications.
+@property (nonatomic, unsafe_unretained) id rac_proxiedDelegate;
+
+// Creates a delegate proxy capable of responding to selectors from `protocol`.
+- (instancetype)initWithProtocol:(Protocol *)protocol;
+
+// Calls -rac_signalForSelector:fromProtocol: using the `protocol` specified
+// during initialization.
+- (RACSignal *)signalForSelector:(SEL)selector;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACDelegateProxy.m b/ReactiveCocoaFramework/ReactiveCocoa/RACDelegateProxy.m
new file mode 100644
index 0000000..1d4fcbc
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACDelegateProxy.m
@@ -0,0 +1,78 @@
+//
+//  RACDelegateProxy.m
+//  ReactiveCocoa
+//
+//  Created by Cody Krieger on 5/19/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACDelegateProxy.h"
+#import "RACSignal+Operations.h"
+#import "NSObject+RACSelectorSignal.h"
+#import "NSObject+RACDeallocating.h"
+#import <objc/runtime.h>
+
+@interface RACDelegateProxy () {
+	// Declared as an ivar to avoid method naming conflicts.
+	Protocol *_protocol;
+}
+
+@end
+
+@implementation RACDelegateProxy
+
+#pragma mark Lifecycle
+
+- (instancetype)initWithProtocol:(Protocol *)protocol {
+	NSCParameterAssert(protocol != NULL);
+
+	self = [super init];
+	if (self == nil) return nil;
+
+	class_addProtocol(self.class, protocol);
+
+	_protocol = protocol;
+
+	return self;
+}
+
+#pragma mark API
+
+- (RACSignal *)signalForSelector:(SEL)selector {
+	return [self rac_signalForSelector:selector fromProtocol:_protocol];
+}
+
+#pragma mark NSObject
+
+- (BOOL)isProxy {
+	return YES;
+}
+
+- (void)forwardInvocation:(NSInvocation *)invocation {
+	[invocation invokeWithTarget:self.rac_proxiedDelegate];
+}
+
+- (NSMethodSignature *)methodSignatureForSelector:(SEL)selector {
+	// Look for the selector as an optional instance method.
+	struct objc_method_description methodDescription = protocol_getMethodDescription(_protocol, selector, NO, YES);
+
+	if (methodDescription.name == NULL) {
+		// Then fall back to looking for a required instance
+		// method.
+		methodDescription = protocol_getMethodDescription(_protocol, selector, YES, YES);
+		if (methodDescription.name == NULL) return [super methodSignatureForSelector:selector];
+	}
+
+	return [NSMethodSignature signatureWithObjCTypes:methodDescription.types];
+}
+
+- (BOOL)respondsToSelector:(SEL)selector {
+	// Add the delegate to the autorelease pool, so it doesn't get deallocated
+	// between this method call and -forwardInvocation:.
+	__autoreleasing id delegate = self.rac_proxiedDelegate;
+	if ([delegate respondsToSelector:selector]) return YES;
+    
+	return [super respondsToSelector:selector];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACDisposable.h b/ReactiveCocoaFramework/ReactiveCocoa/RACDisposable.h
new file mode 100644
index 0000000..1267d44
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACDisposable.h
@@ -0,0 +1,36 @@
+//
+//  RACDisposable.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 3/16/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+@class RACScopedDisposable;
+
+
+/// A disposable encapsulates the work necessary to tear down and cleanup a
+/// subscription.
+@interface RACDisposable : NSObject
+
+/// Whether the receiver has been disposed.
+///
+/// Use of this property is discouraged, since it may be set to `YES`
+/// concurrently at any time.
+///
+/// This property is not KVO-compliant.
+@property (atomic, assign, getter = isDisposed, readonly) BOOL disposed;
+
++ (instancetype)disposableWithBlock:(void (^)(void))block;
+
+/// Performs the disposal work. Can be called multiple times, though subsequent
+/// calls won't do anything.
+- (void)dispose;
+
+/// Returns a new disposable which will dispose of this disposable when it gets
+/// dealloc'd.
+- (RACScopedDisposable *)asScopedDisposable;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACDisposable.m b/ReactiveCocoaFramework/ReactiveCocoa/RACDisposable.m
new file mode 100644
index 0000000..08eceb2
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACDisposable.m
@@ -0,0 +1,92 @@
+//
+//  RACDisposable.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 3/16/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACDisposable.h"
+#import "RACScopedDisposable.h"
+#import <libkern/OSAtomic.h>
+
+@interface RACDisposable () {
+	// A copied block of type void (^)(void) containing the logic for disposal,
+	// a pointer to `self` if no logic should be performed upon disposal, or
+	// NULL if the receiver is already disposed.
+	//
+	// This should only be used atomically.
+	void * volatile _disposeBlock;
+}
+
+@end
+
+@implementation RACDisposable
+
+#pragma mark Properties
+
+- (BOOL)isDisposed {
+	return _disposeBlock == NULL;
+}
+
+#pragma mark Lifecycle
+
+- (id)init {
+	self = [super init];
+	if (self == nil) return nil;
+
+	_disposeBlock = (__bridge void *)self;
+	OSMemoryBarrier();
+
+	return self;
+}
+
+- (id)initWithBlock:(void (^)(void))block {
+	NSCParameterAssert(block != nil);
+
+	self = [super init];
+	if (self == nil) return nil;
+
+	_disposeBlock = (void *)CFBridgingRetain([block copy]); 
+	OSMemoryBarrier();
+
+	return self;
+}
+
++ (instancetype)disposableWithBlock:(void (^)(void))block {
+	return [[self alloc] initWithBlock:block];
+}
+
+- (void)dealloc {
+	if (_disposeBlock == NULL || _disposeBlock == (__bridge void *)self) return;
+
+	CFRelease(_disposeBlock);
+	_disposeBlock = NULL;
+}
+
+#pragma mark Disposal
+
+- (void)dispose {
+	void (^disposeBlock)(void) = NULL;
+
+	while (YES) {
+		void *blockPtr = _disposeBlock;
+		if (OSAtomicCompareAndSwapPtrBarrier(blockPtr, NULL, &_disposeBlock)) {
+			if (blockPtr != (__bridge void *)self) {
+				disposeBlock = CFBridgingRelease(blockPtr);
+			}
+
+			break;
+		}
+	}
+
+	if (disposeBlock != nil) disposeBlock();
+}
+
+#pragma mark Scoped Disposables
+
+- (RACScopedDisposable *)asScopedDisposable {
+	return [RACScopedDisposable scopedDisposableWithDisposable:self];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACDynamicSequence.h b/ReactiveCocoaFramework/ReactiveCocoa/RACDynamicSequence.h
new file mode 100644
index 0000000..1e103e3
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACDynamicSequence.h
@@ -0,0 +1,20 @@
+//
+//  RACDynamicSequence.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-10-29.
+//  Copyright (c) 2012 GitHub. All rights reserved.
+//
+
+#import "RACSequence.h"
+
+// Private class that implements a sequence dynamically using blocks.
+@interface RACDynamicSequence : RACSequence
+
+// Returns a sequence which evaluates `dependencyBlock` only once, the first
+// time either `headBlock` or `tailBlock` is evaluated. The result of
+// `dependencyBlock` will be passed into `headBlock` and `tailBlock` when
+// invoked.
++ (RACSequence *)sequenceWithLazyDependency:(id (^)(void))dependencyBlock headBlock:(id (^)(id dependency))headBlock tailBlock:(RACSequence *(^)(id dependency))tailBlock;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACDynamicSequence.m b/ReactiveCocoaFramework/ReactiveCocoa/RACDynamicSequence.m
new file mode 100644
index 0000000..48a977b
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACDynamicSequence.m
@@ -0,0 +1,197 @@
+//
+//  RACDynamicSequence.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-10-29.
+//  Copyright (c) 2012 GitHub. All rights reserved.
+//
+
+#import "RACDynamicSequence.h"
+#import <libkern/OSAtomic.h>
+
+// Determines how RACDynamicSequences will be deallocated before the next one is
+// shifted onto the autorelease pool.
+//
+// This avoids stack overflows when deallocating long chains of dynamic
+// sequences.
+#define DEALLOC_OVERFLOW_GUARD 100
+
+@interface RACDynamicSequence () {
+	// The value for the "head" property, if it's been evaluated already.
+	//
+	// Because it's legal for head to be nil, this ivar is valid any time
+	// headBlock is nil.
+	//
+	// This ivar should only be accessed while synchronized on self.
+	id _head;
+
+	// The value for the "tail" property, if it's been evaluated already.
+	//
+	// Because it's legal for tail to be nil, this ivar is valid any time
+	// tailBlock is nil.
+	//
+	// This ivar should only be accessed while synchronized on self.
+	RACSequence *_tail;
+
+	// The result of an evaluated `dependencyBlock`.
+	//
+	// This ivar is valid any time `hasDependency` is YES and `dependencyBlock`
+	// is nil.
+	//
+	// This ivar should only be accessed while synchronized on self.
+	id _dependency;
+}
+
+// A block used to evaluate head. This should be set to nil after `_head` has been
+// initialized.
+//
+// This is marked `strong` instead of `copy` because of some bizarre block
+// copying bug. See https://github.com/ReactiveCocoa/ReactiveCocoa/pull/506.
+//
+// The signature of this block varies based on the value of `hasDependency`:
+//
+//  - If YES, this block is of type `id (^)(id)`.
+//  - If NO, this block is of type `id (^)(void)`.
+//
+// This property should only be accessed while synchronized on self.
+@property (nonatomic, strong) id headBlock;
+
+// A block used to evaluate tail. This should be set to nil after `_tail` has been
+// initialized.
+//
+// This is marked `strong` instead of `copy` because of some bizarre block
+// copying bug. See https://github.com/ReactiveCocoa/ReactiveCocoa/pull/506.
+//
+// The signature of this block varies based on the value of `hasDependency`:
+//
+//  - If YES, this block is of type `RACSequence * (^)(id)`.
+//  - If NO, this block is of type `RACSequence * (^)(void)`.
+//
+// This property should only be accessed while synchronized on self.
+@property (nonatomic, strong) id tailBlock;
+
+// Whether the receiver was initialized with a `dependencyBlock`.
+//
+// This property should only be accessed while synchronized on self.
+@property (nonatomic, assign) BOOL hasDependency;
+
+// A dependency which must be evaluated before `headBlock` and `tailBlock`. This
+// should be set to nil after `_dependency` and `dependencyBlockExecuted` have
+// been set.
+//
+// This is marked `strong` instead of `copy` because of some bizarre block
+// copying bug. See https://github.com/ReactiveCocoa/ReactiveCocoa/pull/506.
+//
+// This property should only be accessed while synchronized on self.
+@property (nonatomic, strong) id (^dependencyBlock)(void);
+
+@end
+
+@implementation RACDynamicSequence
+
+#pragma mark Lifecycle
+
++ (RACSequence *)sequenceWithHeadBlock:(id (^)(void))headBlock tailBlock:(RACSequence *(^)(void))tailBlock {
+	NSCParameterAssert(headBlock != nil);
+
+	RACDynamicSequence *seq = [[RACDynamicSequence alloc] init];
+	seq.headBlock = [headBlock copy];
+	seq.tailBlock = [tailBlock copy];
+	seq.hasDependency = NO;
+	return seq;
+}
+
++ (RACSequence *)sequenceWithLazyDependency:(id (^)(void))dependencyBlock headBlock:(id (^)(id dependency))headBlock tailBlock:(RACSequence *(^)(id dependency))tailBlock {
+	NSCParameterAssert(dependencyBlock != nil);
+	NSCParameterAssert(headBlock != nil);
+
+	RACDynamicSequence *seq = [[RACDynamicSequence alloc] init];
+	seq.headBlock = [headBlock copy];
+	seq.tailBlock = [tailBlock copy];
+	seq.dependencyBlock = [dependencyBlock copy];
+	seq.hasDependency = YES;
+	return seq;
+}
+
+- (void)dealloc {
+	static volatile int32_t directDeallocCount = 0;
+
+	if (OSAtomicIncrement32(&directDeallocCount) >= DEALLOC_OVERFLOW_GUARD) {
+		OSAtomicAdd32(-DEALLOC_OVERFLOW_GUARD, &directDeallocCount);
+
+		// Put this sequence's tail onto the autorelease pool so we stop
+		// recursing.
+		__autoreleasing RACSequence *tail __attribute__((unused)) = _tail;
+	}
+	
+	_tail = nil;
+}
+
+#pragma mark RACSequence
+
+- (id)head {
+	@synchronized (self) {
+		id untypedHeadBlock = self.headBlock;
+		if (untypedHeadBlock == nil) return _head;
+
+		if (self.hasDependency) {
+			if (self.dependencyBlock != nil) {
+				_dependency = self.dependencyBlock();
+				self.dependencyBlock = nil;
+			}
+
+			id (^headBlock)(id) = untypedHeadBlock;
+			_head = headBlock(_dependency);
+		} else {
+			id (^headBlock)(void) = untypedHeadBlock;
+			_head = headBlock();
+		}
+
+		self.headBlock = nil;
+		return _head;
+	}
+}
+
+- (RACSequence *)tail {
+	@synchronized (self) {
+		id untypedTailBlock = self.tailBlock;
+		if (untypedTailBlock == nil) return _tail;
+
+		if (self.hasDependency) {
+			if (self.dependencyBlock != nil) {
+				_dependency = self.dependencyBlock();
+				self.dependencyBlock = nil;
+			}
+
+			RACSequence * (^tailBlock)(id) = untypedTailBlock;
+			_tail = tailBlock(_dependency);
+		} else {
+			RACSequence * (^tailBlock)(void) = untypedTailBlock;
+			_tail = tailBlock();
+		}
+
+		if (_tail.name == nil) _tail.name = self.name;
+
+		self.tailBlock = nil;
+		return _tail;
+	}
+}
+
+#pragma mark NSObject
+
+- (NSString *)description {
+	id head = @"(unresolved)";
+	id tail = @"(unresolved)";
+
+	@synchronized (self) {
+		if (self.headBlock == nil) head = _head;
+		if (self.tailBlock == nil) {
+			tail = _tail;
+			if (tail == self) tail = @"(self)";
+		}
+	}
+
+	return [NSString stringWithFormat:@"<%@: %p>{ name = %@, head = %@, tail = %@ }", self.class, self, self.name, head, tail];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACDynamicSignal.h b/ReactiveCocoaFramework/ReactiveCocoa/RACDynamicSignal.h
new file mode 100644
index 0000000..81ac6db
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACDynamicSignal.h
@@ -0,0 +1,17 @@
+//
+//  RACDynamicSignal.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-10-10.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSignal.h"
+
+// A private `RACSignal` subclasses that implements its subscription behavior
+// using a block.
+@interface RACDynamicSignal : RACSignal
+
++ (RACSignal *)createSignal:(RACDisposable * (^)(id<RACSubscriber> subscriber))didSubscribe;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACDynamicSignal.m b/ReactiveCocoaFramework/ReactiveCocoa/RACDynamicSignal.m
new file mode 100644
index 0000000..7a8ec32
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACDynamicSignal.m
@@ -0,0 +1,189 @@
+//
+//  RACDynamicSignal.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-10-10.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACDynamicSignal.h"
+#import "EXTScope.h"
+#import "RACPassthroughSubscriber.h"
+#import "RACScheduler+Private.h"
+#import "RACSubscriber.h"
+#import "RACCompoundDisposable.h"
+#import <libkern/OSAtomic.h>
+
+// Retains dynamic signals while they wait for subscriptions.
+//
+// This set must only be used on the main thread.
+static CFMutableSetRef RACActiveSignals = nil;
+
+// A linked list of RACDynamicSignals, used in RACActiveSignalsToCheck.
+typedef struct RACSignalList {
+	CFTypeRef retainedSignal;
+	struct RACSignalList * restrict next;
+} RACSignalList;
+
+// An atomic queue of signals to check for subscribers. If any signals with zero
+// subscribers are found in this queue, they are removed from RACActiveSignals.
+static OSQueueHead RACActiveSignalsToCheck = OS_ATOMIC_QUEUE_INIT;
+
+// Whether RACActiveSignalsToCheck will be enumerated on the next iteration on
+// the main run loop.
+static volatile uint32_t RACWillCheckActiveSignals = 0;
+
+@interface RACDynamicSignal () {
+	// Contains all subscribers to the receiver.
+	//
+	// All access to this array must be synchronized using `_subscribersLock`.
+	NSMutableArray *_subscribers;
+
+	// Synchronizes access to `_subscribers`.
+	OSSpinLock _subscribersLock;
+}
+
+// The block to invoke for each subscriber.
+@property (nonatomic, copy, readonly) RACDisposable * (^didSubscribe)(id<RACSubscriber> subscriber);
+
+@end
+
+@implementation RACDynamicSignal
+
+#pragma mark Lifecycle
+
++ (void)initialize {
+	if (self != RACDynamicSignal.class) return;
+
+	CFSetCallBacks callbacks = kCFTypeSetCallBacks;
+
+	// Use pointer equality and hashes for membership testing.
+	callbacks.equal = NULL;
+	callbacks.hash = NULL;
+
+	RACActiveSignals = CFSetCreateMutable(NULL, 0, &callbacks);
+}
+
++ (RACSignal *)createSignal:(RACDisposable * (^)(id<RACSubscriber> subscriber))didSubscribe {
+	RACDynamicSignal *signal = [[self alloc] init];
+	signal->_didSubscribe = [didSubscribe copy];
+	return [signal setNameWithFormat:@"+createSignal:"];
+}
+
+- (instancetype)init {
+	self = [super init];
+	if (self == nil) return nil;
+	
+	// As soon as we're created we're already trying to be released. Such is life.
+	[self invalidateGlobalRefIfNoNewSubscribersShowUp];
+	
+	return self;
+}
+
+static void RACCheckActiveSignals(void) {
+	// Clear this flag now, so another thread can re-dispatch to the main queue
+	// as needed.
+	OSAtomicAnd32Barrier(0, &RACWillCheckActiveSignals);
+
+	RACSignalList * restrict elem;
+
+	while ((elem = OSAtomicDequeue(&RACActiveSignalsToCheck, offsetof(RACSignalList, next))) != NULL) {
+		RACDynamicSignal *signal = CFBridgingRelease(elem->retainedSignal);
+		free(elem);
+
+		if (signal.hasSubscribers) {
+			// We want to keep the signal around until all its subscribers are done
+			CFSetAddValue(RACActiveSignals, (__bridge void *)signal);
+		} else {
+			CFSetRemoveValue(RACActiveSignals, (__bridge void *)signal);
+		}
+	}
+}
+
+- (void)invalidateGlobalRefIfNoNewSubscribersShowUp {
+	// If no one subscribes in one pass of the main run loop, then we're free to
+	// go. It's up to the caller to keep us alive if they still want us.
+	RACSignalList *elem = malloc(sizeof(*elem));
+
+	// This also serves to retain the signal until the next pass.
+	elem->retainedSignal = CFBridgingRetain(self);
+	OSAtomicEnqueue(&RACActiveSignalsToCheck, elem, offsetof(RACSignalList, next));
+
+	// Not using a barrier because duplicate scheduling isn't erroneous, just
+	// less optimized.
+	int32_t willCheck = OSAtomicOr32Orig(1, &RACWillCheckActiveSignals);
+
+	// Only schedule a check if RACWillCheckActiveSignals was 0 before.
+	if (willCheck == 0) {
+		dispatch_async(dispatch_get_main_queue(), ^{
+			RACCheckActiveSignals();
+		});
+	}
+}
+
+#pragma mark Managing Subscribers
+
+- (BOOL)hasSubscribers {
+	OSSpinLockLock(&_subscribersLock);
+	BOOL hasSubscribers = _subscribers.count > 0;
+	OSSpinLockUnlock(&_subscribersLock);
+
+	return hasSubscribers;
+}
+
+- (RACDisposable *)subscribe:(id<RACSubscriber>)subscriber {
+	NSCParameterAssert(subscriber != nil);
+
+	RACCompoundDisposable *disposable = [RACCompoundDisposable compoundDisposable];
+	subscriber = [[RACPassthroughSubscriber alloc] initWithSubscriber:subscriber signal:self disposable:disposable];
+
+	OSSpinLockLock(&_subscribersLock);
+	if (_subscribers == nil) {
+		_subscribers = [NSMutableArray arrayWithObject:subscriber];
+	} else {
+		[_subscribers addObject:subscriber];
+	}
+	OSSpinLockUnlock(&_subscribersLock);
+	
+	@weakify(self);
+	RACDisposable *defaultDisposable = [RACDisposable disposableWithBlock:^{
+		@strongify(self);
+		if (self == nil) return;
+
+		BOOL stillHasSubscribers = YES;
+
+		OSSpinLockLock(&_subscribersLock);
+		{
+			// Since newer subscribers are generally shorter-lived, search
+			// starting from the end of the list.
+			NSUInteger index = [_subscribers indexOfObjectWithOptions:NSEnumerationReverse passingTest:^ BOOL (id<RACSubscriber> obj, NSUInteger index, BOOL *stop) {
+				return obj == subscriber;
+			}];
+
+			if (index != NSNotFound) {
+				[_subscribers removeObjectAtIndex:index];
+				stillHasSubscribers = _subscribers.count > 0;
+			}
+		}
+		OSSpinLockUnlock(&_subscribersLock);
+		
+		if (!stillHasSubscribers) {
+			[self invalidateGlobalRefIfNoNewSubscribersShowUp];
+		}
+	}];
+
+	[disposable addDisposable:defaultDisposable];
+
+	if (self.didSubscribe != NULL) {
+		RACDisposable *schedulingDisposable = [RACScheduler.subscriptionScheduler schedule:^{
+			RACDisposable *innerDisposable = self.didSubscribe(subscriber);
+			[disposable addDisposable:innerDisposable];
+		}];
+
+		[disposable addDisposable:schedulingDisposable];
+	}
+	
+	return disposable;
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACEagerSequence.h b/ReactiveCocoaFramework/ReactiveCocoa/RACEagerSequence.h
new file mode 100644
index 0000000..ab5aa9f
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACEagerSequence.h
@@ -0,0 +1,14 @@
+//
+//  RACEagerSequence.h
+//  ReactiveCocoa
+//
+//  Created by Uri Baghin on 02/01/2013.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACArraySequence.h"
+
+// Private class that implements an eager sequence.
+@interface RACEagerSequence : RACArraySequence
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACEagerSequence.m b/ReactiveCocoaFramework/ReactiveCocoa/RACEagerSequence.m
new file mode 100644
index 0000000..f12fbe9
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACEagerSequence.m
@@ -0,0 +1,66 @@
+//
+//  RACEagerSequence.m
+//  ReactiveCocoa
+//
+//  Created by Uri Baghin on 02/01/2013.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACEagerSequence.h"
+#import "NSObject+RACDescription.h"
+#import "RACArraySequence.h"
+
+@implementation RACEagerSequence
+
+#pragma mark RACStream
+
++ (instancetype)return:(id)value {
+	return [[self sequenceWithArray:@[ value ] offset:0] setNameWithFormat:@"+return: %@", [value rac_description]];
+}
+
+- (instancetype)bind:(RACStreamBindBlock (^)(void))block {
+	NSCParameterAssert(block != nil);
+	RACStreamBindBlock bindBlock = block();
+	NSArray *currentArray = self.array;
+	NSMutableArray *resultArray = [NSMutableArray arrayWithCapacity:currentArray.count];
+	
+	for (id value in currentArray) {
+		BOOL stop = NO;
+		RACSequence *boundValue = (id)bindBlock(value, &stop);
+		if (boundValue == nil) break;
+
+		for (id x in boundValue) {
+			[resultArray addObject:x];
+		}
+
+		if (stop) break;
+	}
+	
+	return [[self.class sequenceWithArray:resultArray offset:0] setNameWithFormat:@"[%@] -bind:", self.name];
+}
+
+- (instancetype)concat:(RACSequence *)sequence {
+	NSCParameterAssert(sequence != nil);
+	NSCParameterAssert([sequence isKindOfClass:RACSequence.class]);
+
+	NSArray *array = [self.array arrayByAddingObjectsFromArray:sequence.array];
+	return [[self.class sequenceWithArray:array offset:0] setNameWithFormat:@"[%@] -concat: %@", self.name, sequence];
+}
+
+#pragma mark Extended methods
+
+- (RACSequence *)eagerSequence {
+	return self;
+}
+
+- (RACSequence *)lazySequence {
+	return [RACArraySequence sequenceWithArray:self.array offset:0];
+}
+
+- (id)foldRightWithStart:(id)start reduce:(id (^)(id, RACSequence *rest))reduce {
+	return [super foldRightWithStart:start reduce:^(id first, RACSequence *rest) {
+		return reduce(first, rest.eagerSequence);
+	}];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACEmptySequence.h b/ReactiveCocoaFramework/ReactiveCocoa/RACEmptySequence.h
new file mode 100644
index 0000000..140c78b
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACEmptySequence.h
@@ -0,0 +1,14 @@
+//
+//  RACEmptySequence.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-10-29.
+//  Copyright (c) 2012 GitHub. All rights reserved.
+//
+
+#import "RACSequence.h"
+
+// Private class representing an empty sequence.
+@interface RACEmptySequence : RACSequence
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACEmptySequence.m b/ReactiveCocoaFramework/ReactiveCocoa/RACEmptySequence.m
new file mode 100644
index 0000000..e4df150
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACEmptySequence.m
@@ -0,0 +1,71 @@
+//
+//  RACEmptySequence.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-10-29.
+//  Copyright (c) 2012 GitHub. All rights reserved.
+//
+
+#import "RACEmptySequence.h"
+
+@implementation RACEmptySequence
+
+#pragma mark Lifecycle
+
++ (instancetype)empty {
+	static id singleton;
+	static dispatch_once_t pred;
+
+	dispatch_once(&pred, ^{
+		singleton = [[self alloc] init];
+	});
+
+	return singleton;
+}
+
+#pragma mark RACSequence
+
+- (id)head {
+	return nil;
+}
+
+- (RACSequence *)tail {
+	return nil;
+}
+
+- (RACSequence *)bind:(RACStreamBindBlock)bindBlock passingThroughValuesFromSequence:(RACSequence *)passthroughSequence {
+	return passthroughSequence ?: self;
+}
+
+#pragma mark NSCoding
+
+- (Class)classForCoder {
+	// Empty sequences should be encoded as themselves, not array sequences.
+	return self.class;
+}
+
+- (id)initWithCoder:(NSCoder *)coder {
+	// Return the singleton.
+	return self.class.empty;
+}
+
+- (void)encodeWithCoder:(NSCoder *)coder {
+}
+
+#pragma mark NSObject
+
+- (NSString *)description {
+	return [NSString stringWithFormat:@"<%@: %p>{ name = %@ }", self.class, self, self.name];
+}
+
+- (NSUInteger)hash {
+	// This hash isn't ideal, but it's better than -[RACSequence hash], which
+	// would just be zero because we have no head.
+	return (NSUInteger)(__bridge void *)self;
+}
+
+- (BOOL)isEqual:(RACSequence *)seq {
+	return (self == seq);
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACEmptySignal.h b/ReactiveCocoaFramework/ReactiveCocoa/RACEmptySignal.h
new file mode 100644
index 0000000..90b4f00
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACEmptySignal.h
@@ -0,0 +1,17 @@
+//
+//  RACEmptySignal.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-10-10.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSignal.h"
+
+// A private `RACSignal` subclasses that synchronously sends completed to any
+// subscribers.
+@interface RACEmptySignal : RACSignal
+
++ (RACSignal *)empty;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACEmptySignal.m b/ReactiveCocoaFramework/ReactiveCocoa/RACEmptySignal.m
new file mode 100644
index 0000000..8bc8f41
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACEmptySignal.m
@@ -0,0 +1,62 @@
+//
+//  RACEmptySignal.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-10-10.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACEmptySignal.h"
+#import "RACScheduler+Private.h"
+#import "RACSubscriber.h"
+
+@implementation RACEmptySignal
+
+#pragma mark Properties
+
+// Only allow this signal's name to be customized in DEBUG, since it's
+// a singleton in release builds (see +empty).
+- (void)setName:(NSString *)name {
+#ifdef DEBUG
+	[super setName:name];
+#endif
+}
+
+- (NSString *)name {
+#ifdef DEBUG
+	return super.name;
+#else
+	return @"+empty";
+#endif
+}
+
+#pragma mark Lifecycle
+
++ (RACSignal *)empty {
+#ifdef DEBUG
+	// Create multiple instances of this class in DEBUG so users can set custom
+	// names on each.
+	return [[[self alloc] init] setNameWithFormat:@"+empty"];
+#else
+	static id singleton;
+	static dispatch_once_t pred;
+
+	dispatch_once(&pred, ^{
+		singleton = [[self alloc] init];
+	});
+
+	return singleton;
+#endif
+}
+
+#pragma mark Subscription
+
+- (RACDisposable *)subscribe:(id<RACSubscriber>)subscriber {
+	NSCParameterAssert(subscriber != nil);
+
+	return [RACScheduler.subscriptionScheduler schedule:^{
+		[subscriber sendCompleted];
+	}];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACErrorSignal.h b/ReactiveCocoaFramework/ReactiveCocoa/RACErrorSignal.h
new file mode 100644
index 0000000..c942f9e
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACErrorSignal.h
@@ -0,0 +1,17 @@
+//
+//  RACErrorSignal.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-10-10.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSignal.h"
+
+// A private `RACSignal` subclasses that synchronously sends an error to any
+// subscribers.
+@interface RACErrorSignal : RACSignal
+
++ (RACSignal *)error:(NSError *)error;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACErrorSignal.m b/ReactiveCocoaFramework/ReactiveCocoa/RACErrorSignal.m
new file mode 100644
index 0000000..fd6778c
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACErrorSignal.m
@@ -0,0 +1,47 @@
+//
+//  RACErrorSignal.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-10-10.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACErrorSignal.h"
+#import "RACScheduler+Private.h"
+#import "RACSubscriber.h"
+
+@interface RACErrorSignal ()
+
+// The error to send upon subscription.
+@property (nonatomic, strong, readonly) NSError *error;
+
+@end
+
+@implementation RACErrorSignal
+
+#pragma mark Lifecycle
+
++ (RACSignal *)error:(NSError *)error {
+	RACErrorSignal *signal = [[self alloc] init];
+	signal->_error = error;
+
+#ifdef DEBUG
+	[signal setNameWithFormat:@"+error: %@", error];
+#else
+	signal.name = @"+error:";
+#endif
+
+	return signal;
+}
+
+#pragma mark Subscription
+
+- (RACDisposable *)subscribe:(id<RACSubscriber>)subscriber {
+	NSCParameterAssert(subscriber != nil);
+
+	return [RACScheduler.subscriptionScheduler schedule:^{
+		[subscriber sendError:self.error];
+	}];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACEvent.h b/ReactiveCocoaFramework/ReactiveCocoa/RACEvent.h
new file mode 100644
index 0000000..9e64e5a
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACEvent.h
@@ -0,0 +1,51 @@
+//
+//  RACEvent.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-01-07.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+/// Describes the type of a RACEvent.
+///
+/// RACEventTypeCompleted - A `completed` event.
+/// RACEventTypeError     - An `error` event.
+/// RACEventTypeNext      - A `next` event.
+typedef enum : NSUInteger {
+    RACEventTypeCompleted,
+    RACEventTypeError,
+    RACEventTypeNext
+} RACEventType;
+
+/// Represents an event sent by a RACSignal.
+///
+/// This corresponds to the `Notification` class in Rx.
+@interface RACEvent : NSObject <NSCopying>
+
+/// Returns a singleton RACEvent representing the `completed` event.
++ (instancetype)completedEvent;
+
+/// Returns a new event of type RACEventTypeError, containing the given error.
++ (instancetype)eventWithError:(NSError *)error;
+
+/// Returns a new event of type RACEventTypeNext, containing the given value.
++ (instancetype)eventWithValue:(id)value;
+
+/// The type of event represented by the receiver.
+@property (nonatomic, assign, readonly) RACEventType eventType;
+
+/// Returns whether the receiver is of type RACEventTypeCompleted or
+/// RACEventTypeError.
+@property (nonatomic, getter = isFinished, assign, readonly) BOOL finished;
+
+/// The error associated with an event of type RACEventTypeError. This will be
+/// nil for all other event types.
+@property (nonatomic, strong, readonly) NSError *error;
+
+/// The value associated with an event of type RACEventTypeNext. This will be
+/// nil for all other event types.
+@property (nonatomic, strong, readonly) id value;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACEvent.m b/ReactiveCocoaFramework/ReactiveCocoa/RACEvent.m
new file mode 100644
index 0000000..270a95d
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACEvent.m
@@ -0,0 +1,113 @@
+//
+//  RACEvent.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-01-07.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACEvent.h"
+
+@interface RACEvent ()
+
+// An object associated with this event. This will be used for the error and
+// value properties.
+@property (nonatomic, strong, readonly) id object;
+
+// Initializes the receiver with the given type and object.
+- (id)initWithEventType:(RACEventType)type object:(id)object;
+
+@end
+
+@implementation RACEvent
+
+#pragma mark Properties
+
+- (BOOL)isFinished {
+	return self.eventType == RACEventTypeCompleted || self.eventType == RACEventTypeError;
+}
+
+- (NSError *)error {
+	return (self.eventType == RACEventTypeError ? self.object : nil);
+}
+
+- (id)value {
+	return (self.eventType == RACEventTypeNext ? self.object : nil);
+}
+
+#pragma mark Lifecycle
+
++ (instancetype)completedEvent {
+	static dispatch_once_t pred;
+	static id singleton;
+
+	dispatch_once(&pred, ^{
+		singleton = [[self alloc] initWithEventType:RACEventTypeCompleted object:nil];
+	});
+
+	return singleton;
+}
+
++ (instancetype)eventWithError:(NSError *)error {
+	return [[self alloc] initWithEventType:RACEventTypeError object:error];
+}
+
++ (instancetype)eventWithValue:(id)value {
+	return [[self alloc] initWithEventType:RACEventTypeNext object:value];
+}
+
+- (id)initWithEventType:(RACEventType)type object:(id)object {
+	self = [super init];
+	if (self == nil) return nil;
+
+	_eventType = type;
+	_object = object;
+
+	return self;
+}
+
+#pragma mark NSCopying
+
+- (id)copyWithZone:(NSZone *)zone {
+	return self;
+}
+
+#pragma mark NSObject
+
+- (NSString *)description {
+	NSString *eventDescription = nil;
+
+	switch (self.eventType) {
+		case RACEventTypeCompleted:
+			eventDescription = @"completed";
+			break;
+
+		case RACEventTypeError:
+			eventDescription = [NSString stringWithFormat:@"error = %@", self.object];
+			break;
+
+		case RACEventTypeNext:
+			eventDescription = [NSString stringWithFormat:@"next = %@", self.object];
+			break;
+
+		default:
+			NSCAssert(NO, @"Unrecognized event type: %i", (int)self.eventType);
+	}
+
+	return [NSString stringWithFormat:@"<%@: %p>{ %@ }", self.class, self, eventDescription];
+}
+
+- (NSUInteger)hash {
+	return self.eventType ^ [self.object hash];
+}
+
+- (BOOL)isEqual:(id)event {
+	if (event == self) return YES;
+	if (![event isKindOfClass:RACEvent.class]) return NO;
+	if (self.eventType != [event eventType]) return NO;
+
+	// Catches the nil case too.
+	return self.object == [event object] || [self.object isEqual:[event object]];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACGroupedSignal.h b/ReactiveCocoaFramework/ReactiveCocoa/RACGroupedSignal.h
new file mode 100644
index 0000000..697d922
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACGroupedSignal.h
@@ -0,0 +1,20 @@
+//
+//  RACGroupedSignal.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 5/2/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSubject.h"
+
+
+/// A grouped signal is used by -[RACSignal groupBy:transform:].
+@interface RACGroupedSignal : RACSubject
+
+/// The key shared by the group.
+@property (nonatomic, readonly, copy) id<NSCopying> key;
+
++ (instancetype)signalWithKey:(id<NSCopying>)key;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACGroupedSignal.m b/ReactiveCocoaFramework/ReactiveCocoa/RACGroupedSignal.m
new file mode 100644
index 0000000..00e0378
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACGroupedSignal.m
@@ -0,0 +1,25 @@
+//
+//  RACGroupedSignal.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 5/2/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACGroupedSignal.h"
+
+@interface RACGroupedSignal ()
+@property (nonatomic, copy) id<NSCopying> key;
+@end
+
+@implementation RACGroupedSignal
+
+#pragma mark API
+
++ (instancetype)signalWithKey:(id<NSCopying>)key {
+	RACGroupedSignal *subject = [self subject];
+	subject.key = key;
+	return subject;
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACImmediateScheduler.h b/ReactiveCocoaFramework/ReactiveCocoa/RACImmediateScheduler.h
new file mode 100644
index 0000000..76b5b50
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACImmediateScheduler.h
@@ -0,0 +1,14 @@
+//
+//  RACImmediateScheduler.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 11/30/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACScheduler.h"
+
+// A private scheduler which immediately executes its scheduled blocks.
+@interface RACImmediateScheduler : RACScheduler
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACImmediateScheduler.m b/ReactiveCocoaFramework/ReactiveCocoa/RACImmediateScheduler.m
new file mode 100644
index 0000000..f32eda3
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACImmediateScheduler.m
@@ -0,0 +1,44 @@
+//
+//  RACImmediateScheduler.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 11/30/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACImmediateScheduler.h"
+#import "RACScheduler+Private.h"
+
+@implementation RACImmediateScheduler
+
+#pragma mark Lifecycle
+
+- (id)init {
+	return [super initWithName:@"com.ReactiveCocoa.RACScheduler.immediateScheduler"];
+}
+
+#pragma mark RACScheduler
+
+- (RACDisposable *)schedule:(void (^)(void))block {
+	NSCParameterAssert(block != NULL);
+
+	block();
+	return nil;
+}
+
+- (RACDisposable *)after:(NSDate *)date schedule:(void (^)(void))block {
+	NSCParameterAssert(date != nil);
+	NSCParameterAssert(block != NULL);
+
+	[NSThread sleepUntilDate:date];
+	block();
+
+	return nil;
+}
+
+- (RACDisposable *)after:(NSDate *)date repeatingEvery:(NSTimeInterval)interval withLeeway:(NSTimeInterval)leeway schedule:(void (^)(void))block {
+	NSCAssert(NO, @"+[RACScheduler immediateScheduler] does not support %@.", NSStringFromSelector(_cmd));
+	return nil;
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACIndexSetSequence.h b/ReactiveCocoaFramework/ReactiveCocoa/RACIndexSetSequence.h
new file mode 100644
index 0000000..eab84a3
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACIndexSetSequence.h
@@ -0,0 +1,16 @@
+//
+//  RACIndexSetSequence.h
+//  ReactiveCocoa
+//
+//  Created by Sergey Gavrilyuk on 12/18/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSequence.h"
+
+// Private class that adapts an array to the RACSequence interface.
+@interface RACIndexSetSequence : RACSequence
+
++ (instancetype)sequenceWithIndexSet:(NSIndexSet *)indexSet;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACIndexSetSequence.m b/ReactiveCocoaFramework/ReactiveCocoa/RACIndexSetSequence.m
new file mode 100644
index 0000000..7ac8f53
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACIndexSetSequence.m
@@ -0,0 +1,108 @@
+//
+//  RACIndexSetSequence.m
+//  ReactiveCocoa
+//
+//  Created by Sergey Gavrilyuk on 12/18/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACIndexSetSequence.h"
+
+@interface RACIndexSetSequence ()
+
+// A buffer holding the `NSUInteger` values to enumerate over.
+//
+// This is mostly used for memory management. Most access should go through
+// `indexes` instead.
+@property (nonatomic, strong, readonly) NSData *data;
+
+// The indexes that this sequence should enumerate.
+@property (nonatomic, readonly) const NSUInteger *indexes;
+
+// The number of indexes to enumerate.
+@property (nonatomic, readonly) NSUInteger count;
+
+@end
+
+@implementation RACIndexSetSequence
+
+#pragma mark Lifecycle
+
++ (instancetype)sequenceWithIndexSet:(NSIndexSet *)indexSet {
+	NSUInteger count = indexSet.count;
+	NSUInteger sizeInBytes = sizeof(NSUInteger) * count;
+
+	NSMutableData *data = [[NSMutableData alloc] initWithCapacity:sizeInBytes];
+	[indexSet getIndexes:data.mutableBytes maxCount:count inIndexRange:NULL];
+
+	RACIndexSetSequence *seq = [[self alloc] init];
+	seq->_data = data;
+	seq->_indexes = data.bytes;
+	seq->_count = count;
+	return seq;
+}
+
++ (instancetype)sequenceWithIndexSetSequence:(RACIndexSetSequence *)indexSetSequence offset:(NSUInteger)offset {
+	NSCParameterAssert(offset < indexSetSequence.count);
+
+	RACIndexSetSequence *seq = [[self alloc] init];
+	seq->_data = indexSetSequence.data;
+	seq->_indexes = indexSetSequence.indexes + offset;
+	seq->_count = indexSetSequence.count - offset;
+	return seq;
+}
+
+#pragma mark RACSequence
+
+- (id)head {
+	return @(self.indexes[0]);
+}
+
+- (RACSequence *)tail {
+	if (self.count <= 1) return [RACSequence empty];
+
+	return [self.class sequenceWithIndexSetSequence:self offset:1];
+}
+
+#pragma mark NSFastEnumeration
+
+- (NSUInteger)countByEnumeratingWithState:(NSFastEnumerationState *)state objects:(__unsafe_unretained id[])stackbuf count:(NSUInteger)len {
+	NSCParameterAssert(len > 0);
+
+	if (state->state >= self.count) {
+		// Enumeration has completed.
+		return 0;
+	}
+	
+	if (state->state == 0) {
+		// Enumeration begun, mark the mutation flag.
+		state->mutationsPtr = state->extra;
+	}
+	
+	state->itemsPtr = stackbuf;
+	
+	unsigned long index = 0;
+	while (index < MIN(self.count - state->state, len)) {
+		stackbuf[index] = @(self.indexes[index + state->state]);
+		++index;
+	}
+	
+	state->state += index;
+	return index;
+}
+
+#pragma mark NSObject
+
+- (NSString *)description {
+	NSMutableString *indexesStr = [NSMutableString string];
+
+	for (unsigned int i = 0; i < self.count; ++i) {
+		if (i > 0) [indexesStr appendString:@", "];
+
+		[indexesStr appendFormat:@"%lu", (unsigned long)self.indexes[i]];
+	}
+
+	return [NSString stringWithFormat:@"<%@: %p>{ name = %@, indexes = %@ }", self.class, self, self.name, indexesStr];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACKVOChannel.h b/ReactiveCocoaFramework/ReactiveCocoa/RACKVOChannel.h
new file mode 100644
index 0000000..0f72995
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACKVOChannel.h
@@ -0,0 +1,97 @@
+//
+//  RACKVOChannel.h
+//  ReactiveCocoa
+//
+//  Created by Uri Baghin on 27/12/2012.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACChannel.h"
+#import "EXTKeyPathCoding.h"
+#import "metamacros.h"
+
+/// Creates a RACKVOChannel to the given key path. When the targeted object
+/// deallocates, the channel will complete.
+///
+/// If RACChannelTo() is used as an expression, it returns a RACChannelTerminal that
+/// can be used to watch the specified property for changes, and set new values
+/// for it. The terminal will start with the property's current value upon
+/// subscription.
+///
+/// If RACChannelTo() is used on the left-hand side of an assignment, there must a
+/// RACChannelTerminal on the right-hand side of the assignment. The two will be
+/// subscribed to one another: the property's value is immediately set to the
+/// value of the channel terminal on the right-hand side, and subsequent changes
+/// to either terminal will be reflected on the other.
+///
+/// There are two different versions of this macro:
+///
+///  - RACChannelTo(TARGET, KEYPATH, NILVALUE) will create a channel to the `KEYPATH`
+///    of `TARGET`. If the terminal is ever sent a `nil` value, the property will
+///    be set to `NILVALUE` instead. `NILVALUE` may itself be `nil` for object
+///    properties, but an NSValue should be used for primitive properties, to
+///    avoid an exception if `nil` is sent (which might occur if an intermediate
+///    object is set to `nil`).
+///  - RACChannelTo(TARGET, KEYPATH) is the same as the above, but `NILVALUE` defaults to
+///    `nil`.
+///
+/// Examples
+///
+///  RACChannelTerminal *integerChannel = RACChannelTo(self, integerProperty, @42);
+///
+///  // Sets self.integerProperty to 5.
+///  [integerChannel sendNext:@5];
+///
+///  // Logs the current value of self.integerProperty, and all future changes.
+///  [integerChannel subscribeNext:^(id value) {
+///      NSLog(@"value: %@", value);
+///  }];
+///
+///  // Binds properties to each other, taking the initial value from the right
+///  side.
+///  RACChannelTo(view, objectProperty) = RACChannelTo(model, objectProperty);
+///  RACChannelTo(view, integerProperty, @2) = RACChannelTo(model, integerProperty, @10);
+#define RACChannelTo(TARGET, ...) \
+    metamacro_if_eq(1, metamacro_argcount(__VA_ARGS__)) \
+        (RACChannelTo_(TARGET, __VA_ARGS__, nil)) \
+        (RACChannelTo_(TARGET, __VA_ARGS__))
+
+/// Do not use this directly. Use the RACChannelTo macro above.
+#define RACChannelTo_(TARGET, KEYPATH, NILVALUE) \
+    [[RACKVOChannel alloc] initWithTarget:(TARGET) keyPath:@keypath(TARGET, KEYPATH) nilValue:(NILVALUE)][@keypath(RACKVOChannel.new, followingTerminal)]
+
+/// A RACChannel that observes a KVO-compliant key path for changes.
+@interface RACKVOChannel : RACChannel
+
+/// Initializes a channel that will observe the given object and key path.
+///
+/// The current value of the key path, and future KVO notifications for the given
+/// key path, will be sent to subscribers of the channel's `followingTerminal`.
+/// Values sent to the `followingTerminal` will be set at the given key path using
+/// key-value coding.
+///
+/// When the target object deallocates, the channel will complete. Signal errors
+/// are considered undefined behavior.
+///
+/// This is the designated initializer for this class.
+///
+/// target   - The object to bind to.
+/// keyPath  - The key path to observe and set the value of.
+/// nilValue - The value to set at the key path whenever a `nil` value is
+///            received. This may be nil when connecting to object properties, but
+///            an NSValue should be used for primitive properties, to avoid an
+///            exception if `nil` is received (which might occur if an intermediate
+///            object is set to `nil`).
+- (id)initWithTarget:(NSObject *)target keyPath:(NSString *)keyPath nilValue:(id)nilValue;
+
+- (id)init __attribute__((unavailable("Use -initWithTarget:keyPath:nilValue: instead")));
+
+@end
+
+/// Methods needed for the convenience macro. Do not call explicitly.
+@interface RACKVOChannel (RACChannelTo)
+
+- (RACChannelTerminal *)objectForKeyedSubscript:(NSString *)key;
+- (void)setObject:(RACChannelTerminal *)otherTerminal forKeyedSubscript:(NSString *)key;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACKVOChannel.m b/ReactiveCocoaFramework/ReactiveCocoa/RACKVOChannel.m
new file mode 100644
index 0000000..7292a74
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACKVOChannel.m
@@ -0,0 +1,206 @@
+//
+//  RACKVOChannel.m
+//  ReactiveCocoa
+//
+//  Created by Uri Baghin on 27/12/2012.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACKVOChannel.h"
+#import "EXTScope.h"
+#import "NSObject+RACDeallocating.h"
+#import "NSObject+RACDescription.h"
+#import "NSObject+RACKVOWrapper.h"
+#import "NSObject+RACPropertySubscribing.h"
+#import "NSString+RACKeyPathUtilities.h"
+#import "RACChannel.h"
+#import "RACCompoundDisposable.h"
+#import "RACDisposable.h"
+#import "RACReplaySubject.h"
+#import "RACSignal+Operations.h"
+#import "RACSubscriber+Private.h"
+#import "RACSubject.h"
+
+// Key for the array of RACKVOChannel's additional thread local
+// data in the thread dictionary.
+static NSString * const RACKVOChannelDataDictionaryKey = @"RACKVOChannelKey";
+
+// Wrapper class for additional thread local data.
+@interface RACKVOChannelData : NSObject
+
+// The flag used to ignore updates the channel itself has triggered.
+@property (nonatomic, assign) BOOL ignoreNextUpdate;
+
+// A pointer to the owner of the data. Only use this for pointer comparison,
+// never as an object reference.
+@property (nonatomic, assign) void *owner;
+
++ (instancetype)dataForChannel:(RACKVOChannel *)channel;
+
+@end
+
+@interface RACKVOChannel ()
+
+// The object whose key path the channel is wrapping.
+@property (atomic, unsafe_unretained) NSObject *target;
+
+// The key path the channel is wrapping.
+@property (nonatomic, copy, readonly) NSString *keyPath;
+
+// Returns the existing thread local data container or nil if none exists.
+@property (nonatomic, strong, readonly) RACKVOChannelData *currentThreadData;
+
+// Creates the thread local data container for the channel.
+- (void)createCurrentThreadData;
+
+// Destroy the thread local data container for the channel.
+- (void)destroyCurrentThreadData;
+
+@end
+
+@implementation RACKVOChannel
+
+#pragma mark Properties
+
+- (RACKVOChannelData *)currentThreadData {
+	NSMutableArray *dataArray = NSThread.currentThread.threadDictionary[RACKVOChannelDataDictionaryKey];
+
+	for (RACKVOChannelData *data in dataArray) {
+		if (data.owner == (__bridge void *)self) return data;
+	}
+
+	return nil;
+}
+
+#pragma mark Lifecycle
+
+- (id)initWithTarget:(NSObject *)target keyPath:(NSString *)keyPath nilValue:(id)nilValue {
+	NSCParameterAssert(keyPath.rac_keyPathComponents.count > 0);
+
+	self = [super init];
+	if (self == nil) return nil;
+
+	_target = target;
+	_keyPath = [keyPath copy];
+
+	[self.leadingTerminal setNameWithFormat:@"[-initWithTarget: %@ keyPath: %@ nilValue: %@] -leadingTerminal", target, keyPath, nilValue];
+	[self.followingTerminal setNameWithFormat:@"[-initWithTarget: %@ keyPath: %@ nilValue: %@] -followingTerminal", target, keyPath, nilValue];
+
+	// Observe the key path on target for changes and forward the changes to the
+	// terminal.
+	//
+	// Intentionally capturing `self` strongly in the blocks below, so the
+	// channel object stays alive while observing.
+	RACDisposable *observationDisposable = [target rac_observeKeyPath:keyPath options:NSKeyValueObservingOptionInitial observer:nil block:^(id value, NSDictionary *change) {
+		// If the change wasn't triggered by deallocation, only affects the last
+		// path component, and ignoreNextUpdate is set, then it was triggered by
+		// this channel and should not be forwarded.
+		if (![change[RACKeyValueChangeCausedByDeallocationKey] boolValue] && [change[RACKeyValueChangeAffectedOnlyLastComponentKey] boolValue] && self.currentThreadData.ignoreNextUpdate) {
+			[self destroyCurrentThreadData];
+			return;
+		}
+
+		[self.leadingTerminal sendNext:value];
+	}];
+	
+	NSString *keyPathByDeletingLastKeyPathComponent = keyPath.rac_keyPathByDeletingLastKeyPathComponent;
+	NSArray *keyPathComponents = keyPath.rac_keyPathComponents;
+	NSUInteger keyPathComponentsCount = keyPathComponents.count;
+	NSString *lastKeyPathComponent = keyPathComponents.lastObject;
+
+	// Update the value of the property with the values received.
+	[[self.leadingTerminal
+		finally:^{
+			[observationDisposable dispose];
+		}]
+		subscribeNext:^(id x) {
+			// Check the value of the second to last key path component. Since the
+			// channel can only update the value of a property on an object, and not
+			// update intermediate objects, it can only update the value of the whole
+			// key path if this object is not nil.
+			NSObject *object = (keyPathComponentsCount > 1 ? [self.target valueForKeyPath:keyPathByDeletingLastKeyPathComponent] : self.target);
+			if (object == nil) return;
+
+			// Set the ignoreNextUpdate flag before setting the value so this channel
+			// ignores the value in the subsequent -didChangeValueForKey: callback.
+			[self createCurrentThreadData];
+			self.currentThreadData.ignoreNextUpdate = YES;
+
+			[object setValue:x ?: nilValue forKey:lastKeyPathComponent];
+		} error:^(NSError *error) {
+			NSCAssert(NO, @"Received error in %@: %@", self, error);
+			
+			// Log the error if we're running with assertions disabled.
+			NSLog(@"Received error in %@: %@", self, error);
+		}];
+	
+	// Capture `self` weakly for the target's deallocation disposable, so we can
+	// freely deallocate if we complete before then.
+	@weakify(self);
+	
+	[target.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+		@strongify(self);
+		[self.leadingTerminal sendCompleted];
+		self.target = nil;
+	}]];
+	
+	return self;
+}
+
+- (void)createCurrentThreadData {
+	NSMutableArray *dataArray = NSThread.currentThread.threadDictionary[RACKVOChannelDataDictionaryKey];
+	if (dataArray == nil) {
+		dataArray = [NSMutableArray array];
+		NSThread.currentThread.threadDictionary[RACKVOChannelDataDictionaryKey] = dataArray;
+		[dataArray addObject:[RACKVOChannelData dataForChannel:self]];
+		return;
+	}
+
+	for (RACKVOChannelData *data in dataArray) {
+		if (data.owner == (__bridge void *)self) return;
+	}
+
+	[dataArray addObject:[RACKVOChannelData dataForChannel:self]];
+}
+
+- (void)destroyCurrentThreadData {
+	NSMutableArray *dataArray = NSThread.currentThread.threadDictionary[RACKVOChannelDataDictionaryKey];
+	NSUInteger index = [dataArray indexOfObjectPassingTest:^ BOOL (RACKVOChannelData *data, NSUInteger idx, BOOL *stop) {
+		return data.owner == (__bridge void *)self;
+	}];
+
+	if (index != NSNotFound) [dataArray removeObjectAtIndex:index];
+}
+
+@end
+
+@implementation RACKVOChannel (RACChannelTo)
+
+- (RACChannelTerminal *)objectForKeyedSubscript:(NSString *)key {
+	NSCParameterAssert(key != nil);
+
+	RACChannelTerminal *terminal = [self valueForKey:key];
+	NSCAssert([terminal isKindOfClass:RACChannelTerminal.class], @"Key \"%@\" does not identify a channel terminal", key);
+	
+	return terminal;
+}
+
+- (void)setObject:(RACChannelTerminal *)otherTerminal forKeyedSubscript:(NSString *)key {
+	NSCParameterAssert(otherTerminal != nil);
+
+	RACChannelTerminal *selfTerminal = [self objectForKeyedSubscript:key];
+	[otherTerminal subscribe:selfTerminal];
+	[[selfTerminal skip:1] subscribe:otherTerminal];
+}
+
+@end
+
+@implementation RACKVOChannelData
+
++ (instancetype)dataForChannel:(RACKVOChannel *)channel {
+	RACKVOChannelData *data = [[self alloc] init];
+	data->_owner = (__bridge void *)channel;
+	return data;
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACKVOTrampoline.h b/ReactiveCocoaFramework/ReactiveCocoa/RACKVOTrampoline.h
new file mode 100644
index 0000000..5701486
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACKVOTrampoline.h
@@ -0,0 +1,31 @@
+//
+//  RACKVOTrampoline.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 1/15/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "NSObject+RACKVOWrapper.h"
+#import "RACDisposable.h"
+
+// A private trampoline object that represents a KVO observation.
+//
+// Disposing of the trampoline will stop observation.
+@interface RACKVOTrampoline : RACDisposable
+
+// Initializes the receiver with the given parameters.
+//
+// target   - The object whose key path should be observed. Cannot be nil.
+// observer - The object that gets notified when the value at the key path
+//            changes. Can be nil.
+// keyPath  - The key path on `target` to observe. Cannot be nil.
+// options  - Any key value observing options to use in the observation.
+// block    - The block to call when the value at the observed key path changes.
+//            Cannot be nil.
+//
+// Returns the initialized object.
+- (id)initWithTarget:(NSObject *)target observer:(NSObject *)observer keyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options block:(RACKVOBlock)block;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACKVOTrampoline.m b/ReactiveCocoaFramework/ReactiveCocoa/RACKVOTrampoline.m
new file mode 100644
index 0000000..1e4feae
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACKVOTrampoline.m
@@ -0,0 +1,100 @@
+//
+//  RACKVOTrampoline.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 1/15/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACKVOTrampoline.h"
+#import "NSObject+RACDeallocating.h"
+#import "RACCompoundDisposable.h"
+
+static void *RACKVOWrapperContext = &RACKVOWrapperContext;
+
+@interface RACKVOTrampoline ()
+
+// The keypath which the trampoline is observing.
+@property (nonatomic, readonly, copy) NSString *keyPath;
+
+// These properties should only be manipulated while synchronized on the
+// receiver.
+@property (nonatomic, readonly, copy) RACKVOBlock block;
+@property (nonatomic, readonly, unsafe_unretained) NSObject *target;
+@property (nonatomic, readonly, unsafe_unretained) NSObject *observer;
+
+@end
+
+@implementation RACKVOTrampoline
+
+#pragma mark Lifecycle
+
+- (id)initWithTarget:(NSObject *)target observer:(NSObject *)observer keyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options block:(RACKVOBlock)block {
+	NSCParameterAssert(target != nil);
+	NSCParameterAssert(keyPath != nil);
+	NSCParameterAssert(block != nil);
+
+	self = [super init];
+	if (self == nil) return nil;
+
+	_keyPath = [keyPath copy];
+
+	_block = [block copy];
+	_target = target;
+	_observer = observer;
+
+	[self.target addObserver:self forKeyPath:self.keyPath options:options context:&RACKVOWrapperContext];
+	[self.target.rac_deallocDisposable addDisposable:self];
+	[self.observer.rac_deallocDisposable addDisposable:self];
+
+	return self;
+}
+
+- (void)dealloc {
+	[self dispose];
+}
+
+#pragma mark Observation
+
+- (void)dispose {
+	NSObject *target;
+	NSObject *observer;
+
+	@synchronized (self) {
+		_block = nil;
+
+		target = self.target;
+		observer = self.observer;
+
+		_target = nil;
+		_observer = nil;
+	}
+
+	[target.rac_deallocDisposable removeDisposable:self];
+	[observer.rac_deallocDisposable removeDisposable:self];
+
+	[target removeObserver:self forKeyPath:self.keyPath context:&RACKVOWrapperContext];
+}
+
+- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context {
+	if (context != &RACKVOWrapperContext) {
+		[super observeValueForKeyPath:keyPath ofObject:object change:change context:context];
+		return;
+	}
+
+	RACKVOBlock block;
+	id observer;
+	id target;
+
+	@synchronized (self) {
+		block = self.block;
+		observer = self.observer;
+		target = self.target;
+	}
+
+	if (block == nil) return;
+
+	block(target, observer, change);
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACMulticastConnection+Private.h b/ReactiveCocoaFramework/ReactiveCocoa/RACMulticastConnection+Private.h
new file mode 100644
index 0000000..43931f8
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACMulticastConnection+Private.h
@@ -0,0 +1,17 @@
+//
+//  RACMulticastConnection+Private.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 4/11/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACMulticastConnection.h"
+
+@class RACSubject;
+
+@interface RACMulticastConnection ()
+
+- (id)initWithSourceSignal:(RACSignal *)source subject:(RACSubject *)subject;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACMulticastConnection.h b/ReactiveCocoaFramework/ReactiveCocoa/RACMulticastConnection.h
new file mode 100644
index 0000000..5361f5d
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACMulticastConnection.h
@@ -0,0 +1,46 @@
+//
+//  RACMulticastConnection.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 4/11/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+@class RACSignal;
+@class RACDisposable;
+
+/// A multicast connection encapsulates the idea of sharing one subscription to a
+/// signal to many subscribers. This is most often needed if the subscription to
+/// the underlying signal involves side-effects or shouldn't be called more than
+/// once.
+///
+/// The multicasted signal is only subscribed to when
+/// -[RACMulticastConnection connect] is called. Until that happens, no values
+/// will be sent on `signal`. See -[RACMulticastConnection autoconnect] for how
+/// -[RACMulticastConnection connect] can be called automatically.
+///
+/// Note that you shouldn't create RACMulticastConnection manually. Instead use
+/// -[RACSignal publish] or -[RACSignal multicast:].
+@interface RACMulticastConnection : NSObject
+
+/// The multicasted signal.
+@property (nonatomic, strong, readonly) RACSignal *signal;
+
+/// Connect to the underlying signal by subscribing to it. Calling this multiple
+/// times does nothing but return the existing connection's disposable.
+///
+/// Returns the disposable for the subscription to the multicasted signal.
+- (RACDisposable *)connect;
+
+/// Connects to the underlying signal when the returned signal is first
+/// subscribed to, and disposes of the subscription to the multicasted signal
+/// when the returned signal has no subscribers.
+///
+/// If new subscribers show up after being disposed, they'll subscribe and then
+/// be immediately disposed of. The returned signal will never re-connect to the
+/// multicasted signal.
+///
+/// Returns the autoconnecting signal.
+- (RACSignal *)autoconnect;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACMulticastConnection.m b/ReactiveCocoaFramework/ReactiveCocoa/RACMulticastConnection.m
new file mode 100644
index 0000000..1534d96
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACMulticastConnection.m
@@ -0,0 +1,85 @@
+//
+//  RACMulticastConnection.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 4/11/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACMulticastConnection.h"
+#import "RACMulticastConnection+Private.h"
+#import "RACDisposable.h"
+#import "RACSerialDisposable.h"
+#import "RACSubject.h"
+#import <libkern/OSAtomic.h>
+
+@interface RACMulticastConnection () {
+	RACSubject *_signal;
+
+	// When connecting, a caller should attempt to atomically swap the value of this
+	// from `0` to `1`.
+	//
+	// If the swap is successful the caller is resposible for subscribing `_signal`
+	// to `sourceSignal` and storing the returned disposable in `serialDisposable`.
+	//
+	// If the swap is unsuccessful it means that `_sourceSignal` has already been
+	// connected and the caller has no action to take.
+	int32_t volatile _hasConnected;
+}
+
+@property (nonatomic, readonly, strong) RACSignal *sourceSignal;
+@property (strong) RACSerialDisposable *serialDisposable;
+@end
+
+@implementation RACMulticastConnection
+
+#pragma mark Lifecycle
+
+- (id)initWithSourceSignal:(RACSignal *)source subject:(RACSubject *)subject {
+	NSCParameterAssert(source != nil);
+	NSCParameterAssert(subject != nil);
+
+	self = [super init];
+	if (self == nil) return nil;
+
+	_sourceSignal = source;
+	_serialDisposable = [[RACSerialDisposable alloc] init];
+	_signal = subject;
+	
+	return self;
+}
+
+#pragma mark Connecting
+
+- (RACDisposable *)connect {
+	BOOL shouldConnect = OSAtomicCompareAndSwap32Barrier(0, 1, &_hasConnected);
+
+	if (shouldConnect) {
+		self.serialDisposable.disposable = [self.sourceSignal subscribe:_signal];
+	}
+
+	return self.serialDisposable;
+}
+
+- (RACSignal *)autoconnect {
+	__block volatile int32_t subscriberCount = 0;
+
+	return [[RACSignal
+		createSignal:^(id<RACSubscriber> subscriber) {
+			OSAtomicIncrement32Barrier(&subscriberCount);
+
+			RACDisposable *subscriptionDisposable = [self.signal subscribe:subscriber];
+			RACDisposable *connectionDisposable = [self connect];
+
+			return [RACDisposable disposableWithBlock:^{
+				[subscriptionDisposable dispose];
+
+				if (OSAtomicDecrement32Barrier(&subscriberCount) == 0) {
+					[connectionDisposable dispose];
+				}
+			}];
+		}]
+		setNameWithFormat:@"[%@] -autoconnect", self.signal.name];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACObjCRuntime.h b/ReactiveCocoaFramework/ReactiveCocoa/RACObjCRuntime.h
new file mode 100644
index 0000000..fbec61c
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACObjCRuntime.h
@@ -0,0 +1,17 @@
+//
+//  RACObjCRuntime.h
+//  ReactiveCocoa
+//
+//  Created by Cody Krieger on 5/19/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+// A private class containing wrappers to runtime functions.
+@interface RACObjCRuntime : NSObject
+
+// Invokes objc_allocateClassPair(). Can be called from ARC code.
++ (Class)createClass:(const char *)className inheritingFromClass:(Class)superclass;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACObjCRuntime.m b/ReactiveCocoaFramework/ReactiveCocoa/RACObjCRuntime.m
new file mode 100644
index 0000000..43cfc19
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACObjCRuntime.m
@@ -0,0 +1,22 @@
+//
+//  RACObjCRuntime.m
+//  ReactiveCocoa
+//
+//  Created by Cody Krieger on 5/19/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACObjCRuntime.h"
+#import <objc/runtime.h>
+
+#if __has_feature(objc_arc)
+#error "This file must be compiled without ARC."
+#endif
+
+@implementation RACObjCRuntime
+
++ (Class)createClass:(const char *)className inheritingFromClass:(Class)superclass {
+	return objc_allocateClassPair(superclass, className, 0);
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACPassthroughSubscriber.h b/ReactiveCocoaFramework/ReactiveCocoa/RACPassthroughSubscriber.h
new file mode 100644
index 0000000..9ae547b
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACPassthroughSubscriber.h
@@ -0,0 +1,29 @@
+//
+//  RACPassthroughSubscriber.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-06-13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "RACSubscriber.h"
+
+@class RACCompoundDisposable;
+@class RACSignal;
+
+// A private subscriber that passes through all events to another subscriber
+// while not disposed.
+@interface RACPassthroughSubscriber : NSObject <RACSubscriber>
+
+// Initializes the receiver to pass through events until disposed.
+//
+// subscriber - The subscriber to forward events to. This must not be nil.
+// signal     - The signal that will be sending events to the receiver.
+// disposable - When this disposable is disposed, no more events will be
+//              forwarded. This must not be nil.
+//
+// Returns an initialized passthrough subscriber.
+- (instancetype)initWithSubscriber:(id<RACSubscriber>)subscriber signal:(RACSignal *)signal disposable:(RACCompoundDisposable *)disposable;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACPassthroughSubscriber.m b/ReactiveCocoaFramework/ReactiveCocoa/RACPassthroughSubscriber.m
new file mode 100644
index 0000000..614d7d5
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACPassthroughSubscriber.m
@@ -0,0 +1,103 @@
+//
+//  RACPassthroughSubscriber.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-06-13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACPassthroughSubscriber.h"
+#import "RACCompoundDisposable.h"
+#import "RACSignal.h"
+#import "RACSignalProvider.h"
+
+static const char *cleanedDTraceString(NSString *original) {
+	return [original stringByReplacingOccurrencesOfString:@"\\s+" withString:@" " options:NSRegularExpressionSearch range:NSMakeRange(0, original.length)].UTF8String;
+}
+
+static const char *cleanedSignalDescription(RACSignal *signal) {
+	NSString *desc = signal.description;
+
+	NSRange range = [desc rangeOfString:@" name:"];
+	if (range.location != NSNotFound) {
+		desc = [desc stringByReplacingCharactersInRange:range withString:@""];
+	}
+
+	return cleanedDTraceString(desc);
+}
+
+@interface RACPassthroughSubscriber ()
+
+// The subscriber to which events should be forwarded.
+@property (nonatomic, strong, readonly) id<RACSubscriber> innerSubscriber;
+
+// The signal sending events to this subscriber.
+//
+// This property isn't `weak` because it's only used for DTrace probes, so
+// a zeroing weak reference would incur an unnecessary performance penalty in
+// normal usage.
+@property (nonatomic, unsafe_unretained, readonly) RACSignal *signal;
+
+// A disposable representing the subscription. When disposed, no further events
+// should be sent to the `innerSubscriber`.
+@property (nonatomic, strong, readonly) RACCompoundDisposable *disposable;
+
+@end
+
+@implementation RACPassthroughSubscriber
+
+#pragma mark Lifecycle
+
+- (instancetype)initWithSubscriber:(id<RACSubscriber>)subscriber signal:(RACSignal *)signal disposable:(RACCompoundDisposable *)disposable {
+	NSCParameterAssert(subscriber != nil);
+
+	self = [super init];
+	if (self == nil) return nil;
+
+	_innerSubscriber = subscriber;
+	_signal = signal;
+	_disposable = disposable;
+
+	[self.innerSubscriber didSubscribeWithDisposable:self.disposable];
+	return self;
+}
+
+#pragma mark RACSubscriber
+
+- (void)sendNext:(id)value {
+	if (self.disposable.disposed) return;
+
+	if (RACSIGNAL_NEXT_ENABLED()) {
+		RACSIGNAL_NEXT(cleanedSignalDescription(self.signal), cleanedDTraceString(self.innerSubscriber.description), cleanedDTraceString([value description]));
+	}
+
+	[self.innerSubscriber sendNext:value];
+}
+
+- (void)sendError:(NSError *)error {
+	if (self.disposable.disposed) return;
+
+	if (RACSIGNAL_ERROR_ENABLED()) {
+		RACSIGNAL_ERROR(cleanedSignalDescription(self.signal), cleanedDTraceString(self.innerSubscriber.description), cleanedDTraceString(error.description));
+	}
+
+	[self.innerSubscriber sendError:error];
+}
+
+- (void)sendCompleted {
+	if (self.disposable.disposed) return;
+
+	if (RACSIGNAL_COMPLETED_ENABLED()) {
+		RACSIGNAL_COMPLETED(cleanedSignalDescription(self.signal), cleanedDTraceString(self.innerSubscriber.description));
+	}
+
+	[self.innerSubscriber sendCompleted];
+}
+
+- (void)didSubscribeWithDisposable:(RACCompoundDisposable *)disposable {
+	if (disposable != self.disposable) {
+		[self.disposable addDisposable:disposable];
+	}
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACQueueScheduler+Subclass.h b/ReactiveCocoaFramework/ReactiveCocoa/RACQueueScheduler+Subclass.h
new file mode 100644
index 0000000..48ef636
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACQueueScheduler+Subclass.h
@@ -0,0 +1,46 @@
+//
+//  RACQueueScheduler+Subclass.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 6/6/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACQueueScheduler.h"
+
+/// An interface for use by subclasses.
+///
+/// Subclasses should use `-performAsCurrentScheduler:` to do the actual block
+/// invocation so that +[RACScheduler currentScheduler] behaves as expected.
+///
+/// **Note that RACSchedulers are expected to be serial**. Subclasses must honor
+/// that contract. See `RACTargetQueueScheduler` for a queue-based scheduler
+/// which will enforce the serialization guarantee.
+@interface RACQueueScheduler ()
+
+/// The queue on which blocks are enqueued.
+@property (nonatomic, readonly) dispatch_queue_t queue;
+
+/// Initializes the receiver with the name of the scheduler and the queue which
+/// the scheduler should use.
+///
+/// name  - The name of the scheduler. If nil, a default name will be used.
+/// queue - The queue upon which the receiver should enqueue scheduled blocks.
+///         This argument must not be NULL.
+///
+/// Returns the initialized object.
+- (id)initWithName:(NSString *)name queue:(dispatch_queue_t)queue;
+
+/// Performs the given block with the receiver as the current scheduler for
+/// `queue`. This should only be called by subclasses to perform scheduled blocks
+/// on their queue.
+///
+/// block - The block to execute. Cannot be NULL.
+- (void)performAsCurrentScheduler:(void (^)(void))block;
+
+/// Converts a date into a GCD time using dispatch_walltime().
+///
+/// date - The date to convert. This must not be nil.
++ (dispatch_time_t)wallTimeWithDate:(NSDate *)date;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACQueueScheduler.h b/ReactiveCocoaFramework/ReactiveCocoa/RACQueueScheduler.h
new file mode 100644
index 0000000..ef42512
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACQueueScheduler.h
@@ -0,0 +1,18 @@
+//
+//  RACQueueScheduler.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 11/30/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACScheduler.h"
+
+/// An abstract scheduler which asynchronously enqueues all its work to a Grand
+/// Central Dispatch queue.
+///
+/// Because RACQueueScheduler is abstract, it should not be instantiated
+/// directly. Create a subclass using the `RACQueueScheduler+Subclass.h`
+/// interface and use that instead.
+@interface RACQueueScheduler : RACScheduler
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACQueueScheduler.m b/ReactiveCocoaFramework/ReactiveCocoa/RACQueueScheduler.m
new file mode 100644
index 0000000..7ae8202
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACQueueScheduler.m
@@ -0,0 +1,120 @@
+//
+//  RACQueueScheduler.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 11/30/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACQueueScheduler.h"
+#import "RACBacktrace.h"
+#import "RACDisposable.h"
+#import "RACQueueScheduler+Subclass.h"
+#import "RACScheduler+Private.h"
+
+@implementation RACQueueScheduler
+
+#pragma mark Lifecycle
+
+- (void)dealloc {
+	dispatch_release(_queue);
+}
+
+- (id)initWithName:(NSString *)name queue:(dispatch_queue_t)queue {
+	NSCParameterAssert(queue != NULL);
+
+	self = [super initWithName:name];
+	if (self == nil) return nil;
+
+	dispatch_retain(queue);
+	_queue = queue;
+
+	return self;
+}
+
+#pragma mark Date Conversions
+
++ (dispatch_time_t)wallTimeWithDate:(NSDate *)date {
+	NSCParameterAssert(date != nil);
+
+	double seconds = 0;
+	double frac = modf(date.timeIntervalSince1970, &seconds);
+
+	struct timespec walltime = {
+		.tv_sec = (time_t)fmin(fmax(seconds, LONG_MIN), LONG_MAX),
+		.tv_nsec = (long)fmin(fmax(frac * NSEC_PER_SEC, LONG_MIN), LONG_MAX)
+	};
+
+	return dispatch_walltime(&walltime, 0);
+}
+
+#pragma mark RACScheduler
+
+- (RACDisposable *)schedule:(void (^)(void))block {
+	NSCParameterAssert(block != NULL);
+
+	RACDisposable *disposable = [[RACDisposable alloc] init];
+
+	dispatch_async(self.queue, ^{
+		if (disposable.disposed) return;
+		[self performAsCurrentScheduler:block];
+	});
+
+	return disposable;
+}
+
+- (RACDisposable *)after:(NSDate *)date schedule:(void (^)(void))block {
+	NSCParameterAssert(date != nil);
+	NSCParameterAssert(block != NULL);
+
+	RACDisposable *disposable = [[RACDisposable alloc] init];
+
+	dispatch_after([self.class wallTimeWithDate:date], self.queue, ^{
+		if (disposable.disposed) return;
+		[self performAsCurrentScheduler:block];
+	});
+
+	return disposable;
+}
+
+- (RACDisposable *)after:(NSDate *)date repeatingEvery:(NSTimeInterval)interval withLeeway:(NSTimeInterval)leeway schedule:(void (^)(void))block {
+	NSCParameterAssert(date != nil);
+	NSCParameterAssert(interval > 0.0 && interval < INT64_MAX / NSEC_PER_SEC);
+	NSCParameterAssert(leeway >= 0.0 && leeway < INT64_MAX / NSEC_PER_SEC);
+	NSCParameterAssert(block != NULL);
+
+	uint64_t intervalInNanoSecs = (uint64_t)(interval * NSEC_PER_SEC);
+	uint64_t leewayInNanoSecs = (uint64_t)(leeway * NSEC_PER_SEC);
+
+	dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, self.queue);
+	dispatch_source_set_timer(timer, [self.class wallTimeWithDate:date], intervalInNanoSecs, leewayInNanoSecs);
+	dispatch_source_set_event_handler(timer, block);
+	dispatch_resume(timer);
+
+	return [RACDisposable disposableWithBlock:^{
+		dispatch_source_cancel(timer);
+		dispatch_release(timer);
+	}];
+}
+
+- (void)performAsCurrentScheduler:(void (^)(void))block {
+	NSCParameterAssert(block != NULL);
+
+	// If we're using a concurrent queue, we could end up in here concurrently,
+	// in which case we *don't* want to clear the current scheduler immediately
+	// after our block is done executing, but only *after* all our concurrent
+	// invocations are done.
+
+	RACScheduler *previousScheduler = RACScheduler.currentScheduler;
+	NSThread.currentThread.threadDictionary[RACSchedulerCurrentSchedulerKey] = self;
+
+	block();
+
+	if (previousScheduler != nil) {
+		NSThread.currentThread.threadDictionary[RACSchedulerCurrentSchedulerKey] = previousScheduler;
+	} else {
+		[NSThread.currentThread.threadDictionary removeObjectForKey:RACSchedulerCurrentSchedulerKey];
+	}
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACReplaySubject.h b/ReactiveCocoaFramework/ReactiveCocoa/RACReplaySubject.h
new file mode 100644
index 0000000..cd6f2ec
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACReplaySubject.h
@@ -0,0 +1,23 @@
+//
+//  RACReplaySubject.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 3/14/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSubject.h"
+
+extern const NSUInteger RACReplaySubjectUnlimitedCapacity;
+
+
+/// A replay subject saves the values it is sent (up to its defined capacity)
+/// and resends those to new subscribers. It will also replay an error or
+/// completion.
+@interface RACReplaySubject : RACSubject
+
+/// Creates a new replay subject with the given capacity. A capacity of
+/// RACReplaySubjectUnlimitedCapacity means values are never trimmed.
++ (instancetype)replaySubjectWithCapacity:(NSUInteger)capacity;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACReplaySubject.m b/ReactiveCocoaFramework/ReactiveCocoa/RACReplaySubject.m
new file mode 100644
index 0000000..bca008e
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACReplaySubject.m
@@ -0,0 +1,112 @@
+//
+//  RACReplaySubject.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 3/14/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACReplaySubject.h"
+#import "RACDisposable.h"
+#import "RACScheduler+Private.h"
+#import "RACSubscriber.h"
+#import "RACTuple.h"
+#import "RACCompoundDisposable.h"
+
+const NSUInteger RACReplaySubjectUnlimitedCapacity = NSUIntegerMax;
+
+@interface RACReplaySubject ()
+
+@property (nonatomic, assign, readonly) NSUInteger capacity;
+
+// These properties should only be modified while synchronized on self.
+@property (nonatomic, strong, readonly) NSMutableArray *valuesReceived;
+@property (nonatomic, assign) BOOL hasCompleted;
+@property (nonatomic, assign) BOOL hasError;
+@property (nonatomic, strong) NSError *error;
+
+@end
+
+
+@implementation RACReplaySubject
+
+#pragma mark Lifecycle
+
++ (instancetype)replaySubjectWithCapacity:(NSUInteger)capacity {
+	return [[self alloc] initWithCapacity:capacity];
+}
+
+- (instancetype)init {
+	return [self initWithCapacity:RACReplaySubjectUnlimitedCapacity];
+}
+
+- (instancetype)initWithCapacity:(NSUInteger)capacity {
+	self = [super init];
+	if (self == nil) return nil;
+	
+	_capacity = capacity;
+	_valuesReceived = (capacity == RACReplaySubjectUnlimitedCapacity ? [NSMutableArray array] : [NSMutableArray arrayWithCapacity:capacity]);
+	
+	return self;
+}
+
+#pragma mark RACSignal
+
+- (RACDisposable *)subscribe:(id<RACSubscriber>)subscriber {
+	RACCompoundDisposable *compoundDisposable = [RACCompoundDisposable compoundDisposable];
+
+	RACDisposable *schedulingDisposable = [RACScheduler.subscriptionScheduler schedule:^{
+		@synchronized (self) {
+			for (id value in self.valuesReceived) {
+				if (compoundDisposable.disposed) return;
+
+				[subscriber sendNext:([value isKindOfClass:RACTupleNil.class] ? nil : value)];
+			}
+
+			if (compoundDisposable.disposed) return;
+
+			if (self.hasCompleted) {
+				[subscriber sendCompleted];
+			} else if (self.hasError) {
+				[subscriber sendError:self.error];
+			} else {
+				RACDisposable *subscriptionDisposable = [super subscribe:subscriber];
+				[compoundDisposable addDisposable:subscriptionDisposable];
+			}
+		}
+	}];
+
+	[compoundDisposable addDisposable:schedulingDisposable];
+
+	return compoundDisposable;
+}
+
+#pragma mark RACSubscriber
+
+- (void)sendNext:(id)value {
+	@synchronized (self) {
+		[self.valuesReceived addObject:value ?: RACTupleNil.tupleNil];
+		[super sendNext:value];
+		
+		if (self.capacity != RACReplaySubjectUnlimitedCapacity && self.valuesReceived.count > self.capacity) {
+			[self.valuesReceived removeObjectsInRange:NSMakeRange(0, self.valuesReceived.count - self.capacity)];
+		}
+	}
+}
+
+- (void)sendCompleted {
+	@synchronized (self) {
+		self.hasCompleted = YES;
+		[super sendCompleted];
+	}
+}
+
+- (void)sendError:(NSError *)e {
+	@synchronized (self) {
+		self.hasError = YES;
+		self.error = e;
+		[super sendError:e];
+	}
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACReturnSignal.h b/ReactiveCocoaFramework/ReactiveCocoa/RACReturnSignal.h
new file mode 100644
index 0000000..73e5674
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACReturnSignal.h
@@ -0,0 +1,17 @@
+//
+//  RACReturnSignal.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-10-10.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSignal.h"
+
+// A private `RACSignal` subclasses that synchronously sends a value to any
+// subscribers, then completes.
+@interface RACReturnSignal : RACSignal
+
++ (RACSignal *)return:(id)value;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACReturnSignal.m b/ReactiveCocoaFramework/ReactiveCocoa/RACReturnSignal.m
new file mode 100644
index 0000000..3006634
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACReturnSignal.m
@@ -0,0 +1,90 @@
+//
+//  RACReturnSignal.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-10-10.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACReturnSignal.h"
+#import "RACScheduler+Private.h"
+#import "RACSubscriber.h"
+#import "RACUnit.h"
+
+@interface RACReturnSignal ()
+
+// The value to send upon subscription.
+@property (nonatomic, strong, readonly) id value;
+
+@end
+
+@implementation RACReturnSignal
+
+#pragma mark Properties
+
+// Only allow this signal's name to be customized in DEBUG, since it's
+// potentially a singleton in release builds (see +return:).
+- (void)setName:(NSString *)name {
+#ifdef DEBUG
+	[super setName:name];
+#endif
+}
+
+- (NSString *)name {
+#ifdef DEBUG
+	return super.name;
+#else
+	return @"+return:";
+#endif
+}
+
+#pragma mark Lifecycle
+
++ (RACSignal *)return:(id)value {
+#ifndef DEBUG
+	// In release builds, use singletons for two very common cases.
+	if (value == RACUnit.defaultUnit) {
+		static RACReturnSignal *unitSingleton;
+		static dispatch_once_t unitPred;
+
+		dispatch_once(&unitPred, ^{
+			unitSingleton = [[self alloc] init];
+			unitSingleton->_value = RACUnit.defaultUnit;
+		});
+
+		return unitSingleton;
+	} else if (value == nil) {
+		static RACReturnSignal *nilSingleton;
+		static dispatch_once_t nilPred;
+
+		dispatch_once(&nilPred, ^{
+			nilSingleton = [[self alloc] init];
+			nilSingleton->_value = nil;
+		});
+
+		return nilSingleton;
+	}
+#endif
+
+	RACReturnSignal *signal = [[self alloc] init];
+	signal->_value = value;
+
+#ifdef DEBUG
+	[signal setNameWithFormat:@"+return: %@", value];
+#endif
+
+	return signal;
+}
+
+#pragma mark Subscription
+
+- (RACDisposable *)subscribe:(id<RACSubscriber>)subscriber {
+	NSCParameterAssert(subscriber != nil);
+
+	return [RACScheduler.subscriptionScheduler schedule:^{
+		[subscriber sendNext:self.value];
+		[subscriber sendCompleted];
+	}];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACScheduler+Private.h b/ReactiveCocoaFramework/ReactiveCocoa/RACScheduler+Private.h
new file mode 100644
index 0000000..2c91e66
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACScheduler+Private.h
@@ -0,0 +1,34 @@
+//
+//  RACScheduler+Private.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 11/29/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACScheduler.h"
+
+// The thread-specific current scheduler key.
+extern NSString * const RACSchedulerCurrentSchedulerKey;
+
+// A private interface for internal RAC use only.
+@interface RACScheduler ()
+
+// A dedicated scheduler that fills two requirements:
+//
+//   1. By the time subscription happens, we need a valid +currentScheduler.
+//   2. Subscription should happen as soon as possible.
+//
+// To fulfill those two, if we already have a valid +currentScheduler, it
+// immediately executes scheduled blocks. If we don't, it will execute scheduled
+// blocks with a private background scheduler.
++ (instancetype)subscriptionScheduler;
+
+// Initializes the receiver with the given name.
+//
+// name - The name of the scheduler. If nil, a default name will be used.
+//
+// Returns the initialized object.
+- (id)initWithName:(NSString *)name;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACScheduler.h b/ReactiveCocoaFramework/ReactiveCocoa/RACScheduler.h
new file mode 100644
index 0000000..ce1ee32
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACScheduler.h
@@ -0,0 +1,148 @@
+//
+//  RACScheduler.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 4/16/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+/// The priority for the scheduler.
+///
+/// RACSchedulerPriorityHigh       - High priority.
+/// RACSchedulerPriorityDefault    - Default priority.
+/// RACSchedulerPriorityLow        - Low priority.
+/// RACSchedulerPriorityBackground - Background priority.
+typedef enum : long {
+	RACSchedulerPriorityHigh = DISPATCH_QUEUE_PRIORITY_HIGH,
+	RACSchedulerPriorityDefault = DISPATCH_QUEUE_PRIORITY_DEFAULT,
+	RACSchedulerPriorityLow = DISPATCH_QUEUE_PRIORITY_LOW,
+	RACSchedulerPriorityBackground = DISPATCH_QUEUE_PRIORITY_BACKGROUND,
+} RACSchedulerPriority;
+
+/// Scheduled with -scheduleRecursiveBlock:, this type of block is passed a block
+/// with which it can call itself recursively.
+typedef void (^RACSchedulerRecursiveBlock)(void (^reschedule)(void));
+
+@class RACDisposable;
+
+/// Schedulers are used to control when and where work is performed.
+@interface RACScheduler : NSObject
+
+/// A singleton scheduler that immediately executes the blocks it is given.
+///
+/// **Note:** Unlike most other schedulers, this does not set the current
+/// scheduler. There may still be a valid +currentScheduler if this is used
+/// within a block scheduled on a different scheduler.
++ (RACScheduler *)immediateScheduler;
+
+/// A singleton scheduler that executes blocks in the main thread.
++ (RACScheduler *)mainThreadScheduler;
+
+/// Creates and returns a new background scheduler with the given priority and
+/// name. The name is for debug and instrumentation purposes only.
+///
+/// Scheduler creation is cheap. It's unnecessary to save the result of this
+/// method call unless you want to serialize some actions on the same background
+/// scheduler.
++ (RACScheduler *)schedulerWithPriority:(RACSchedulerPriority)priority name:(NSString *)name;
+
+/// Invokes +schedulerWithPriority:name: with a default name.
++ (RACScheduler *)schedulerWithPriority:(RACSchedulerPriority)priority;
+
+/// Invokes +schedulerWithPriority: with RACSchedulerPriorityDefault.
++ (RACScheduler *)scheduler;
+
+/// The current scheduler. This will only be valid when used from within a
+/// -[RACScheduler schedule:] block or when on the main thread.
++ (RACScheduler *)currentScheduler;
+
+/// Schedule the given block for execution on the scheduler.
+///
+/// Scheduled blocks will be executed in the order in which they were scheduled.
+///
+/// block - The block to schedule for execution. Cannot be nil.
+///
+/// Returns a disposable which can be used to cancel the scheduled block before
+/// it begins executing, or nil if cancellation is not supported.
+- (RACDisposable *)schedule:(void (^)(void))block;
+
+/// Schedule the given block for execution on the scheduler at or after
+/// a specific time.
+///
+/// Note that blocks scheduled for a certain time will not preempt any other
+/// scheduled work that is executing at the time.
+///
+/// When invoked on the +immediateScheduler, the calling thread **will block**
+/// until the specified time.
+///
+/// date  - The earliest time at which `block` should begin executing. The block
+///         may not execute immediately at this time, whether due to system load
+///         or another block on the scheduler currently being run. Cannot be nil.
+/// block - The block to schedule for execution. Cannot be nil.
+///
+/// Returns a disposable which can be used to cancel the scheduled block before
+/// it begins executing, or nil if cancellation is not supported.
+- (RACDisposable *)after:(NSDate *)date schedule:(void (^)(void))block;
+
+/// Schedule the given block for execution on the scheduler after the delay.
+///
+/// Converts the delay into an NSDate, then invokes `-after:schedule:`.
+- (RACDisposable *)afterDelay:(NSTimeInterval)delay schedule:(void (^)(void))block;
+
+/// Reschedule the given block at a particular interval, starting at a specific
+/// time, and with a given leeway for deferral.
+///
+/// Note that blocks scheduled for a certain time will not preempt any other
+/// scheduled work that is executing at the time.
+///
+/// Regardless of the value of `leeway`, the given block may not execute exactly
+/// at `when` or exactly on successive intervals, whether due to system load or
+/// because another block is currently being run on the scheduler.
+///
+/// It is considered undefined behavior to invoke this method on the
+/// +immediateScheduler.
+///
+/// date     - The earliest time at which `block` should begin executing. The
+///            block may not execute immediately at this time, whether due to
+///            system load or another block on the scheduler currently being
+///            run. Cannot be nil.
+/// interval - The interval at which the block should be rescheduled, starting
+///            from `date`. This will use the system wall clock, to avoid
+///            skew when the computer goes to sleep.
+/// leeway   - A hint to the system indicating the number of seconds that each
+///            scheduling can be deferred. Note that this is just a hint, and
+///            there may be some additional latency no matter what.
+/// block    - The block to repeatedly schedule for execution. Cannot be nil.
+///
+/// Returns a disposable which can be used to cancel the automatic scheduling and
+/// rescheduling, or nil if cancellation is not supported.
+- (RACDisposable *)after:(NSDate *)date repeatingEvery:(NSTimeInterval)interval withLeeway:(NSTimeInterval)leeway schedule:(void (^)(void))block;
+
+/// Schedule the given recursive block for execution on the scheduler. The
+/// scheduler will automatically flatten any recursive scheduling into iteration
+/// instead, so this can be used without issue for blocks that may keep invoking
+/// themselves forever.
+///
+/// Scheduled blocks will be executed in the order in which they were scheduled.
+///
+/// recursiveBlock - The block to schedule for execution. When invoked, the
+///                  recursive block will be passed a `void (^)(void)` block
+///                  which will reschedule the recursive block at the end of the
+///                  receiver's queue. This passed-in block will automatically
+///                  skip scheduling if the scheduling of the `recursiveBlock`
+///                  was disposed in the meantime.
+///
+/// Returns a disposable which can be used to cancel the scheduled block before
+/// it begins executing, or to stop it from rescheduling if it's already begun
+/// execution.
+- (RACDisposable *)scheduleRecursiveBlock:(RACSchedulerRecursiveBlock)recursiveBlock;
+
+@end
+
+@interface RACScheduler (Deprecated)
+
++ (RACScheduler *)schedulerWithQueue:(dispatch_queue_t)queue name:(NSString *)name __attribute__((deprecated("Use -[RACScheduler initWithName:targetQueue:] instead.")));
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACScheduler.m b/ReactiveCocoaFramework/ReactiveCocoa/RACScheduler.m
new file mode 100644
index 0000000..c829896
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACScheduler.m
@@ -0,0 +1,206 @@
+//
+//  RACScheduler.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 4/16/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACScheduler.h"
+#import "RACBacktrace.h"
+#import "RACCompoundDisposable.h"
+#import "RACDisposable.h"
+#import "RACImmediateScheduler.h"
+#import "RACScheduler+Private.h"
+#import "RACSubscriptionScheduler.h"
+#import "RACTargetQueueScheduler.h"
+
+// The key for the thread-specific current scheduler.
+NSString * const RACSchedulerCurrentSchedulerKey = @"RACSchedulerCurrentSchedulerKey";
+
+@interface RACScheduler ()
+@property (nonatomic, readonly, copy) NSString *name;
+@end
+
+@implementation RACScheduler
+
+#pragma mark NSObject
+
+- (NSString *)description {
+	return [NSString stringWithFormat:@"<%@: %p> %@", self.class, self, self.name];
+}
+
+#pragma mark Initializers
+
+- (id)initWithName:(NSString *)name {
+	self = [super init];
+	if (self == nil) return nil;
+
+	if (name == nil) {
+		_name = [NSString stringWithFormat:@"com.ReactiveCocoa.%@.anonymousScheduler", self.class];
+	} else {
+		_name = [name copy];
+	}
+
+	return self;
+}
+
+#pragma mark Schedulers
+
++ (instancetype)immediateScheduler {
+	static dispatch_once_t onceToken;
+	static RACScheduler *immediateScheduler;
+	dispatch_once(&onceToken, ^{
+		immediateScheduler = [[RACImmediateScheduler alloc] init];
+	});
+	
+	return immediateScheduler;
+}
+
++ (instancetype)mainThreadScheduler {
+	static dispatch_once_t onceToken;
+	static RACScheduler *mainThreadScheduler;
+	dispatch_once(&onceToken, ^{
+		mainThreadScheduler = [[RACTargetQueueScheduler alloc] initWithName:@"com.ReactiveCocoa.RACScheduler.mainThreadScheduler" targetQueue:dispatch_get_main_queue()];
+	});
+	
+	return mainThreadScheduler;
+}
+
++ (instancetype)schedulerWithPriority:(RACSchedulerPriority)priority name:(NSString *)name {
+	return [[RACTargetQueueScheduler alloc] initWithName:name targetQueue:dispatch_get_global_queue(priority, 0)];
+}
+
++ (instancetype)schedulerWithPriority:(RACSchedulerPriority)priority {
+	return [self schedulerWithPriority:priority name:@"com.ReactiveCocoa.RACScheduler.backgroundScheduler"];
+}
+
++ (instancetype)scheduler {
+	return [self schedulerWithPriority:RACSchedulerPriorityDefault];
+}
+
++ (instancetype)subscriptionScheduler {
+	static dispatch_once_t onceToken;
+	static RACScheduler *subscriptionScheduler;
+	dispatch_once(&onceToken, ^{
+		subscriptionScheduler = [[RACSubscriptionScheduler alloc] init];
+	});
+
+	return subscriptionScheduler;
+}
+
++ (BOOL)isOnMainThread {
+	return [NSOperationQueue.currentQueue isEqual:NSOperationQueue.mainQueue] || [NSThread isMainThread];
+}
+
++ (instancetype)currentScheduler {
+	RACScheduler *scheduler = NSThread.currentThread.threadDictionary[RACSchedulerCurrentSchedulerKey];
+	if (scheduler != nil) return scheduler;
+	if ([self.class isOnMainThread]) return RACScheduler.mainThreadScheduler;
+
+	return nil;
+}
+
+#pragma mark Scheduling
+
+- (RACDisposable *)schedule:(void (^)(void))block {
+	NSCAssert(NO, @"%@ must be implemented by subclasses.", NSStringFromSelector(_cmd));
+	return nil;
+}
+
+- (RACDisposable *)after:(NSDate *)date schedule:(void (^)(void))block {
+	NSCAssert(NO, @"%@ must be implemented by subclasses.", NSStringFromSelector(_cmd));
+	return nil;
+}
+
+- (RACDisposable *)afterDelay:(NSTimeInterval)delay schedule:(void (^)(void))block {
+	return [self after:[NSDate dateWithTimeIntervalSinceNow:delay] schedule:block];
+}
+
+- (RACDisposable *)after:(NSDate *)date repeatingEvery:(NSTimeInterval)interval withLeeway:(NSTimeInterval)leeway schedule:(void (^)(void))block {
+	NSCAssert(NO, @"%@ must be implemented by subclasses.", NSStringFromSelector(_cmd));
+	return nil;
+}
+
+- (RACDisposable *)scheduleRecursiveBlock:(RACSchedulerRecursiveBlock)recursiveBlock {
+	RACCompoundDisposable *disposable = [RACCompoundDisposable compoundDisposable];
+
+	[self scheduleRecursiveBlock:[recursiveBlock copy] addingToDisposable:disposable];
+	return disposable;
+}
+
+- (void)scheduleRecursiveBlock:(RACSchedulerRecursiveBlock)recursiveBlock addingToDisposable:(RACCompoundDisposable *)disposable {
+	@autoreleasepool {
+		RACCompoundDisposable *selfDisposable = [RACCompoundDisposable compoundDisposable];
+		[disposable addDisposable:selfDisposable];
+
+		__weak RACDisposable *weakSelfDisposable = selfDisposable;
+
+		RACDisposable *schedulingDisposable = [self schedule:^{
+			@autoreleasepool {
+				// At this point, we've been invoked, so our disposable is now useless.
+				[disposable removeDisposable:weakSelfDisposable];
+			}
+
+			if (disposable.disposed) return;
+
+			void (^reallyReschedule)(void) = ^{
+				if (disposable.disposed) return;
+				[self scheduleRecursiveBlock:recursiveBlock addingToDisposable:disposable];
+			};
+
+			// Protects the variables below.
+			//
+			// This doesn't actually need to be __block qualified, but Clang
+			// complains otherwise. :C
+			__block NSLock *lock = [[NSLock alloc] init];
+			lock.name = [NSString stringWithFormat:@"%@ %s", self, sel_getName(_cmd)];
+
+			__block NSUInteger rescheduleCount = 0;
+
+			// Set to YES once synchronous execution has finished. Further
+			// rescheduling should occur immediately (rather than being
+			// flattened).
+			__block BOOL rescheduleImmediately = NO;
+
+			@autoreleasepool {
+				recursiveBlock(^{
+					[lock lock];
+					BOOL immediate = rescheduleImmediately;
+					if (!immediate) ++rescheduleCount;
+					[lock unlock];
+
+					if (immediate) reallyReschedule();
+				});
+			}
+
+			[lock lock];
+			NSUInteger synchronousCount = rescheduleCount;
+			rescheduleImmediately = YES;
+			[lock unlock];
+
+			for (NSUInteger i = 0; i < synchronousCount; i++) {
+				reallyReschedule();
+			}
+		}];
+
+		[selfDisposable addDisposable:schedulingDisposable];
+	}
+}
+
+@end
+
+@implementation RACScheduler (Deprecated)
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-implementations"
+
++ (instancetype)schedulerWithQueue:(dispatch_queue_t)queue name:(NSString *)name {
+	NSCParameterAssert(queue != NULL);
+
+	return [[RACTargetQueueScheduler alloc] initWithName:name targetQueue:queue];
+}
+
+#pragma clang diagnostic pop
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACScopedDisposable.h b/ReactiveCocoaFramework/ReactiveCocoa/RACScopedDisposable.h
new file mode 100644
index 0000000..03da6a2
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACScopedDisposable.h
@@ -0,0 +1,19 @@
+//
+//  RACScopedDisposable.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 3/28/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACDisposable.h"
+
+
+/// A disposable that calls its own -dispose when it is dealloc'd.
+@interface RACScopedDisposable : RACDisposable
+
+/// Creates a new scoped disposable that will also dispose of the given
+/// disposable when it is dealloc'd.
++ (instancetype)scopedDisposableWithDisposable:(RACDisposable *)disposable;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACScopedDisposable.m b/ReactiveCocoaFramework/ReactiveCocoa/RACScopedDisposable.m
new file mode 100644
index 0000000..91115be
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACScopedDisposable.m
@@ -0,0 +1,32 @@
+//
+//  RACScopedDisposable.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 3/28/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACScopedDisposable.h"
+
+@implementation RACScopedDisposable
+
+#pragma mark Lifecycle
+
++ (instancetype)scopedDisposableWithDisposable:(RACDisposable *)disposable {
+	return [self disposableWithBlock:^{
+		[disposable dispose];
+	}];
+}
+
+- (void)dealloc {
+	[self dispose];
+}
+
+#pragma mark RACDisposable
+
+- (RACScopedDisposable *)asScopedDisposable {
+	// totally already are
+	return self;
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSequence.h b/ReactiveCocoaFramework/ReactiveCocoa/RACSequence.h
new file mode 100644
index 0000000..a39f840
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSequence.h
@@ -0,0 +1,154 @@
+//
+//  RACSequence.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-10-29.
+//  Copyright (c) 2012 GitHub. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "RACStream.h"
+
+@class RACScheduler;
+@class RACSignal;
+
+/// Represents an immutable sequence of values. Unless otherwise specified, the
+/// sequences' values are evaluated lazily on demand. Like Cocoa collections,
+/// sequences cannot contain nil.
+///
+/// Most inherited RACStream methods that accept a block will execute the block
+/// _at most_ once for each value that is evaluated in the returned sequence.
+/// Side effects are subject to the behavior described in
+/// +sequenceWithHeadBlock:tailBlock:.
+///
+/// Implemented as a class cluster. A minimal implementation for a subclass
+/// consists simply of -head and -tail.
+@interface RACSequence : RACStream <NSCoding, NSCopying, NSFastEnumeration>
+
+/// The first object in the sequence, or nil if the sequence is empty.
+///
+/// Subclasses must provide an implementation of this method.
+@property (nonatomic, strong, readonly) id head;
+
+/// All but the first object in the sequence, or nil if the sequence is empty.
+///
+/// Subclasses must provide an implementation of this method.
+@property (nonatomic, strong, readonly) RACSequence *tail;
+
+/// Evaluates the full sequence to produce an equivalently-sized array.
+@property (nonatomic, copy, readonly) NSArray *array;
+
+/// Returns an enumerator of all objects in the sequence.
+@property (nonatomic, copy, readonly) NSEnumerator *objectEnumerator;
+
+/// Converts a sequence into an eager sequence.
+///
+/// An eager sequence fully evaluates all of its values immediately. Sequences
+/// derived from an eager sequence will also be eager.
+///
+/// Returns a new eager sequence, or the receiver if the sequence is already
+/// eager.
+@property (nonatomic, copy, readonly) RACSequence *eagerSequence;
+
+/// Converts a sequence into a lazy sequence.
+///
+/// A lazy sequence evaluates its values on demand, as they are accessed.
+/// Sequences derived from a lazy sequence will also be lazy.
+///
+/// Returns a new lazy sequence, or the receiver if the sequence is already lazy.
+@property (nonatomic, copy, readonly) RACSequence *lazySequence;
+
+/// Invokes -signalWithScheduler: with a new RACScheduler.
+- (RACSignal *)signal;
+
+/// Evaluates the full sequence on the given scheduler.
+///
+/// Each item is evaluated in its own scheduled block, such that control of the
+/// scheduler is yielded between each value.
+///
+/// Returns a signal which sends the receiver's values on the given scheduler as
+/// they're evaluated.
+- (RACSignal *)signalWithScheduler:(RACScheduler *)scheduler;
+
+/// Applies a left fold to the sequence.
+///
+/// This is the same as iterating the sequence along with a provided start value.
+/// This uses a constant amount of memory. A left fold is left-associative so in
+/// the sequence [1,2,3] the block would applied in the following order:
+///  reduce(reduce(reduce(start, 1), 2), 3)
+///
+/// start  - The starting value for the fold. Used as `accumulator` for the
+///          first fold.
+/// reduce - The block used to combine the accumulated value and the next value.
+///          Cannot be nil.
+///
+/// Returns a reduced value.
+- (id)foldLeftWithStart:(id)start reduce:(id (^)(id accumulator, id value))reduce;
+
+/// Applies a right fold to the sequence.
+///
+/// A right fold is equivalent to recursion on the list. The block is evaluated
+/// from the right to the left in list. It is right associative so it's applied
+/// to the rightmost elements first. For example, in the sequence [1,2,3] the
+/// block is applied in the order:
+///   reduce(1, reduce(2, reduce(3, start)))
+///
+/// start  - The starting value for the fold.
+/// reduce - The block used to combine the accumulated value and the next head.
+///          The block is given the accumulated value and the value of the rest
+///          of the computation (result of the recursion). This is computed when
+///          you retrieve its value using `rest.head`. This allows you to
+///          prevent unnecessary computation by not accessing `rest.head` if you
+///          don't need to.
+///
+/// Returns a reduced value.
+- (id)foldRightWithStart:(id)start reduce:(id (^)(id first, RACSequence *rest))reduce;
+
+/// Check if any value in sequence passes the block.
+///
+/// block - The block predicate used to check each item. Cannot be nil.
+///
+/// Returns a boolean indiciating if any value in the sequence passed.
+- (BOOL)any:(BOOL (^)(id value))block;
+
+/// Check if all values in the sequence pass the block.
+///
+/// block - The block predicate used to check each item. Cannot be nil.
+///
+/// Returns a boolean indicating if all values in the sequence passed.
+- (BOOL)all:(BOOL (^)(id value))block;
+
+/// Returns the first object that passes the block.
+///
+/// block - The block predicate used to check each item. Cannot be nil.
+///
+/// Returns an object that passes the block or nil if no objects passed.
+- (id)objectPassingTest:(BOOL (^)(id value))block;
+
+/// Creates a sequence that dynamically generates its values.
+///
+/// headBlock - Invoked the first time -head is accessed.
+/// tailBlock - Invoked the first time -tail is accessed.
+///
+/// The results from each block are memoized, so each block will be invoked at
+/// most once, no matter how many times the head and tail properties of the
+/// sequence are accessed.
+///
+/// Any side effects in `headBlock` or `tailBlock` should be thread-safe, since
+/// the sequence may be evaluated at any time from any thread. Not only that, but
+/// -tail may be accessed before -head, or both may be accessed simultaneously.
+/// As noted above, side effects will only be triggered the _first_ time -head or
+/// -tail is invoked.
+///
+/// Returns a sequence that lazily invokes the given blocks to provide head and
+/// tail. `headBlock` must not be nil.
++ (RACSequence *)sequenceWithHeadBlock:(id (^)(void))headBlock tailBlock:(RACSequence *(^)(void))tailBlock;
+
+@end
+
+@interface RACSequence (Deprecated)
+
+- (id)foldLeftWithStart:(id)start combine:(id (^)(id accumulator, id value))combine __attribute__((deprecated("Renamed to -foldLeftWithStart:reduce:")));
+- (id)foldRightWithStart:(id)start combine:(id (^)(id first, RACSequence *rest))combine __attribute__((deprecated("Renamed to -foldRightWithStart:reduce:")));
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSequence.m b/ReactiveCocoaFramework/ReactiveCocoa/RACSequence.m
new file mode 100644
index 0000000..9567ea8
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSequence.m
@@ -0,0 +1,384 @@
+//
+//  RACSequence.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-10-29.
+//  Copyright (c) 2012 GitHub. All rights reserved.
+//
+
+#import "RACSequence.h"
+#import "RACArraySequence.h"
+#import "RACDynamicSequence.h"
+#import "RACEagerSequence.h"
+#import "RACEmptySequence.h"
+#import "RACScheduler.h"
+#import "RACSignal.h"
+#import "RACSubscriber.h"
+#import "RACTuple.h"
+#import "RACUnarySequence.h"
+
+// An enumerator over sequences.
+@interface RACSequenceEnumerator : NSEnumerator
+
+// The sequence the enumerator is enumerating.
+//
+// This will change as the enumerator is exhausted. This property should only be
+// accessed while synchronized on self.
+@property (nonatomic, strong) RACSequence *sequence;
+
+@end
+
+@interface RACSequence ()
+
+// Performs one iteration of lazy binding, passing through values from `current`
+// until the sequence is exhausted, then recursively binding the remaining
+// values in the receiver.
+//
+// Returns a new sequence which contains `current`, followed by the combined
+// result of all applications of `block` to the remaining values in the receiver.
+- (instancetype)bind:(RACStreamBindBlock)block passingThroughValuesFromSequence:(RACSequence *)current;
+
+@end
+
+@implementation RACSequenceEnumerator
+
+- (id)nextObject {
+	id object = nil;
+	
+	@synchronized (self) {
+		object = self.sequence.head;
+		self.sequence = self.sequence.tail;
+	}
+	
+	return object;
+}
+
+@end
+
+@implementation RACSequence
+
+#pragma mark Lifecycle
+
++ (RACSequence *)sequenceWithHeadBlock:(id (^)(void))headBlock tailBlock:(RACSequence *(^)(void))tailBlock {
+	return [[RACDynamicSequence sequenceWithHeadBlock:headBlock tailBlock:tailBlock] setNameWithFormat:@"+sequenceWithHeadBlock:tailBlock:"];
+}
+
+#pragma mark Class cluster primitives
+
+- (id)head {
+	NSCAssert(NO, @"%s must be overridden by subclasses", __func__);
+	return nil;
+}
+
+- (RACSequence *)tail {
+	NSCAssert(NO, @"%s must be overridden by subclasses", __func__);
+	return nil;
+}
+
+#pragma mark RACStream
+
++ (instancetype)empty {
+	return RACEmptySequence.empty;
+}
+
++ (instancetype)return:(id)value {
+	return [RACUnarySequence return:value];
+}
+
+- (instancetype)bind:(RACStreamBindBlock (^)(void))block {
+	RACStreamBindBlock bindBlock = block();
+	return [[self bind:bindBlock passingThroughValuesFromSequence:nil] setNameWithFormat:@"[%@] -bind:", self.name];
+}
+
+- (instancetype)bind:(RACStreamBindBlock)bindBlock passingThroughValuesFromSequence:(RACSequence *)passthroughSequence {
+	// Store values calculated in the dependency here instead, avoiding any kind
+	// of temporary collection and boxing.
+	//
+	// This relies on the implementation of RACDynamicSequence synchronizing
+	// access to its head, tail, and dependency, and we're only doing it because
+	// we really need the performance.
+	__block RACSequence *valuesSeq = self;
+	__block RACSequence *current = passthroughSequence;
+	__block BOOL stop = NO;
+
+	RACSequence *sequence = [RACDynamicSequence sequenceWithLazyDependency:^ id {
+		while (current.head == nil) {
+			if (stop) return nil;
+
+			// We've exhausted the current sequence, create a sequence from the
+			// next value.
+			id value = valuesSeq.head;
+
+			if (value == nil) {
+				// We've exhausted all the sequences.
+				stop = YES;
+				return nil;
+			}
+
+			current = (id)bindBlock(value, &stop);
+			if (current == nil) {
+				stop = YES;
+				return nil;
+			}
+
+			valuesSeq = valuesSeq.tail;
+		}
+
+		NSCAssert([current isKindOfClass:RACSequence.class], @"-bind: block returned an object that is not a sequence: %@", current);
+		return nil;
+	} headBlock:^(id _) {
+		return current.head;
+	} tailBlock:^ id (id _) {
+		if (stop) return nil;
+
+		return [valuesSeq bind:bindBlock passingThroughValuesFromSequence:current.tail];
+	}];
+
+	sequence.name = self.name;
+	return sequence;
+}
+
+- (instancetype)concat:(RACStream *)stream {
+	NSCParameterAssert(stream != nil);
+
+	return [[[RACArraySequence sequenceWithArray:@[ self, stream ] offset:0]
+		flatten]
+		setNameWithFormat:@"[%@] -concat: %@", self.name, stream];
+}
+
+- (instancetype)zipWith:(RACSequence *)sequence {
+	NSCParameterAssert(sequence != nil);
+
+	return [[RACSequence
+		sequenceWithHeadBlock:^ id {
+			if (self.head == nil || sequence.head == nil) return nil;
+			return RACTuplePack(self.head, sequence.head);
+		} tailBlock:^ id {
+			if (self.tail == nil || [[RACSequence empty] isEqual:self.tail]) return nil;
+			if (sequence.tail == nil || [[RACSequence empty] isEqual:sequence.tail]) return nil;
+
+			return [self.tail zipWith:sequence.tail];
+		}]
+		setNameWithFormat:@"[%@] -zipWith: %@", self.name, sequence];
+}
+
+#pragma mark Extended methods
+
+- (NSArray *)array {
+	NSMutableArray *array = [NSMutableArray array];
+	for (id obj in self) {
+		[array addObject:obj];
+	}
+
+	return [array copy];
+}
+
+- (NSEnumerator *)objectEnumerator {
+	RACSequenceEnumerator *enumerator = [[RACSequenceEnumerator alloc] init];
+	enumerator.sequence = self;
+	return enumerator;
+}
+
+- (RACSignal *)signal {
+	return [[self signalWithScheduler:[RACScheduler scheduler]] setNameWithFormat:@"[%@] -signal", self.name];
+}
+
+- (RACSignal *)signalWithScheduler:(RACScheduler *)scheduler {
+	return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+		__block RACSequence *sequence = self;
+
+		return [scheduler scheduleRecursiveBlock:^(void (^reschedule)(void)) {
+			if (sequence.head == nil) {
+				[subscriber sendCompleted];
+				return;
+			}
+
+			[subscriber sendNext:sequence.head];
+
+			sequence = sequence.tail;
+			reschedule();
+		}];
+	}] setNameWithFormat:@"[%@] -signalWithScheduler:", self.name];
+}
+
+- (id)foldLeftWithStart:(id)start reduce:(id (^)(id, id))reduce {
+	NSCParameterAssert(reduce != NULL);
+
+	if (self.head == nil) return start;
+	
+	for (id value in self) {
+		start = reduce(start, value);
+	}
+	
+	return start;
+}
+
+- (id)foldRightWithStart:(id)start reduce:(id (^)(id, RACSequence *))reduce {
+	NSCParameterAssert(reduce != NULL);
+
+	if (self.head == nil) return start;
+	
+	RACSequence *rest = [RACSequence sequenceWithHeadBlock:^{
+		return [self.tail foldRightWithStart:start reduce:reduce];
+	} tailBlock:nil];
+	
+	return reduce(self.head, rest);
+}
+
+- (BOOL)any:(BOOL (^)(id))block {
+	NSCParameterAssert(block != NULL);
+
+	return [self objectPassingTest:block] != nil;
+}
+
+- (BOOL)all:(BOOL (^)(id))block {
+	NSCParameterAssert(block != NULL);
+	
+	NSNumber *result = [self foldLeftWithStart:@YES reduce:^(NSNumber *accumulator, id value) {
+		return @(accumulator.boolValue && block(value));
+	}];
+	
+	return result.boolValue;
+}
+
+- (id)objectPassingTest:(BOOL (^)(id))block {
+	NSCParameterAssert(block != NULL);
+
+	return [self filter:block].head;
+}
+
+- (RACSequence *)eagerSequence {
+	return [RACEagerSequence sequenceWithArray:self.array offset:0];
+}
+
+- (RACSequence *)lazySequence {
+	return self;
+}
+
+#pragma mark NSCopying
+
+- (id)copyWithZone:(NSZone *)zone {
+	return self;
+}
+
+#pragma mark NSCoding
+
+- (Class)classForCoder {
+	// Most sequences should be archived as RACArraySequences.
+	return RACArraySequence.class;
+}
+
+- (id)initWithCoder:(NSCoder *)coder {
+	if (![self isKindOfClass:RACArraySequence.class]) return [[RACArraySequence alloc] initWithCoder:coder];
+
+	// Decoding is handled in RACArraySequence.
+	return [super init];
+}
+
+- (void)encodeWithCoder:(NSCoder *)coder {
+	[coder encodeObject:self.array forKey:@"array"];
+}
+
+#pragma mark NSFastEnumeration
+
+- (NSUInteger)countByEnumeratingWithState:(NSFastEnumerationState *)state objects:(__unsafe_unretained id *)stackbuf count:(NSUInteger)len {
+	if (state->state == ULONG_MAX) {
+		// Enumeration has completed.
+		return 0;
+	}
+
+	// We need to traverse the sequence itself on repeated calls to this
+	// method, so use the 'state' field to track the current head.
+	RACSequence *(^getSequence)(void) = ^{
+		return (__bridge RACSequence *)(void *)state->state;
+	};
+
+	void (^setSequence)(RACSequence *) = ^(RACSequence *sequence) {
+		// Release the old sequence and retain the new one.
+		CFBridgingRelease((void *)state->state);
+
+		state->state = (unsigned long)CFBridgingRetain(sequence);
+	};
+
+	void (^complete)(void) = ^{
+		// Release any stored sequence.
+		setSequence(nil);
+		state->state = ULONG_MAX;
+	};
+
+	if (state->state == 0) {
+		// Since a sequence doesn't mutate, this just needs to be set to
+		// something non-NULL.
+		state->mutationsPtr = state->extra;
+
+		setSequence(self);
+	}
+
+	state->itemsPtr = stackbuf;
+
+	NSUInteger enumeratedCount = 0;
+	while (enumeratedCount < len) {
+		RACSequence *seq = getSequence();
+
+		// Because the objects in a sequence may be generated lazily, we want to
+		// prevent them from being released until the enumerator's used them.
+		__autoreleasing id obj = seq.head;
+		if (obj == nil) {
+			complete();
+			break;
+		}
+
+		stackbuf[enumeratedCount++] = obj;
+
+		if (seq.tail == nil) {
+			complete();
+			break;
+		}
+
+		setSequence(seq.tail);
+	}
+
+	return enumeratedCount;
+}
+
+#pragma mark NSObject
+
+- (NSUInteger)hash {
+	return [self.head hash];
+}
+
+- (BOOL)isEqual:(RACSequence *)seq {
+	if (self == seq) return YES;
+	if (![seq isKindOfClass:RACSequence.class]) return NO;
+
+	for (id<NSObject> selfObj in self) {
+		id<NSObject> seqObj = seq.head;
+
+		// Handles the nil case too.
+		if (![seqObj isEqual:selfObj]) return NO;
+
+		seq = seq.tail;
+	}
+
+	// self is now depleted -- the argument should be too.
+	return (seq.head == nil);
+}
+
+@end
+
+@implementation RACSequence (Deprecated)
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-implementations"
+
+- (id)foldLeftWithStart:(id)start combine:(id (^)(id accumulator, id value))combine {
+	return [self foldLeftWithStart:start reduce:combine];
+}
+
+- (id)foldRightWithStart:(id)start combine:(id (^)(id first, RACSequence *rest))combine {
+	return [self foldRightWithStart:start reduce:combine];
+}
+
+#pragma clang diagnostic pop
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSerialDisposable.h b/ReactiveCocoaFramework/ReactiveCocoa/RACSerialDisposable.h
new file mode 100644
index 0000000..a3fc1d4
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSerialDisposable.h
@@ -0,0 +1,43 @@
+//
+//  RACSerialDisposable.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-07-22.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACDisposable.h"
+
+/// A disposable that contains exactly one other disposable and allows it to be
+/// swapped out atomically.
+@interface RACSerialDisposable : RACDisposable
+
+/// The inner disposable managed by the serial disposable.
+///
+/// This property is thread-safe for reading and writing. However, if you want to
+/// read the current value _and_ write a new one atomically, use
+/// -swapInDisposable: instead.
+///
+/// Disposing of the receiver will also dispose of the current disposable set for
+/// this property, then set the property to nil. If any new disposable is set
+/// after the receiver is disposed, it will be disposed immediately and this
+/// property will remain set to nil.
+@property (atomic, strong) RACDisposable *disposable;
+
+/// Creates a serial disposable which will wrap the given disposable.
+///
+/// disposable - The value to set for `disposable`. This may be nil.
+///
+/// Returns a RACSerialDisposable, or nil if an error occurs.
++ (instancetype)serialDisposableWithDisposable:(RACDisposable *)disposable;
+
+/// Atomically swaps the receiver's `disposable` for `newDisposable`.
+///
+/// newDisposable - The new value for `disposable`. If the receiver has already
+///                 been disposed, this disposable will be too, and `disposable`
+///                 will remain set to nil. This argument may be nil.
+///
+/// Returns the previous value for the `disposable` property.
+- (RACDisposable *)swapInDisposable:(RACDisposable *)newDisposable;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSerialDisposable.m b/ReactiveCocoaFramework/ReactiveCocoa/RACSerialDisposable.m
new file mode 100644
index 0000000..975afbf
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSerialDisposable.m
@@ -0,0 +1,133 @@
+//
+//  RACSerialDisposable.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-07-22.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSerialDisposable.h"
+#import <libkern/OSAtomic.h>
+
+@interface RACSerialDisposable () {
+	// A reference to the receiver's `disposable`. This variable must only be
+	// modified atomically.
+	//
+	// If this is `self`, no `disposable` has been set, but the receiver has not
+	// been disposed of yet. `self` is never stored retained.
+	//
+	// If this is `nil`, the receiver has been disposed.
+	//
+	// Otherwise, this is a retained reference to the inner disposable and the
+	// receiver has not been disposed of yet.
+	void * volatile _disposablePtr;
+}
+
+@end
+
+@implementation RACSerialDisposable
+
+#pragma mark Properties
+
+- (BOOL)isDisposed {
+	return _disposablePtr == nil;
+}
+
+- (RACDisposable *)disposable {
+	RACDisposable *disposable = (__bridge id)_disposablePtr;
+	return (disposable == self ? nil : disposable);
+}
+
+- (void)setDisposable:(RACDisposable *)disposable {
+	[self swapInDisposable:disposable];
+}
+
+#pragma mark Lifecycle
+
++ (instancetype)serialDisposableWithDisposable:(RACDisposable *)disposable {
+	RACSerialDisposable *serialDisposable = [[self alloc] init];
+	serialDisposable.disposable = disposable;
+	return serialDisposable;
+}
+
+- (id)init {
+	self = [super init];
+	if (self == nil) return nil;
+
+	_disposablePtr = (__bridge void *)self;
+	OSMemoryBarrier();
+
+	return self;
+}
+
+- (id)initWithBlock:(void (^)(void))block {
+	self = [self init];
+	if (self == nil) return nil;
+
+	self.disposable = [RACDisposable disposableWithBlock:block];
+
+	return self;
+}
+
+- (void)dealloc {
+	self.disposable = nil;
+}
+
+#pragma mark Inner Disposable
+
+- (RACDisposable *)swapInDisposable:(RACDisposable *)newDisposable {
+	void * const selfPtr = (__bridge void *)self;
+
+	// Only retain the new disposable if it's not `self`.
+	// Take ownership before attempting the swap so that a subsequent swap
+	// receives an owned reference.
+	void *newDisposablePtr = selfPtr;
+	if (newDisposable != nil) {
+		newDisposablePtr = (void *)CFBridgingRetain(newDisposable);
+	}
+
+	void *existingDisposablePtr;
+	// Keep trying while we're not disposed.
+	while ((existingDisposablePtr = _disposablePtr) != NULL) {
+		if (!OSAtomicCompareAndSwapPtrBarrier(existingDisposablePtr, newDisposablePtr, &_disposablePtr)) {
+			continue;
+		}
+
+		// Return nil if _disposablePtr was set to self. Otherwise, release
+		// the old value and return it as an object.
+		if (existingDisposablePtr == selfPtr) {
+			return nil;
+		} else {
+			return CFBridgingRelease(existingDisposablePtr);
+		}
+	}
+
+	// At this point, we've found out that we were already disposed.
+	[newDisposable dispose];
+
+	// Failed to swap, clean up the ownership we took prior to the swap.
+	if (newDisposable != nil) {
+		CFRelease(newDisposablePtr);
+	}
+
+	return nil;
+}
+
+#pragma mark Disposal
+
+- (void)dispose {
+	void *existingDisposablePtr;
+
+	while ((existingDisposablePtr = _disposablePtr) != NULL) {
+		if (OSAtomicCompareAndSwapPtrBarrier(existingDisposablePtr, NULL, &_disposablePtr)) {
+			if (existingDisposablePtr != (__bridge void *)self) {
+				RACDisposable *existingDisposable = CFBridgingRelease(existingDisposablePtr);
+				[existingDisposable dispose];
+			}
+
+			break;
+		}
+	}
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSignal+Operations.h b/ReactiveCocoaFramework/ReactiveCocoa/RACSignal+Operations.h
new file mode 100644
index 0000000..53b10d6
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSignal+Operations.h
@@ -0,0 +1,625 @@
+//
+//  RACSignal+Operations.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-09-06.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "RACSignal.h"
+
+/// The domain for errors originating in RACSignal operations.
+extern NSString * const RACSignalErrorDomain;
+
+/// The error code used with -timeout:.
+extern const NSInteger RACSignalErrorTimedOut;
+
+/// The error code used when a value passed into +switch:cases:default: does not
+/// match any of the cases, and no default was given.
+extern const NSInteger RACSignalErrorNoMatchingCase;
+
+@class RACMulticastConnection;
+@class RACDisposable;
+@class RACScheduler;
+@class RACSequence;
+@class RACSubject;
+@class RACTuple;
+@class RACCommand;
+@protocol RACSubscriber;
+
+@interface RACSignal (Operations)
+
+/// Do the given block on `next`. This should be used to inject side effects into
+/// the signal.
+- (RACSignal *)doNext:(void (^)(id x))block;
+
+/// Do the given block on `error`. This should be used to inject side effects
+/// into the signal.
+- (RACSignal *)doError:(void (^)(NSError *error))block;
+
+/// Do the given block on `completed`. This should be used to inject side effects
+/// into the signal.
+- (RACSignal *)doCompleted:(void (^)(void))block;
+
+/// Send `next`s only if we don't receive another `next` in `interval` seconds.
+///
+/// If a `next` is received, and then another `next` is received before
+/// `interval` seconds have passed, the first value is discarded.
+///
+/// After `interval` seconds have passed since the most recent `next` was sent,
+/// the most recent `next` is forwarded on the scheduler that the value was
+/// originally received on. If +[RACScheduler currentScheduler] was nil at the
+/// time, a private background scheduler is used.
+///
+/// Returns a signal which sends throttled and delayed `next` events. Completion
+/// and errors are always forwarded immediately.
+- (RACSignal *)throttle:(NSTimeInterval)interval;
+
+/// Throttles `next`s for which `predicate` returns YES.
+///
+/// When `predicate` returns YES for a `next`:
+///
+///  1. If another `next` is received before `interval` seconds have passed, the
+///     prior value is discarded. This happens regardless of whether the new
+///     value will be throttled.
+///  2. After `interval` seconds have passed since the value was originally
+///     received, it will be forwarded on the scheduler that it was received
+///     upon. If +[RACScheduler currentScheduler] was nil at the time, a private
+///     background scheduler is used.
+///
+/// When `predicate` returns NO for a `next`, it is forwarded immediately,
+/// without any throttling.
+///
+/// interval  - The number of seconds for which to buffer the latest value that
+///             passes `predicate`.
+/// predicate - Passed each `next` from the receiver, this block returns
+///             whether the given value should be throttled. This argument must
+///             not be nil.
+///
+/// Returns a signal which sends `next` events, throttled when `predicate`
+/// returns YES. Completion and errors are always forwarded immediately.
+- (RACSignal *)throttle:(NSTimeInterval)interval valuesPassingTest:(BOOL (^)(id next))predicate;
+
+/// Forwards `next` and `completed` events after delaying for `interval` seconds
+/// on the current scheduler (on which the events were delivered).
+///
+/// If +[RACScheduler currentScheduler] is nil when `next` or `completed` is
+/// received, a private background scheduler is used.
+///
+/// Returns a signal which sends delayed `next` and `completed` events. Errors
+/// are always forwarded immediately.
+- (RACSignal *)delay:(NSTimeInterval)interval;
+
+/// Resubscribes when the signal completes.
+- (RACSignal *)repeat;
+
+/// Execute the given block each time a subscription is created.
+///
+/// block - A block which defines the subscription side effects. Cannot be `nil`.
+///
+/// Example:
+///
+///   // Write new file, with backup.
+///   [[[[fileManager
+///       rac_createFileAtPath:path contents:data]
+///       initially:^{
+///           // 2. Second, backup current file
+///           [fileManager moveItemAtPath:path toPath:backupPath error:nil];
+///       }]
+///       initially:^{
+///           // 1. First, acquire write lock.
+///           [writeLock lock];
+///       }]
+///       finally:^{
+///           [writeLock unlock];
+///       }];
+///
+/// Returns a signal that passes through all events of the receiver, plus
+/// introduces side effects which occur prior to any subscription side effects
+/// of the receiver.
+- (RACSignal *)initially:(void (^)(void))block;
+
+/// Execute the given block when the signal completes or errors.
+- (RACSignal *)finally:(void (^)(void))block;
+
+/// Divides the receiver's `next`s into buffers which deliver every `interval`
+/// seconds.
+///
+/// interval  - The interval in which values are grouped into one buffer.
+/// scheduler - The scheduler upon which the returned signal will deliver its
+///             values. This must not be nil or +[RACScheduler
+///             immediateScheduler].
+///
+/// Returns a signal which sends RACTuples of the buffered values at each
+/// interval on `scheduler`. When the receiver completes, any currently-buffered
+/// values will be sent immediately.
+- (RACSignal *)bufferWithTime:(NSTimeInterval)interval onScheduler:(RACScheduler *)scheduler;
+
+/// Collect all receiver's `next`s into a NSArray. nil values will be converted
+/// to NSNull.
+///
+/// This corresponds to the `ToArray` method in Rx.
+///
+/// Returns a signal which sends a single NSArray when the receiver completes
+/// successfully.
+- (RACSignal *)collect;
+
+/// Takes the last `count` `next`s after the receiving signal completes.
+- (RACSignal *)takeLast:(NSUInteger)count;
+
+/// Combines the latest values from the receiver and the given signal into
+/// RACTuples, once both have sent at least one `next`.
+///
+/// Any additional `next`s will result in a new RACTuple with the latest values
+/// from both signals.
+///
+/// signal - The signal to combine with. This argument must not be nil.
+///
+/// Returns a signal which sends RACTuples of the combined values, forwards any
+/// `error` events, and completes when both input signals complete.
+- (RACSignal *)combineLatestWith:(RACSignal *)signal;
+
+/// Combines the latest values from the given signals into RACTuples, once all
+/// the signals have sent at least one `next`.
+///
+/// Any additional `next`s will result in a new RACTuple with the latest values
+/// from all signals.
+///
+/// signals - The signals to combine. If this collection is empty, the returned
+///           signal will immediately complete upon subscription.
+///
+/// Returns a signal which sends RACTuples of the combined values, forwards any
+/// `error` events, and completes when all input signals complete.
++ (RACSignal *)combineLatest:(id<NSFastEnumeration>)signals;
+
+/// Combines signals using +combineLatest:, then reduces the resulting tuples
+/// into a single value using -reduceEach:.
+///
+/// signals     - The signals to combine. If this collection is empty, the
+///               returned signal will immediately complete upon subscription.
+/// reduceBlock - The block which reduces the latest values from all the
+///               signals into one value. It must take as many arguments as the
+///               number of signals given. Each argument will be an object
+///               argument. The return value must be an object. This argument
+///               must not be nil.
+///
+/// Example:
+///
+///   [RACSignal combineLatest:@[ stringSignal, intSignal ] reduce:^(NSString *string, NSNumber *number) {
+///       return [NSString stringWithFormat:@"%@: %@", string, number];
+///   }];
+///
+/// Returns a signal which sends the results from each invocation of
+/// `reduceBlock`.
++ (RACSignal *)combineLatest:(id<NSFastEnumeration>)signals reduce:(id (^)())reduceBlock;
+
+/// Merges the receiver and the given signal with `+merge:` and returns the
+/// resulting signal.
+- (RACSignal *)merge:(RACSignal *)signal;
+
+/// Sends the latest `next` from any of the signals.
+///
+/// Returns a signal that passes through values from each of the given signals,
+/// and sends `completed` when all of them complete. If any signal sends an error,
+/// the returned signal sends `error` immediately.
++ (RACSignal *)merge:(id<NSFastEnumeration>)signals;
+
+/// Merges the signals sent by the receiver into a flattened signal, but only
+/// subscribes to `maxConcurrent` number of signals at a time. New signals are
+/// queued and subscribed to as other signals complete.
+///
+/// If an error occurs on any of the signals, it is sent on the returned signal.
+/// It completes only after the receiver and all sent signals have completed.
+///
+/// This corresponds to `Merge<TSource>(IObservable<IObservable<TSource>>, Int32)`
+/// in Rx.
+///
+/// maxConcurrent - the maximum number of signals to subscribe to at a
+///                 time. If 0, it subscribes to an unlimited number of
+///                 signals.
+- (RACSignal *)flatten:(NSUInteger)maxConcurrent;
+
+/// Ignores all `next`s from the receiver, waits for the receiver to complete,
+/// then subscribes to a new signal.
+///
+/// block - A block which will create or obtain a new signal to subscribe to,
+///         executed only after the receiver completes. This block must not be
+///         nil, and it must not return a nil signal.
+///
+/// Returns a signal which will pass through the events of the signal created in
+/// `block`. If the receiver errors out, the returned signal will error as well.
+- (RACSignal *)then:(RACSignal * (^)(void))block;
+
+/// Concats the inner signals of a signal of signals.
+- (RACSignal *)concat;
+
+/// Aggregate `next`s with the given start and combination.
+- (RACSignal *)aggregateWithStart:(id)start reduce:(id (^)(id running, id next))reduceBlock;
+
+/// Aggregate `next`s with the given start and combination. The start factory 
+/// block is called to get a new start object for each subscription.
+- (RACSignal *)aggregateWithStartFactory:(id (^)(void))startFactory reduce:(id (^)(id running, id next))reduceBlock;
+
+/// Invokes -setKeyPath:onObject:nilValue: with `nil` for the nil value.
+///
+/// WARNING: Under certain conditions, this method is known to be thread-unsafe.
+///          See the description in -setKeyPath:onObject:nilValue:.
+- (RACDisposable *)setKeyPath:(NSString *)keyPath onObject:(NSObject *)object;
+
+/// Binds the receiver to an object, automatically setting the given key path on
+/// every `next`. When the signal completes, the binding is automatically
+/// disposed of.
+///
+/// WARNING: Under certain conditions, this method is known to be thread-unsafe.
+///          A crash can result if `object` is deallocated concurrently on
+///          another thread within a window of time between a value being sent
+///          on this signal and immediately prior to the invocation of
+///          -setValue:forKeyPath:, which sets the property. To prevent this,
+///          ensure `object` is deallocated on the same thread the receiver
+///          sends on, or ensure that the returned disposable is disposed of
+///          before `object` deallocates.
+///          See https://github.com/ReactiveCocoa/ReactiveCocoa/pull/1184
+///
+/// Sending an error on the signal is considered undefined behavior, and will
+/// generate an assertion failure in Debug builds.
+///
+/// A given key on an object should only have one active signal bound to it at any
+/// given time. Binding more than one signal to the same property is considered
+/// undefined behavior.
+///
+/// keyPath  - The key path to update with `next`s from the receiver.
+/// object   - The object that `keyPath` is relative to.
+/// nilValue - The value to set at the key path whenever `nil` is sent by the
+///            receiver. This may be nil when binding to object properties, but
+///            an NSValue should be used for primitive properties, to avoid an
+///            exception if `nil` is sent (which might occur if an intermediate
+///            object is set to `nil`).
+///
+/// Returns a disposable which can be used to terminate the binding.
+- (RACDisposable *)setKeyPath:(NSString *)keyPath onObject:(NSObject *)object nilValue:(id)nilValue;
+
+/// Sends NSDate.date every `interval` seconds.
+///
+/// interval  - The time interval in seconds at which the current time is sent.
+/// scheduler - The scheduler upon which the current NSDate should be sent. This
+///             must not be nil or +[RACScheduler immediateScheduler].
+///
+/// Returns a signal that sends the current date/time every `interval` on
+/// `scheduler`.
++ (RACSignal *)interval:(NSTimeInterval)interval onScheduler:(RACScheduler *)scheduler;
+
+/// Sends NSDate.date at intervals of at least `interval` seconds, up to
+/// approximately `interval` + `leeway` seconds.
+///
+/// The created signal will defer sending each `next` for at least `interval`
+/// seconds, and for an additional amount of time up to `leeway` seconds in the
+/// interest of performance or power consumption. Note that some additional
+/// latency is to be expected, even when specifying a `leeway` of 0.
+///
+/// interval  - The base interval between `next`s.
+/// scheduler - The scheduler upon which the current NSDate should be sent. This
+///             must not be nil or +[RACScheduler immediateScheduler].
+/// leeway    - The maximum amount of additional time the `next` can be deferred.
+///
+/// Returns a signal that sends the current date/time at intervals of at least
+/// `interval seconds` up to approximately `interval` + `leeway` seconds on
+/// `scheduler`.
++ (RACSignal *)interval:(NSTimeInterval)interval onScheduler:(RACScheduler *)scheduler withLeeway:(NSTimeInterval)leeway;
+
+/// Take `next`s until the `signalTrigger` sends `next` or `completed`.
+///
+/// Returns a signal which passes through all events from the receiver until
+/// `signalTrigger` sends `next` or `completed`, at which point the returned signal
+/// will send `completed`.
+- (RACSignal *)takeUntil:(RACSignal *)signalTrigger;
+
+/// Take `next`s until the `replacement` sends an event.
+///
+/// replacement - The signal which replaces the receiver as soon as it sends an
+///               event.
+///
+/// Returns a signal which passes through `next`s and `error` from the receiver
+/// until `replacement` sends an event, at which point the returned signal will
+/// send that event and switch to passing through events from `replacement`
+/// instead, regardless of whether the receiver has sent events already.
+- (RACSignal *)takeUntilReplacement:(RACSignal *)replacement;
+
+/// Subscribe to the returned signal when an error occurs.
+- (RACSignal *)catch:(RACSignal * (^)(NSError *error))catchBlock;
+
+/// Subscribe to the given signal when an error occurs.
+- (RACSignal *)catchTo:(RACSignal *)signal;
+
+/// Runs `tryBlock` against each of the receiver's values, passing values
+/// until `tryBlock` returns NO, or the receiver completes.
+///
+/// tryBlock - An action to run against each of the receiver's values.
+///            The block should return YES to indicate that the action was
+///            successful. This block must not be nil.
+///
+/// Example:
+///
+///   // The returned signal will send an error if data values cannot be
+///   // written to `someFileURL`.
+///   [signal try:^(NSData *data, NSError **errorPtr) {
+///       return [data writeToURL:someFileURL options:NSDataWritingAtomic error:errorPtr];
+///   }];
+///
+/// Returns a signal which passes through all the values of the receiver. If
+/// `tryBlock` fails for any value, the returned signal will error using the
+/// `NSError` passed out from the block.
+- (RACSignal *)try:(BOOL (^)(id value, NSError **errorPtr))tryBlock;
+
+/// Runs `mapBlock` against each of the receiver's values, mapping values until
+/// `mapBlock` returns nil, or the receiver completes.
+///
+/// mapBlock - An action to map each of the receiver's values. The block should
+///            return a non-nil value to indicate that the action was successful.
+///            This block must not be nil.
+///
+/// Example:
+///
+///   // The returned signal will send an error if data cannot be read from
+///   // `fileURL`.
+///   [signal tryMap:^(NSURL *fileURL, NSError **errorPtr) {
+///       return [NSData dataWithContentsOfURL:fileURL options:0 error:errorPtr];
+///   }];
+///
+/// Returns a signal which transforms all the values of the receiver. If
+/// `mapBlock` returns nil for any value, the returned signal will error using
+/// the `NSError` passed out from the block.
+- (RACSignal *)tryMap:(id (^)(id value, NSError **errorPtr))mapBlock;
+
+/// Returns the first `next`. Note that this is a blocking call.
+- (id)first;
+
+/// Returns the first `next` or `defaultValue` if the signal completes or errors
+/// without sending a `next`. Note that this is a blocking call.
+- (id)firstOrDefault:(id)defaultValue;
+
+/// Returns the first `next` or `defaultValue` if the signal completes or errors
+/// without sending a `next`. If an error occurs success will be NO and error
+/// will be populated. Note that this is a blocking call.
+///
+/// Both success and error may be NULL.
+- (id)firstOrDefault:(id)defaultValue success:(BOOL *)success error:(NSError **)error;
+
+/// Blocks the caller and waits for the signal to complete.
+///
+/// error - If not NULL, set to any error that occurs.
+///
+/// Returns whether the signal completed successfully. If NO, `error` will be set
+/// to the error that occurred.
+- (BOOL)waitUntilCompleted:(NSError **)error;
+
+/// Defer creation of a signal until the signal's actually subscribed to.
+///
+/// This can be used to effectively turn a hot signal into a cold signal.
++ (RACSignal *)defer:(RACSignal * (^)(void))block;
+
+/// Every time the receiver sends a new RACSignal, subscribes and sends `next`s and
+/// `error`s only for that signal.
+///
+/// The receiver must be a signal of signals.
+///
+/// Returns a signal which passes through `next`s and `error`s from the latest
+/// signal sent by the receiver, and sends `completed` when both the receiver and
+/// the last sent signal complete.
+- (RACSignal *)switchToLatest;
+
+/// Switches between the signals in `cases` as well as `defaultSignal` based on
+/// the latest value sent by `signal`.
+///
+/// signal        - A signal of objects used as keys in the `cases` dictionary.
+///                 This argument must not be nil.
+/// cases         - A dictionary that has signals as values. This argument must
+///                 not be nil. A RACTupleNil key in this dictionary will match
+///                 nil `next` events that are received on `signal`.
+/// defaultSignal - The signal to pass through after `signal` sends a value for
+///                 which `cases` does not contain a signal. If nil, any
+///                 unmatched values will result in
+///                 a RACSignalErrorNoMatchingCase error.
+///
+/// Returns a signal which passes through `next`s and `error`s from one of the
+/// the signals in `cases` or `defaultSignal`, and sends `completed` when both
+/// `signal` and the last used signal complete. If no `defaultSignal` is given,
+/// an unmatched `next` will result in an error on the returned signal.
++ (RACSignal *)switch:(RACSignal *)signal cases:(NSDictionary *)cases default:(RACSignal *)defaultSignal;
+
+/// Switches between `trueSignal` and `falseSignal` based on the latest value
+/// sent by `boolSignal`.
+///
+/// boolSignal  - A signal of BOOLs determining whether `trueSignal` or
+///               `falseSignal` should be active. This argument must not be nil.
+/// trueSignal  - The signal to pass through after `boolSignal` has sent YES.
+///               This argument must not be nil.
+/// falseSignal - The signal to pass through after `boolSignal` has sent NO. This
+///               argument must not be nil.
+///
+/// Returns a signal which passes through `next`s and `error`s from `trueSignal`
+/// and/or `falseSignal`, and sends `completed` when both `boolSignal` and the
+/// last switched signal complete.
++ (RACSignal *)if:(RACSignal *)boolSignal then:(RACSignal *)trueSignal else:(RACSignal *)falseSignal;
+
+/// Add every `next` to an array. Nils are represented by NSNulls. Note that this
+/// is a blocking call.
+///
+/// **This is not the same as the `ToArray` method in Rx.** See -collect for
+/// that behavior instead.
+///
+/// Returns the array of `next` values, or nil if an error occurs.
+- (NSArray *)toArray;
+
+/// Add every `next` to a sequence. Nils are represented by NSNulls.
+///
+/// This corresponds to the `ToEnumerable` method in Rx.
+///
+/// Returns a sequence which provides values from the signal as they're sent.
+/// Trying to retrieve a value from the sequence which has not yet been sent will
+/// block.
+@property (nonatomic, strong, readonly) RACSequence *sequence;
+
+/// Creates and returns a multicast connection. This allows you to share a single
+/// subscription to the underlying signal.
+- (RACMulticastConnection *)publish;
+
+/// Creates and returns a multicast connection that pushes values into the given
+/// subject. This allows you to share a single subscription to the underlying
+/// signal.
+- (RACMulticastConnection *)multicast:(RACSubject *)subject;
+
+/// Multicasts the signal to a RACReplaySubject of unlimited capacity, and
+/// immediately connects to the resulting RACMulticastConnection.
+///
+/// Returns the connected, multicasted signal.
+- (RACSignal *)replay;
+
+/// Multicasts the signal to a RACReplaySubject of capacity 1, and immediately
+/// connects to the resulting RACMulticastConnection.
+///
+/// Returns the connected, multicasted signal.
+- (RACSignal *)replayLast;
+
+/// Multicasts the signal to a RACReplaySubject of unlimited capacity, and
+/// lazily connects to the resulting RACMulticastConnection.
+///
+/// This means the returned signal will subscribe to the multicasted signal only
+/// when the former receives its first subscription.
+///
+/// Returns the lazily connected, multicasted signal.
+- (RACSignal *)replayLazily;
+
+/// Sends an error after `interval` seconds if the source doesn't complete
+/// before then.
+///
+/// The error will be in the RACSignalErrorDomain and have a code of
+/// RACSignalErrorTimedOut.
+///
+/// interval  - The number of seconds after which the signal should error out.
+/// scheduler - The scheduler upon which any timeout error should be sent. This
+///             must not be nil or +[RACScheduler immediateScheduler].
+///
+/// Returns a signal that passes through the receiver's events, until the stream
+/// finishes or times out, at which point an error will be sent on `scheduler`.
+- (RACSignal *)timeout:(NSTimeInterval)interval onScheduler:(RACScheduler *)scheduler;
+
+/// Creates and returns a signal that delivers its events on the given scheduler.
+/// Any side effects of the receiver will still be performed on the original
+/// thread.
+///
+/// This is ideal when the signal already performs its work on the desired
+/// thread, but you want to handle its events elsewhere.
+///
+/// This corresponds to the `ObserveOn` method in Rx.
+- (RACSignal *)deliverOn:(RACScheduler *)scheduler;
+
+/// Creates and returns a signal that executes its side effects and delivers its
+/// events on the given scheduler.
+///
+/// Use of this operator should be avoided whenever possible, because the
+/// receiver's side effects may not be safe to run on another thread. If you just
+/// want to receive the signal's events on `scheduler`, use -deliverOn: instead.
+- (RACSignal *)subscribeOn:(RACScheduler *)scheduler;
+
+/// Groups each received object into a group, as determined by calling `keyBlock`
+/// with that object. The object sent is transformed by calling `transformBlock`
+/// with the object. If `transformBlock` is nil, it sends the original object.
+///
+/// The returned signal is a signal of RACGroupedSignal.
+- (RACSignal *)groupBy:(id<NSCopying> (^)(id object))keyBlock transform:(id (^)(id object))transformBlock;
+
+/// Calls -[RACSignal groupBy:keyBlock transform:nil].
+- (RACSignal *)groupBy:(id<NSCopying> (^)(id object))keyBlock;
+
+/// Sends an [NSNumber numberWithBool:YES] if the receiving signal sends any
+/// objects.
+- (RACSignal *)any;
+
+/// Sends an [NSNumber numberWithBool:YES] if the receiving signal sends any
+/// objects that pass `predicateBlock`.
+///
+/// predicateBlock - cannot be nil.
+- (RACSignal *)any:(BOOL (^)(id object))predicateBlock;
+
+/// Sends an [NSNumber numberWithBool:YES] if all the objects the receiving 
+/// signal sends pass `predicateBlock`.
+///
+/// predicateBlock - cannot be nil.
+- (RACSignal *)all:(BOOL (^)(id object))predicateBlock;
+
+/// Resubscribes to the receiving signal if an error occurs, up until it has
+/// retried the given number of times.
+///
+/// retryCount - if 0, it keeps retrying until it completes.
+- (RACSignal *)retry:(NSInteger)retryCount;
+
+/// Resubscribes to the receiving signal if an error occurs.
+- (RACSignal *)retry;
+
+/// Sends the latest value from the receiver only when `sampler` sends a value.
+/// The returned signal could repeat values if `sampler` fires more often than
+/// the receiver. Values from `sampler` are ignored before the receiver sends
+/// its first value.
+///
+/// sampler - The signal that controls when the latest value from the receiver
+///           is sent. Cannot be nil.
+- (RACSignal *)sample:(RACSignal *)sampler;
+
+/// Ignores all `next`s from the receiver.
+///
+/// Returns a signal which only passes through `error` or `completed` events from
+/// the receiver.
+- (RACSignal *)ignoreValues;
+
+/// Converts each of the receiver's events into a RACEvent object.
+///
+/// Returns a signal which sends the receiver's events as RACEvents, and
+/// completes after the receiver sends `completed` or `error`.
+- (RACSignal *)materialize;
+
+/// Converts each RACEvent in the receiver back into "real" RACSignal events.
+///
+/// Returns a signal which sends `next` for each value RACEvent, `error` for each
+/// error RACEvent, and `completed` for each completed RACEvent.
+- (RACSignal *)dematerialize;
+
+/// Inverts each NSNumber-wrapped BOOL sent by the receiver. It will assert if
+/// the receiver sends anything other than NSNumbers.
+///
+/// Returns a signal of inverted NSNumber-wrapped BOOLs.
+- (RACSignal *)not;
+
+/// Performs a boolean AND on all of the RACTuple of NSNumbers in sent by the receiver.
+///
+/// Asserts if the receiver sends anything other than a RACTuple of one or more NSNumbers.
+///
+/// Returns a signal that applies AND to each NSNumber in the tuple.
+- (RACSignal *)and;
+
+/// Performs a boolean OR on all of the RACTuple of NSNumbers in sent by the receiver.
+///
+/// Asserts if the receiver sends anything other than a RACTuple of one or more NSNumbers.
+/// 
+/// Returns a signal that applies OR to each NSNumber in the tuple.
+- (RACSignal *)or;
+
+@end
+
+@interface RACSignal (OperationsDeprecated)
+
+- (RACSignal *)windowWithStart:(RACSignal *)openSignal close:(RACSignal * (^)(RACSignal *start))closeBlock __attribute__((deprecated("See https://github.com/ReactiveCocoa/ReactiveCocoa/issues/587")));
+- (RACSignal *)buffer:(NSUInteger)bufferCount __attribute__((deprecated("See https://github.com/ReactiveCocoa/ReactiveCocoa/issues/587")));
+- (RACSignal *)let:(RACSignal * (^)(RACSignal *sharedSignal))letBlock __attribute__((deprecated("Use -publish instead")));
++ (RACSignal *)interval:(NSTimeInterval)interval __attribute__((deprecated("Use +interval:onScheduler: instead")));
++ (RACSignal *)interval:(NSTimeInterval)interval withLeeway:(NSTimeInterval)leeway __attribute__((deprecated("Use +interval:onScheduler:withLeeway: instead")));
+- (RACSignal *)bufferWithTime:(NSTimeInterval)interval __attribute__((deprecated("Use -bufferWithTime:onScheduler: instead")));
+- (RACSignal *)timeout:(NSTimeInterval)interval __attribute__((deprecated("Use -timeout:onScheduler: instead")));
+- (RACDisposable *)toProperty:(NSString *)keyPath onObject:(NSObject *)object __attribute__((deprecated("Renamed to -setKeyPath:onObject:")));
+- (RACSignal *)ignoreElements __attribute__((deprecated("Renamed to -ignoreValues")));
+- (RACSignal *)sequenceNext:(RACSignal * (^)(void))block __attribute__((deprecated("Renamed to -then:")));
+- (RACSignal *)aggregateWithStart:(id)start combine:(id (^)(id running, id next))combineBlock __attribute__((deprecated("Renamed to -aggregateWithStart:reduce:")));
+- (RACSignal *)aggregateWithStartFactory:(id (^)(void))startFactory combine:(id (^)(id running, id next))combineBlock __attribute__((deprecated("Renamed to -aggregateWithStartFactory:reduce:")));
+- (RACDisposable *)executeCommand:(RACCommand *)command __attribute__((deprecated("Use -flattenMap: or -subscribeNext: instead")));
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSignal+Operations.m b/ReactiveCocoaFramework/ReactiveCocoa/RACSignal+Operations.m
new file mode 100644
index 0000000..6e36dd6
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSignal+Operations.m
@@ -0,0 +1,1436 @@
+//
+//  RACSignal+Operations.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-09-06.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSignal+Operations.h"
+#import "NSObject+RACDeallocating.h"
+#import "NSObject+RACDescription.h"
+#import "RACCommand.h"
+#import "RACCompoundDisposable.h"
+#import "RACDisposable.h"
+#import "RACEvent.h"
+#import "RACGroupedSignal.h"
+#import "RACMulticastConnection+Private.h"
+#import "RACReplaySubject.h"
+#import "RACScheduler+Private.h"
+#import "RACScheduler.h"
+#import "RACSerialDisposable.h"
+#import "RACSignalSequence.h"
+#import "RACStream+Private.h"
+#import "RACSubject.h"
+#import "RACSubscriber+Private.h"
+#import "RACSubscriber.h"
+#import "RACTuple.h"
+#import "RACUnit.h"
+#import <libkern/OSAtomic.h>
+#import <objc/runtime.h>
+
+NSString * const RACSignalErrorDomain = @"RACSignalErrorDomain";
+
+const NSInteger RACSignalErrorTimedOut = 1;
+const NSInteger RACSignalErrorNoMatchingCase = 2;
+
+// Subscribes to the given signal with the given blocks.
+//
+// If the signal errors or completes, the corresponding block is invoked. If the
+// disposable passed to the block is _not_ disposed, then the signal is
+// subscribed to again.
+static RACDisposable *subscribeForever (RACSignal *signal, void (^next)(id), void (^error)(NSError *, RACDisposable *), void (^completed)(RACDisposable *)) {
+	next = [next copy];
+	error = [error copy];
+	completed = [completed copy];
+
+	RACCompoundDisposable *compoundDisposable = [RACCompoundDisposable compoundDisposable];
+
+	RACSchedulerRecursiveBlock recursiveBlock = ^(void (^recurse)(void)) {
+		RACCompoundDisposable *selfDisposable = [RACCompoundDisposable compoundDisposable];
+		[compoundDisposable addDisposable:selfDisposable];
+
+		__weak RACDisposable *weakSelfDisposable = selfDisposable;
+
+		RACDisposable *subscriptionDisposable = [signal subscribeNext:next error:^(NSError *e) {
+			@autoreleasepool {
+				error(e, compoundDisposable);
+				[compoundDisposable removeDisposable:weakSelfDisposable];
+			}
+
+			recurse();
+		} completed:^{
+			@autoreleasepool {
+				completed(compoundDisposable);
+				[compoundDisposable removeDisposable:weakSelfDisposable];
+			}
+
+			recurse();
+		}];
+
+		[selfDisposable addDisposable:subscriptionDisposable];
+	};
+	
+	// Subscribe once immediately, and then use recursive scheduling for any
+	// further resubscriptions.
+	recursiveBlock(^{
+		RACScheduler *recursiveScheduler = RACScheduler.currentScheduler ?: [RACScheduler scheduler];
+
+		RACDisposable *schedulingDisposable = [recursiveScheduler scheduleRecursiveBlock:recursiveBlock];
+		[compoundDisposable addDisposable:schedulingDisposable];
+	});
+
+	return compoundDisposable;
+}
+
+@implementation RACSignal (Operations)
+
+- (RACSignal *)doNext:(void (^)(id x))block {
+	NSCParameterAssert(block != NULL);
+
+	return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+		return [self subscribeNext:^(id x) {
+			block(x);
+			[subscriber sendNext:x];
+		} error:^(NSError *error) {
+			[subscriber sendError:error];
+		} completed:^{
+			[subscriber sendCompleted];
+		}];
+	}] setNameWithFormat:@"[%@] -doNext:", self.name];
+}
+
+- (RACSignal *)doError:(void (^)(NSError *error))block {
+	NSCParameterAssert(block != NULL);
+	
+	return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+		return [self subscribeNext:^(id x) {
+			[subscriber sendNext:x];
+		} error:^(NSError *error) {
+			block(error);
+			[subscriber sendError:error];
+		} completed:^{
+			[subscriber sendCompleted];
+		}];
+	}] setNameWithFormat:@"[%@] -doError:", self.name];
+}
+
+- (RACSignal *)doCompleted:(void (^)(void))block {
+	NSCParameterAssert(block != NULL);
+	
+	return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+		return [self subscribeNext:^(id x) {
+			[subscriber sendNext:x];
+		} error:^(NSError *error) {
+			[subscriber sendError:error];
+		} completed:^{
+			block();
+			[subscriber sendCompleted];
+		}];
+	}] setNameWithFormat:@"[%@] -doCompleted:", self.name];
+}
+
+- (RACSignal *)throttle:(NSTimeInterval)interval {
+	return [[self throttle:interval valuesPassingTest:^(id _) {
+		return YES;
+	}] setNameWithFormat:@"[%@] -throttle: %f", self.name, (double)interval];
+}
+
+- (RACSignal *)throttle:(NSTimeInterval)interval valuesPassingTest:(BOOL (^)(id next))predicate {
+	NSCParameterAssert(interval >= 0);
+	NSCParameterAssert(predicate != nil);
+
+	return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+		RACCompoundDisposable *compoundDisposable = [RACCompoundDisposable compoundDisposable];
+
+		// We may never use this scheduler, but we need to set it up ahead of
+		// time so that our scheduled blocks are run serially if we do.
+		RACScheduler *scheduler = [RACScheduler scheduler];
+
+		// Information about any currently-buffered `next` event.
+		__block id nextValue = nil;
+		__block BOOL hasNextValue = NO;
+		RACSerialDisposable *nextDisposable = [[RACSerialDisposable alloc] init];
+
+		void (^flushNext)(BOOL send) = ^(BOOL send) {
+			@synchronized (compoundDisposable) {
+				[nextDisposable.disposable dispose];
+
+				if (!hasNextValue) return;
+				if (send) [subscriber sendNext:nextValue];
+
+				nextValue = nil;
+				hasNextValue = NO;
+			}
+		};
+
+		RACDisposable *subscriptionDisposable = [self subscribeNext:^(id x) {
+			RACScheduler *delayScheduler = RACScheduler.currentScheduler ?: scheduler;
+			BOOL shouldThrottle = predicate(x);
+
+			@synchronized (compoundDisposable) {
+				flushNext(NO);
+				if (!shouldThrottle) {
+					[subscriber sendNext:x];
+					return;
+				}
+
+				nextValue = x;
+				hasNextValue = YES;
+				nextDisposable.disposable = [delayScheduler afterDelay:interval schedule:^{
+					flushNext(YES);
+				}];
+			}
+		} error:^(NSError *error) {
+			[compoundDisposable dispose];
+			[subscriber sendError:error];
+		} completed:^{
+			flushNext(YES);
+			[subscriber sendCompleted];
+		}];
+
+		[compoundDisposable addDisposable:subscriptionDisposable];
+		return compoundDisposable;
+	}] setNameWithFormat:@"[%@] -throttle: %f valuesPassingTest:", self.name, (double)interval];
+}
+
+- (RACSignal *)delay:(NSTimeInterval)interval {
+	return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+		RACCompoundDisposable *disposable = [RACCompoundDisposable compoundDisposable];
+
+		// We may never use this scheduler, but we need to set it up ahead of
+		// time so that our scheduled blocks are run serially if we do.
+		RACScheduler *scheduler = [RACScheduler scheduler];
+
+		void (^schedule)(dispatch_block_t) = ^(dispatch_block_t block) {
+			RACScheduler *delayScheduler = RACScheduler.currentScheduler ?: scheduler;
+			RACDisposable *schedulerDisposable = [delayScheduler afterDelay:interval schedule:block];
+			[disposable addDisposable:schedulerDisposable];
+		};
+
+		RACDisposable *subscriptionDisposable = [self subscribeNext:^(id x) {
+			schedule(^{
+				[subscriber sendNext:x];
+			});
+		} error:^(NSError *error) {
+			[subscriber sendError:error];
+		} completed:^{
+			schedule(^{
+				[subscriber sendCompleted];
+			});
+		}];
+
+		[disposable addDisposable:subscriptionDisposable];
+		return disposable;
+	}] setNameWithFormat:@"[%@] -delay: %f", self.name, (double)interval];
+}
+
+- (RACSignal *)repeat {
+	return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+		return subscribeForever(self,
+			^(id x) {
+				[subscriber sendNext:x];
+			},
+			^(NSError *error, RACDisposable *disposable) {
+				[disposable dispose];
+				[subscriber sendError:error];
+			},
+			^(RACDisposable *disposable) {
+				// Resubscribe.
+			});
+	}] setNameWithFormat:@"[%@] -repeat", self.name];
+}
+
+- (RACSignal *)catch:(RACSignal * (^)(NSError *error))catchBlock {
+	NSCParameterAssert(catchBlock != NULL);
+
+	return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+		RACSerialDisposable *catchDisposable = [[RACSerialDisposable alloc] init];
+
+		RACDisposable *subscriptionDisposable = [self subscribeNext:^(id x) {
+			[subscriber sendNext:x];
+		} error:^(NSError *error) {
+			RACSignal *signal = catchBlock(error);
+			NSCAssert(signal != nil, @"Expected non-nil signal from catch block on %@", self);
+			catchDisposable.disposable = [signal subscribe:subscriber];
+		} completed:^{
+			[subscriber sendCompleted];
+		}];
+
+		return [RACDisposable disposableWithBlock:^{
+			[catchDisposable dispose];
+			[subscriptionDisposable dispose];
+		}];
+	}] setNameWithFormat:@"[%@] -catch:", self.name];
+}
+
+- (RACSignal *)catchTo:(RACSignal *)signal {
+	return [[self catch:^(NSError *error) {
+		return signal;
+	}] setNameWithFormat:@"[%@] -catchTo: %@", self.name, signal];
+}
+
+- (RACSignal *)try:(BOOL (^)(id value, NSError **errorPtr))tryBlock {
+	NSCParameterAssert(tryBlock != NULL);
+	
+	return [[self flattenMap:^(id value) {
+		NSError *error = nil;
+		BOOL passed = tryBlock(value, &error);
+		return (passed ? [RACSignal return:value] : [RACSignal error:error]);
+	}] setNameWithFormat:@"[%@] -try:", self.name];
+}
+
+- (RACSignal *)tryMap:(id (^)(id value, NSError **errorPtr))mapBlock {
+	NSCParameterAssert(mapBlock != NULL);
+	
+	return [[self flattenMap:^(id value) {
+		NSError *error = nil;
+		id mappedValue = mapBlock(value, &error);
+		return (mappedValue == nil ? [RACSignal error:error] : [RACSignal return:mappedValue]);
+	}] setNameWithFormat:@"[%@] -tryMap:", self.name];
+}
+
+- (RACSignal *)initially:(void (^)(void))block {
+	NSCParameterAssert(block != NULL);
+
+	return [[RACSignal defer:^{
+		block();
+		return self;
+	}] setNameWithFormat:@"[%@] -initially:", self.name];
+}
+
+- (RACSignal *)finally:(void (^)(void))block {
+	NSCParameterAssert(block != NULL);
+	
+	return [[[self
+		doError:^(NSError *error) {
+			block();
+		}]
+		doCompleted:^{
+			block();
+		}]
+		setNameWithFormat:@"[%@] -finally:", self.name];
+}
+
+- (RACSignal *)bufferWithTime:(NSTimeInterval)interval onScheduler:(RACScheduler *)scheduler {
+	NSCParameterAssert(scheduler != nil);
+	NSCParameterAssert(scheduler != RACScheduler.immediateScheduler);
+
+	return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+		RACSerialDisposable *timerDisposable = [[RACSerialDisposable alloc] init];
+		NSMutableArray *values = [NSMutableArray array];
+
+		void (^flushValues)() = ^{
+			@synchronized (values) {
+				[timerDisposable.disposable dispose];
+
+				if (values.count == 0) return;
+
+				RACTuple *tuple = [RACTuple tupleWithObjectsFromArray:values convertNullsToNils:NO];
+				[values removeAllObjects];
+				[subscriber sendNext:tuple];
+			}
+		};
+
+		RACDisposable *selfDisposable = [self subscribeNext:^(id x) {
+			@synchronized (values) {
+				if (values.count == 0) {
+					timerDisposable.disposable = [scheduler afterDelay:interval schedule:flushValues];
+				}
+
+				[values addObject:x ?: RACTupleNil.tupleNil];
+			}
+		} error:^(NSError *error) {
+			[subscriber sendError:error];
+		} completed:^{
+			flushValues();
+			[subscriber sendCompleted];
+		}];
+
+		return [RACDisposable disposableWithBlock:^{
+			[selfDisposable dispose];
+			[timerDisposable dispose];
+		}];
+	}] setNameWithFormat:@"[%@] -bufferWithTime: %f", self.name, (double)interval];
+}
+
+- (RACSignal *)collect {
+	return [[self aggregateWithStartFactory:^{
+		return [[NSMutableArray alloc] init];
+	} reduce:^(NSMutableArray *collectedValues, id x) {
+		[collectedValues addObject:(x ?: NSNull.null)];
+		return collectedValues;
+	}] setNameWithFormat:@"[%@] -collect", self.name];
+}
+
+- (RACSignal *)takeLast:(NSUInteger)count {
+	return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {		
+		NSMutableArray *valuesTaken = [NSMutableArray arrayWithCapacity:count];
+		return [self subscribeNext:^(id x) {
+			[valuesTaken addObject:x ? : [RACTupleNil tupleNil]];
+			
+			while(valuesTaken.count > count) {
+				[valuesTaken removeObjectAtIndex:0];
+			}
+		} error:^(NSError *error) {
+			[subscriber sendError:error];
+		} completed:^{
+			for(id value in valuesTaken) {
+				[subscriber sendNext:[value isKindOfClass:[RACTupleNil class]] ? nil : value];
+			}
+			
+			[subscriber sendCompleted];
+		}];
+	}] setNameWithFormat:@"[%@] -takeLast: %lu", self.name, (unsigned long)count];
+}
+
+- (RACSignal *)combineLatestWith:(RACSignal *)signal {
+	NSCParameterAssert(signal != nil);
+
+	return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+		RACCompoundDisposable *disposable = [RACCompoundDisposable compoundDisposable];
+
+		__block id lastSelfValue = nil;
+		__block BOOL selfCompleted = NO;
+
+		__block id lastOtherValue = nil;
+		__block BOOL otherCompleted = NO;
+
+		void (^sendNext)(void) = ^{
+			@synchronized (disposable) {
+				if (lastSelfValue == nil || lastOtherValue == nil) return;
+				[subscriber sendNext:[RACTuple tupleWithObjects:lastSelfValue, lastOtherValue, nil]];
+			}
+		};
+
+		RACDisposable *selfDisposable = [self subscribeNext:^(id x) {
+			@synchronized (disposable) {
+				lastSelfValue = x ?: RACTupleNil.tupleNil;
+				sendNext();
+			}
+		} error:^(NSError *error) {
+			[subscriber sendError:error];
+		} completed:^{
+			@synchronized (disposable) {
+				selfCompleted = YES;
+				if (otherCompleted) [subscriber sendCompleted];
+			}
+		}];
+
+		[disposable addDisposable:selfDisposable];
+
+		RACDisposable *otherDisposable = [signal subscribeNext:^(id x) {
+			@synchronized (disposable) {
+				lastOtherValue = x ?: RACTupleNil.tupleNil;
+				sendNext();
+			}
+		} error:^(NSError *error) {
+			[subscriber sendError:error];
+		} completed:^{
+			@synchronized (disposable) {
+				otherCompleted = YES;
+				if (selfCompleted) [subscriber sendCompleted];
+			}
+		}];
+
+		[disposable addDisposable:otherDisposable];
+
+		return disposable;
+	}] setNameWithFormat:@"[%@] -combineLatestWith: %@", self.name, signal];
+}
+
++ (RACSignal *)combineLatest:(id<NSFastEnumeration>)signals {
+	return [[self join:signals block:^(RACSignal *left, RACSignal *right) {
+		return [left combineLatestWith:right];
+	}] setNameWithFormat:@"+combineLatest: %@", signals];
+}
+
++ (RACSignal *)combineLatest:(id<NSFastEnumeration>)signals reduce:(id (^)())reduceBlock {
+	NSCParameterAssert(reduceBlock != nil);
+
+	RACSignal *result = [self combineLatest:signals];
+
+	// Although we assert this condition above, older versions of this method
+	// supported this argument being nil. Avoid crashing Release builds of
+	// apps that depended on that.
+	if (reduceBlock != nil) result = [result reduceEach:reduceBlock];
+
+	return [result setNameWithFormat:@"+combineLatest: %@ reduce:", signals];
+}
+
+- (RACSignal *)merge:(RACSignal *)signal {
+	return [[RACSignal
+		merge:@[ self, signal ]]
+		setNameWithFormat:@"[%@] -merge: %@", self.name, signal];
+}
+
++ (RACSignal *)merge:(id<NSFastEnumeration>)signals {
+	NSMutableArray *copiedSignals = [[NSMutableArray alloc] init];
+	for (RACSignal *signal in signals) {
+		[copiedSignals addObject:signal];
+	}
+
+	return [[[RACSignal
+		createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) {
+			for (RACSignal *signal in copiedSignals) {
+				[subscriber sendNext:signal];
+			}
+
+			[subscriber sendCompleted];
+			return nil;
+		}]
+		flatten]
+		setNameWithFormat:@"+merge: %@", copiedSignals];
+}
+
+- (RACSignal *)flatten:(NSUInteger)maxConcurrent {
+	return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+		RACCompoundDisposable *compoundDisposable = [[RACCompoundDisposable alloc] init];
+
+		// Contains disposables for the currently active subscriptions.
+		//
+		// This should only be used while synchronized on `subscriber`.
+		NSMutableArray *activeDisposables = [[NSMutableArray alloc] initWithCapacity:maxConcurrent];
+
+		// Whether the signal-of-signals has completed yet.
+		//
+		// This should only be used while synchronized on `subscriber`.
+		__block BOOL selfCompleted = NO;
+
+		// Subscribes to the given signal.
+		//
+		// This will be set to nil once all signals have completed (to break
+		// a retain cycle in the recursive block).
+		__block void (^subscribeToSignal)(RACSignal *);
+
+		// Sends completed to the subscriber if all signals are finished.
+		//
+		// This should only be used while synchronized on `subscriber`.
+		void (^completeIfAllowed)(void) = ^{
+			if (selfCompleted && activeDisposables.count == 0) {
+				[subscriber sendCompleted];
+				subscribeToSignal = nil;
+			}
+		};
+
+		// The signals waiting to be started.
+		//
+		// This array should only be used while synchronized on `subscriber`.
+		NSMutableArray *queuedSignals = [NSMutableArray array];
+
+		subscribeToSignal = ^(RACSignal *signal) {
+			RACSerialDisposable *serialDisposable = [[RACSerialDisposable alloc] init];
+
+			@synchronized (subscriber) {
+				[compoundDisposable addDisposable:serialDisposable];
+				[activeDisposables addObject:serialDisposable];
+			}
+
+			serialDisposable.disposable = [signal subscribeNext:^(id x) {
+				[subscriber sendNext:x];
+			} error:^(NSError *error) {
+				[subscriber sendError:error];
+			} completed:^{
+				RACSignal *nextSignal;
+
+				@synchronized (subscriber) {
+					[compoundDisposable removeDisposable:serialDisposable];
+					[activeDisposables removeObjectIdenticalTo:serialDisposable];
+
+					if (queuedSignals.count == 0) {
+						completeIfAllowed();
+						return;
+					}
+
+					nextSignal = queuedSignals[0];
+					[queuedSignals removeObjectAtIndex:0];
+				}
+
+				#pragma clang diagnostic push
+				#pragma clang diagnostic ignored "-Warc-retain-cycles"
+				// This retain cycle is broken in `completeIfAllowed`.
+				subscribeToSignal(nextSignal);
+				#pragma clang diagnostic pop
+			}];
+		};
+
+		[compoundDisposable addDisposable:[self subscribeNext:^(RACSignal *signal) {
+			if (signal == nil) return;
+
+			NSCAssert([signal isKindOfClass:RACSignal.class], @"Expected a RACSignal, got %@", signal);
+
+			@synchronized (subscriber) {
+				if (maxConcurrent > 0 && activeDisposables.count >= maxConcurrent) {
+					[queuedSignals addObject:signal];
+
+					// If we need to wait, skip subscribing to this
+					// signal.
+					return;
+				}
+			}
+
+			subscribeToSignal(signal);
+		} error:^(NSError *error) {
+			[subscriber sendError:error];
+		} completed:^{
+			@synchronized (subscriber) {
+				selfCompleted = YES;
+				completeIfAllowed();
+			}
+		}]];
+
+		return compoundDisposable;
+	}] setNameWithFormat:@"[%@] -flatten: %lu", self.name, (unsigned long)maxConcurrent];
+}
+
+- (RACSignal *)then:(RACSignal * (^)(void))block {
+	NSCParameterAssert(block != nil);
+
+	return [[[self
+		ignoreValues]
+		concat:[RACSignal defer:block]]
+		setNameWithFormat:@"[%@] -then:", self.name];
+}
+
+- (RACSignal *)concat {
+	return [[self flatten:1] setNameWithFormat:@"[%@] -concat", self.name];
+}
+
+- (RACSignal *)aggregateWithStartFactory:(id (^)(void))startFactory reduce:(id (^)(id running, id next))reduceBlock {
+	NSCParameterAssert(startFactory != NULL);
+	NSCParameterAssert(reduceBlock != NULL);
+	
+	return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+		__block id runningValue = startFactory();
+		return [self subscribeNext:^(id x) {
+			runningValue = reduceBlock(runningValue, x);
+		} error:^(NSError *error) {
+			[subscriber sendError:error];
+		} completed:^{
+			[subscriber sendNext:runningValue];
+			[subscriber sendCompleted];
+		}];
+	}] setNameWithFormat:@"[%@] -aggregateWithStartFactory:reduce:", self.name];
+}
+
+- (RACSignal *)aggregateWithStart:(id)start reduce:(id (^)(id running, id next))reduceBlock {
+	RACSignal *signal = [self aggregateWithStartFactory:^{
+		return start;
+	} reduce:reduceBlock];
+
+	return [signal setNameWithFormat:@"[%@] -aggregateWithStart: %@ reduce:", self.name, [start rac_description]];
+}
+
+- (RACDisposable *)setKeyPath:(NSString *)keyPath onObject:(NSObject *)object {
+	return [self setKeyPath:keyPath onObject:object nilValue:nil];
+}
+
+- (RACDisposable *)setKeyPath:(NSString *)keyPath onObject:(NSObject *)object nilValue:(id)nilValue {
+	NSCParameterAssert(keyPath != nil);
+	NSCParameterAssert(object != nil);
+
+	keyPath = [keyPath copy];
+
+	RACCompoundDisposable *disposable = [RACCompoundDisposable compoundDisposable];
+
+	// Purposely not retaining 'object', since we want to tear down the binding
+	// when it deallocates normally.
+	__block void * volatile objectPtr = (__bridge void *)object;
+
+	RACDisposable *subscriptionDisposable = [self subscribeNext:^(id x) {
+		// Possibly spec, possibly compiler bug, but this __bridge cast does not
+		// result in a retain here, effectively an invisible __unsafe_unretained
+		// qualifier. Using objc_precise_lifetime gives the __strong reference
+		// desired. The explicit use of __strong is strictly defensive.
+		__strong NSObject *object __attribute__((objc_precise_lifetime)) = (__bridge __strong id)objectPtr;
+		[object setValue:x ?: nilValue forKeyPath:keyPath];
+	} error:^(NSError *error) {
+		__strong NSObject *object __attribute__((objc_precise_lifetime)) = (__bridge __strong id)objectPtr;
+
+		NSCAssert(NO, @"Received error from %@ in binding for key path \"%@\" on %@: %@", self, keyPath, object, error);
+
+		// Log the error if we're running with assertions disabled.
+		NSLog(@"Received error from %@ in binding for key path \"%@\" on %@: %@", self, keyPath, object, error);
+
+		[disposable dispose];
+	} completed:^{
+		[disposable dispose];
+	}];
+
+	[disposable addDisposable:subscriptionDisposable];
+
+	#if DEBUG
+	static void *bindingsKey = &bindingsKey;
+	NSMutableDictionary *bindings;
+
+	@synchronized (object) {
+		bindings = objc_getAssociatedObject(object, bindingsKey);
+		if (bindings == nil) {
+			bindings = [NSMutableDictionary dictionary];
+			objc_setAssociatedObject(object, bindingsKey, bindings, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+		}
+	}
+
+	@synchronized (bindings) {
+		NSCAssert(bindings[keyPath] == nil, @"Signal %@ is already bound to key path \"%@\" on object %@, adding signal %@ is undefined behavior", [bindings[keyPath] nonretainedObjectValue], keyPath, object, self);
+
+		bindings[keyPath] = [NSValue valueWithNonretainedObject:self];
+	}
+	#endif
+
+	RACDisposable *clearPointerDisposable = [RACDisposable disposableWithBlock:^{
+		#if DEBUG
+		@synchronized (bindings) {
+			[bindings removeObjectForKey:keyPath];
+		}
+		#endif
+
+		while (YES) {
+			void *ptr = objectPtr;
+			if (OSAtomicCompareAndSwapPtrBarrier(ptr, NULL, &objectPtr)) {
+				break;
+			}
+		}
+	}];
+
+	[disposable addDisposable:clearPointerDisposable];
+
+	[object.rac_deallocDisposable addDisposable:disposable];
+	
+	RACCompoundDisposable *objectDisposable = object.rac_deallocDisposable;
+	return [RACDisposable disposableWithBlock:^{
+		[objectDisposable removeDisposable:disposable];
+		[disposable dispose];
+	}];
+}
+
++ (RACSignal *)interval:(NSTimeInterval)interval onScheduler:(RACScheduler *)scheduler {
+	return [[RACSignal interval:interval onScheduler:scheduler withLeeway:0.0] setNameWithFormat:@"+interval: %f onScheduler: %@", (double)interval, scheduler];
+}
+
++ (RACSignal *)interval:(NSTimeInterval)interval onScheduler:(RACScheduler *)scheduler withLeeway:(NSTimeInterval)leeway {
+	NSCParameterAssert(scheduler != nil);
+	NSCParameterAssert(scheduler != RACScheduler.immediateScheduler);
+
+	return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+		return [scheduler after:[NSDate dateWithTimeIntervalSinceNow:interval] repeatingEvery:interval withLeeway:leeway schedule:^{
+			[subscriber sendNext:[NSDate date]];
+		}];
+	}] setNameWithFormat:@"+interval: %f onScheduler: %@ withLeeway: %f", (double)interval, scheduler, (double)leeway];
+}
+
+- (RACSignal *)takeUntil:(RACSignal *)signalTrigger {
+	return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+		RACCompoundDisposable *disposable = [RACCompoundDisposable compoundDisposable];
+		void (^triggerCompletion)(void) = ^{
+			[disposable dispose];
+			[subscriber sendCompleted];
+		};
+
+		RACDisposable *triggerDisposable = [signalTrigger subscribeNext:^(id _) {
+			triggerCompletion();
+		} completed:^{
+			triggerCompletion();
+		}];
+
+		[disposable addDisposable:triggerDisposable];
+
+		if (!disposable.disposed) {
+			RACDisposable *selfDisposable = [self subscribeNext:^(id x) {
+				[subscriber sendNext:x];
+			} error:^(NSError *error) {
+				[subscriber sendError:error];
+			} completed:^{
+				[disposable dispose];
+				[subscriber sendCompleted];
+			}];
+
+			[disposable addDisposable:selfDisposable];
+		}
+
+		return disposable;
+	}] setNameWithFormat:@"[%@] -takeUntil: %@", self.name, signalTrigger];
+}
+
+- (RACSignal *)takeUntilReplacement:(RACSignal *)replacement {
+	return [RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+		RACSerialDisposable *selfDisposable = [[RACSerialDisposable alloc] init];
+
+		RACDisposable *replacementDisposable = [replacement subscribeNext:^(id x) {
+			[selfDisposable dispose];
+			[subscriber sendNext:x];
+		} error:^(NSError *error) {
+			[selfDisposable dispose];
+			[subscriber sendError:error];
+		} completed:^{
+			[selfDisposable dispose];
+			[subscriber sendCompleted];
+		}];
+
+		if (!selfDisposable.disposed) {
+			selfDisposable.disposable = [[self
+				concat:[RACSignal never]]
+				subscribe:subscriber];
+		}
+
+		return [RACDisposable disposableWithBlock:^{
+			[selfDisposable dispose];
+			[replacementDisposable dispose];
+		}];
+	}];
+}
+
+- (RACSignal *)switchToLatest {
+	return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+		RACMulticastConnection *connection = [self publish];
+
+		RACDisposable *subscriptionDisposable = [[connection.signal
+			flattenMap:^(RACSignal *x) {
+				NSCAssert(x == nil || [x isKindOfClass:RACSignal.class], @"-switchToLatest requires that the source signal (%@) send signals. Instead we got: %@", self, x);
+
+				// -concat:[RACSignal never] prevents completion of the receiver from
+				// prematurely terminating the inner signal.
+				return [x takeUntil:[connection.signal concat:[RACSignal never]]];
+			}]
+			subscribe:subscriber];
+
+		RACDisposable *connectionDisposable = [connection connect];
+		return [RACDisposable disposableWithBlock:^{
+			[subscriptionDisposable dispose];
+			[connectionDisposable dispose];
+		}];
+	}] setNameWithFormat:@"[%@] -switchToLatest", self.name];
+}
+
++ (RACSignal *)switch:(RACSignal *)signal cases:(NSDictionary *)cases default:(RACSignal *)defaultSignal {
+	NSCParameterAssert(signal != nil);
+	NSCParameterAssert(cases != nil);
+
+	for (id key in cases) {
+		id value __attribute__((unused)) = cases[key];
+		NSCAssert([value isKindOfClass:RACSignal.class], @"Expected all cases to be RACSignals, %@ isn't", value);
+	}
+
+	NSDictionary *copy = [cases copy];
+
+	return [[[signal
+		map:^(id key) {
+			if (key == nil) key = RACTupleNil.tupleNil;
+
+			RACSignal *signal = copy[key] ?: defaultSignal;
+			if (signal == nil) {
+				NSString *description = [NSString stringWithFormat:NSLocalizedString(@"No matching signal found for value %@", @""), key];
+				return [RACSignal error:[NSError errorWithDomain:RACSignalErrorDomain code:RACSignalErrorNoMatchingCase userInfo:@{ NSLocalizedDescriptionKey: description }]];
+			}
+
+			return signal;
+		}]
+		switchToLatest]
+		setNameWithFormat:@"+switch: %@ cases: %@ default: %@", signal, cases, defaultSignal];
+}
+
++ (RACSignal *)if:(RACSignal *)boolSignal then:(RACSignal *)trueSignal else:(RACSignal *)falseSignal {
+	NSCParameterAssert(boolSignal != nil);
+	NSCParameterAssert(trueSignal != nil);
+	NSCParameterAssert(falseSignal != nil);
+
+	return [[[boolSignal
+		map:^(NSNumber *value) {
+			NSCAssert([value isKindOfClass:NSNumber.class], @"Expected %@ to send BOOLs, not %@", boolSignal, value);
+			
+			return (value.boolValue ? trueSignal : falseSignal);
+		}]
+		switchToLatest]
+		setNameWithFormat:@"+if: %@ then: %@ else: %@", boolSignal, trueSignal, falseSignal];
+}
+
+- (id)first {
+	return [self firstOrDefault:nil];
+}
+
+- (id)firstOrDefault:(id)defaultValue {
+	return [self firstOrDefault:defaultValue success:NULL error:NULL];
+}
+
+- (id)firstOrDefault:(id)defaultValue success:(BOOL *)success error:(NSError **)error {
+	NSCondition *condition = [[NSCondition alloc] init];
+	condition.name = [NSString stringWithFormat:@"[%@] -firstOrDefault: %@ success:error:", self.name, defaultValue];
+
+	__block id value = defaultValue;
+	__block BOOL done = NO;
+
+	// Ensures that we don't pass values across thread boundaries by reference.
+	__block NSError *localError;
+	__block BOOL localSuccess;
+
+	[[self take:1] subscribeNext:^(id x) {
+		[condition lock];
+
+		value = x;
+		localSuccess = YES;
+		
+		done = YES;
+		[condition broadcast];
+		[condition unlock];
+	} error:^(NSError *e) {
+		[condition lock];
+
+		if (!done) {
+			localSuccess = NO;
+			localError = e;
+
+			done = YES;
+			[condition broadcast];
+		}
+
+		[condition unlock];
+	} completed:^{
+		[condition lock];
+
+		localSuccess = YES;
+
+		done = YES;
+		[condition broadcast];
+		[condition unlock];
+	}];
+
+	[condition lock];
+	while (!done) {
+		[condition wait];
+	}
+
+	if (success != NULL) *success = localSuccess;
+	if (error != NULL) *error = localError;
+
+	[condition unlock];
+	return value;
+}
+
+- (BOOL)waitUntilCompleted:(NSError **)error {
+	BOOL success = NO;
+
+	[[[self
+		ignoreValues]
+		setNameWithFormat:@"[%@] -waitUntilCompleted:", self.name]
+		firstOrDefault:nil success:&success error:error];
+	
+	return success;
+}
+
++ (RACSignal *)defer:(RACSignal * (^)(void))block {
+	NSCParameterAssert(block != NULL);
+	
+	return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+		return [block() subscribe:subscriber];
+	}] setNameWithFormat:@"+defer:"];
+}
+
+- (NSArray *)toArray {
+	return [[[self collect] first] copy];
+}
+
+- (RACSequence *)sequence {
+	return [[RACSignalSequence sequenceWithSignal:self] setNameWithFormat:@"[%@] -sequence", self.name];
+}
+
+- (RACMulticastConnection *)publish {
+	RACSubject *subject = [[RACSubject subject] setNameWithFormat:@"[%@] -publish", self.name];
+	RACMulticastConnection *connection = [self multicast:subject];
+	return connection;
+}
+
+- (RACMulticastConnection *)multicast:(RACSubject *)subject {
+	[subject setNameWithFormat:@"[%@] -multicast: %@", self.name, subject.name];
+	RACMulticastConnection *connection = [[RACMulticastConnection alloc] initWithSourceSignal:self subject:subject];
+	return connection;
+}
+
+- (RACSignal *)replay {
+	RACReplaySubject *subject = [[RACReplaySubject subject] setNameWithFormat:@"[%@] -replay", self.name];
+
+	RACMulticastConnection *connection = [self multicast:subject];
+	[connection connect];
+
+	return connection.signal;
+}
+
+- (RACSignal *)replayLast {
+	RACReplaySubject *subject = [[RACReplaySubject replaySubjectWithCapacity:1] setNameWithFormat:@"[%@] -replayLast", self.name];
+
+	RACMulticastConnection *connection = [self multicast:subject];
+	[connection connect];
+
+	return connection.signal;
+}
+
+- (RACSignal *)replayLazily {
+	RACMulticastConnection *connection = [self multicast:[RACReplaySubject subject]];
+	return [[RACSignal
+		defer:^{
+			[connection connect];
+			return connection.signal;
+		}]
+		setNameWithFormat:@"[%@] -replayLazily", self.name];
+}
+
+- (RACSignal *)timeout:(NSTimeInterval)interval onScheduler:(RACScheduler *)scheduler {
+	NSCParameterAssert(scheduler != nil);
+	NSCParameterAssert(scheduler != RACScheduler.immediateScheduler);
+
+	return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+		RACCompoundDisposable *disposable = [RACCompoundDisposable compoundDisposable];
+
+		RACDisposable *timeoutDisposable = [scheduler afterDelay:interval schedule:^{
+			[disposable dispose];
+			[subscriber sendError:[NSError errorWithDomain:RACSignalErrorDomain code:RACSignalErrorTimedOut userInfo:nil]];
+		}];
+
+		[disposable addDisposable:timeoutDisposable];
+
+		RACDisposable *subscriptionDisposable = [self subscribeNext:^(id x) {
+			[subscriber sendNext:x];
+		} error:^(NSError *error) {
+			[disposable dispose];
+			[subscriber sendError:error];
+		} completed:^{
+			[disposable dispose];
+			[subscriber sendCompleted];
+		}];
+
+		[disposable addDisposable:subscriptionDisposable];
+		return disposable;
+	}] setNameWithFormat:@"[%@] -timeout: %f", self.name, (double)interval];
+}
+
+- (RACSignal *)deliverOn:(RACScheduler *)scheduler {
+	return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+		return [self subscribeNext:^(id x) {
+			[scheduler schedule:^{
+				[subscriber sendNext:x];
+			}];
+		} error:^(NSError *error) {
+			[scheduler schedule:^{
+				[subscriber sendError:error];
+			}];
+		} completed:^{
+			[scheduler schedule:^{
+				[subscriber sendCompleted];
+			}];
+		}];
+	}] setNameWithFormat:@"[%@] -deliverOn: %@", self.name, scheduler];
+}
+
+- (RACSignal *)subscribeOn:(RACScheduler *)scheduler {
+	return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+		RACCompoundDisposable *disposable = [RACCompoundDisposable compoundDisposable];
+
+		RACDisposable *schedulingDisposable = [scheduler schedule:^{
+			RACDisposable *subscriptionDisposable = [self subscribeNext:^(id x) {
+				[subscriber sendNext:x];
+			} error:^(NSError *error) {
+				[subscriber sendError:error];
+			} completed:^{
+				[subscriber sendCompleted];
+			}];
+
+			[disposable addDisposable:subscriptionDisposable];
+		}];
+		
+		[disposable addDisposable:schedulingDisposable];
+		return disposable;
+	}] setNameWithFormat:@"[%@] -subscribeOn: %@", self.name, scheduler];
+}
+
+- (RACSignal *)groupBy:(id<NSCopying> (^)(id object))keyBlock transform:(id (^)(id object))transformBlock {
+	NSCParameterAssert(keyBlock != NULL);
+
+	return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+		NSMutableDictionary *groups = [NSMutableDictionary dictionary];
+
+		return [self subscribeNext:^(id x) {
+			id<NSCopying> key = keyBlock(x);
+			RACGroupedSignal *groupSubject = nil;
+			@synchronized(groups) {
+				groupSubject = [groups objectForKey:key];
+				if(groupSubject == nil) {
+					groupSubject = [RACGroupedSignal signalWithKey:key];
+					[groups setObject:groupSubject forKey:key];
+					[subscriber sendNext:groupSubject];
+				}
+			}
+
+			[groupSubject sendNext:transformBlock != NULL ? transformBlock(x) : x];
+		} error:^(NSError *error) {
+			[subscriber sendError:error];
+
+			[groups.allValues makeObjectsPerformSelector:@selector(sendError:) withObject:error];
+		} completed:^{
+			[subscriber sendCompleted];
+
+			[groups.allValues makeObjectsPerformSelector:@selector(sendCompleted)];
+		}];
+	}] setNameWithFormat:@"[%@] -groupBy:transform:", self.name];
+}
+
+- (RACSignal *)groupBy:(id<NSCopying> (^)(id object))keyBlock {
+	return [[self groupBy:keyBlock transform:nil] setNameWithFormat:@"[%@] -groupBy:", self.name];
+}
+
+- (RACSignal *)any {	
+	return [[self any:^(id x) {
+		return YES;
+	}] setNameWithFormat:@"[%@] -any", self.name];
+}
+
+- (RACSignal *)any:(BOOL (^)(id object))predicateBlock {
+	NSCParameterAssert(predicateBlock != NULL);
+	
+	return [[[self materialize] bind:^{
+		return ^(RACEvent *event, BOOL *stop) {
+			if (event.finished) {
+				*stop = YES;
+				return [RACSignal return:@NO];
+			}
+			
+			if (predicateBlock(event.value)) {
+				*stop = YES;
+				return [RACSignal return:@YES];
+			}
+
+			return [RACSignal empty];
+		};
+	}] setNameWithFormat:@"[%@] -any:", self.name];
+}
+
+- (RACSignal *)all:(BOOL (^)(id object))predicateBlock {
+	NSCParameterAssert(predicateBlock != NULL);
+	
+	return [[[self materialize] bind:^{
+		return ^(RACEvent *event, BOOL *stop) {
+			if (event.eventType == RACEventTypeCompleted) {
+				*stop = YES;
+				return [RACSignal return:@YES];
+			}
+			
+			if (event.eventType == RACEventTypeError || !predicateBlock(event.value)) {
+				*stop = YES;
+				return [RACSignal return:@NO];
+			}
+
+			return [RACSignal empty];
+		};
+	}] setNameWithFormat:@"[%@] -all:", self.name];
+}
+
+- (RACSignal *)retry:(NSInteger)retryCount {
+	return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+		__block NSInteger currentRetryCount = 0;
+		return subscribeForever(self,
+			^(id x) {
+				[subscriber sendNext:x];
+			},
+			^(NSError *error, RACDisposable *disposable) {
+				if (retryCount == 0 || currentRetryCount < retryCount) {
+					// Resubscribe.
+					currentRetryCount++;
+					return;
+				}
+
+				[disposable dispose];
+				[subscriber sendError:error];
+			},
+			^(RACDisposable *disposable) {
+				[disposable dispose];
+				[subscriber sendCompleted];
+			});
+	}] setNameWithFormat:@"[%@] -retry: %lu", self.name, (unsigned long)retryCount];
+}
+
+- (RACSignal *)retry {
+	return [[self retry:0] setNameWithFormat:@"[%@] -retry", self.name];
+}
+
+- (RACSignal *)sample:(RACSignal *)sampler {
+	NSCParameterAssert(sampler != nil);
+
+	return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+		NSLock *lock = [[NSLock alloc] init];
+		__block id lastValue;
+		__block BOOL hasValue = NO;
+
+		RACSerialDisposable *samplerDisposable = [[RACSerialDisposable alloc] init];
+		RACDisposable *sourceDisposable = [self subscribeNext:^(id x) {
+			[lock lock];
+			hasValue = YES;
+			lastValue = x;
+			[lock unlock];
+		} error:^(NSError *error) {
+			[samplerDisposable dispose];
+			[subscriber sendError:error];
+		} completed:^{
+			[samplerDisposable dispose];
+			[subscriber sendCompleted];
+		}];
+
+		samplerDisposable.disposable = [sampler subscribeNext:^(id _) {
+			BOOL shouldSend = NO;
+			id value;
+			[lock lock];
+			shouldSend = hasValue;
+			value = lastValue;
+			[lock unlock];
+
+			if (shouldSend) {
+				[subscriber sendNext:value];
+			}
+		} error:^(NSError *error) {
+			[sourceDisposable dispose];
+			[subscriber sendError:error];
+		} completed:^{
+			[sourceDisposable dispose];
+			[subscriber sendCompleted];
+		}];
+
+		return [RACDisposable disposableWithBlock:^{
+			[samplerDisposable dispose];
+			[sourceDisposable dispose];
+		}];
+	}] setNameWithFormat:@"[%@] -sample: %@", self.name, sampler];
+}
+
+- (RACSignal *)ignoreValues {
+	return [[self filter:^(id _) {
+		return NO;
+	}] setNameWithFormat:@"[%@] -ignoreValues", self.name];
+}
+
+- (RACSignal *)materialize {
+	return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+		return [self subscribeNext:^(id x) {
+			[subscriber sendNext:[RACEvent eventWithValue:x]];
+		} error:^(NSError *error) {
+			[subscriber sendNext:[RACEvent eventWithError:error]];
+			[subscriber sendCompleted];
+		} completed:^{
+			[subscriber sendNext:RACEvent.completedEvent];
+			[subscriber sendCompleted];
+		}];
+	}] setNameWithFormat:@"[%@] -materialize", self.name];
+}
+
+- (RACSignal *)dematerialize {
+	return [[self bind:^{
+		return ^(RACEvent *event, BOOL *stop) {
+			switch (event.eventType) {
+				case RACEventTypeCompleted:
+					*stop = YES;
+					return [RACSignal empty];
+
+				case RACEventTypeError:
+					*stop = YES;
+					return [RACSignal error:event.error];
+
+				case RACEventTypeNext:
+					return [RACSignal return:event.value];
+			}
+		};
+	}] setNameWithFormat:@"[%@] -dematerialize", self.name];
+}
+
+- (RACSignal *)not {
+	return [[self map:^(NSNumber *value) {
+		NSCAssert([value isKindOfClass:NSNumber.class], @"-not must only be used on a signal of NSNumbers. Instead, got: %@", value);
+
+		return @(!value.boolValue);
+	}] setNameWithFormat:@"[%@] -not", self.name];
+}
+
+- (RACSignal *)and {
+	return [[self map:^(RACTuple *tuple) {
+		NSCAssert([tuple isKindOfClass:RACTuple.class], @"-and must only be used on a signal of RACTuples of NSNumbers. Instead, received: %@", tuple);
+		NSCAssert(tuple.count > 0, @"-and must only be used on a signal of RACTuples of NSNumbers, with at least 1 value in the tuple");
+		
+		return @([tuple.rac_sequence all:^(NSNumber *number) {
+			NSCAssert([number isKindOfClass:NSNumber.class], @"-and must only be used on a signal of RACTuples of NSNumbers. Instead, tuple contains a non-NSNumber value: %@", tuple);
+			
+			return number.boolValue;
+		}]);
+	}] setNameWithFormat:@"[%@] -and", self.name];
+}
+
+- (RACSignal *)or {
+	return [[self map:^(RACTuple *tuple) {
+		NSCAssert([tuple isKindOfClass:RACTuple.class], @"-or must only be used on a signal of RACTuples of NSNumbers. Instead, received: %@", tuple);
+		NSCAssert(tuple.count > 0, @"-or must only be used on a signal of RACTuples of NSNumbers, with at least 1 value in the tuple");
+		
+		return @([tuple.rac_sequence any:^(NSNumber *number) {
+			NSCAssert([number isKindOfClass:NSNumber.class], @"-or must only be used on a signal of RACTuples of NSNumbers. Instead, tuple contains a non-NSNumber value: %@", tuple);
+			
+			return number.boolValue;
+		}]);
+	}] setNameWithFormat:@"[%@] -or", self.name];
+}
+
+@end
+
+@implementation RACSignal (OperationsDeprecated)
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-implementations"
+
+- (RACSignal *)windowWithStart:(RACSignal *)openSignal close:(RACSignal * (^)(RACSignal *start))closeBlock {
+	NSCParameterAssert(openSignal != nil);
+	NSCParameterAssert(closeBlock != NULL);
+	
+	return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+		__block RACSubject *currentWindow = nil;
+		__block RACSignal *currentCloseWindow = nil;
+		__block RACDisposable *closeObserverDisposable = NULL;
+		
+		void (^closeCurrentWindow)(void) = ^{
+			[currentWindow sendCompleted];
+			currentWindow = nil;
+			currentCloseWindow = nil;
+			[closeObserverDisposable dispose], closeObserverDisposable = nil;
+		};
+		
+		RACDisposable *openObserverDisposable = [openSignal subscribe:[RACSubscriber subscriberWithNext:^(id x) {
+			if(currentWindow == nil) {
+				currentWindow = [RACSubject subject];
+				[subscriber sendNext:currentWindow];
+				
+				currentCloseWindow = closeBlock(currentWindow);
+				closeObserverDisposable = [currentCloseWindow subscribe:[RACSubscriber subscriberWithNext:^(id x) {
+					closeCurrentWindow();
+				} error:^(NSError *error) {
+					closeCurrentWindow();
+				} completed:^{
+					closeCurrentWindow();
+				}]];
+			}
+		} error:^(NSError *error) {
+			
+		} completed:^{
+			
+		}]];
+				
+		RACDisposable *selfObserverDisposable = [self subscribeNext:^(id x) {
+			[currentWindow sendNext:x];
+		} error:^(NSError *error) {
+			[subscriber sendError:error];
+		} completed:^{
+			[subscriber sendCompleted];
+		}];
+				
+		return [RACDisposable disposableWithBlock:^{
+			[closeObserverDisposable dispose];
+			[openObserverDisposable dispose];
+			[selfObserverDisposable dispose];
+		}];
+	}] setNameWithFormat:@"[%@] -windowWithStart: %@ close:", self.name, openSignal];
+}
+
+- (RACSignal *)buffer:(NSUInteger)bufferCount {
+	NSCParameterAssert(bufferCount > 0);
+	return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+		NSMutableArray *values = [NSMutableArray arrayWithCapacity:bufferCount];
+		RACSubject *windowCloseSubject = [RACSubject subject];
+		
+		RACDisposable *closeDisposable = [windowCloseSubject subscribeNext:^(id x) {
+			[subscriber sendNext:[RACTuple tupleWithObjectsFromArray:values convertNullsToNils:NO]];
+			[values removeAllObjects];
+		}];
+
+		__block RACDisposable *innerDisposable = nil;
+		RACDisposable *outerDisposable = [[self windowWithStart:self close:^(RACSignal *start) {
+			return windowCloseSubject;
+		}] subscribeNext:^(id x) {		
+			innerDisposable = [x subscribeNext:^(id x) {
+				[values addObject:x ? : [RACTupleNil tupleNil]];
+				if(values.count % bufferCount == 0) {
+					[windowCloseSubject sendNext:[RACUnit defaultUnit]];
+				}
+			}];
+		} error:^(NSError *error) {
+			[subscriber sendError:error];
+		} completed:^{
+			[subscriber sendCompleted];
+		}];
+
+		return [RACDisposable disposableWithBlock:^{
+			[innerDisposable dispose];
+			[outerDisposable dispose];
+			[closeDisposable dispose];
+		}];
+	}] setNameWithFormat:@"[%@] -buffer: %lu", self.name, (unsigned long)bufferCount];
+}
+
+- (RACSignal *)let:(RACSignal * (^)(RACSignal *sharedSignal))letBlock {
+	NSCParameterAssert(letBlock != NULL);
+	
+	return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+		RACMulticastConnection *connection = [self publish];
+		RACDisposable *finalDisposable = [letBlock(connection.signal) subscribeNext:^(id x) {
+			[subscriber sendNext:x];
+		} error:^(NSError *error) {
+			[subscriber sendError:error];
+		} completed:^{
+			[subscriber sendCompleted];
+		}];
+		
+		RACDisposable *connectionDisposable = [connection connect];
+		
+		return [RACDisposable disposableWithBlock:^{
+			[connectionDisposable dispose];
+			[finalDisposable dispose];
+		}];
+	}] setNameWithFormat:@"[%@] -let:", self.name];
+}
+
++ (RACSignal *)interval:(NSTimeInterval)interval {
+	return [RACSignal interval:interval onScheduler:[RACScheduler schedulerWithPriority:RACSchedulerPriorityHigh]];
+}
+
++ (RACSignal *)interval:(NSTimeInterval)interval withLeeway:(NSTimeInterval)leeway {
+	return [RACSignal interval:interval onScheduler:[RACScheduler schedulerWithPriority:RACSchedulerPriorityHigh] withLeeway:leeway];
+}
+
+- (RACSignal *)timeout:(NSTimeInterval)interval {
+	return [self timeout:interval onScheduler:[RACScheduler schedulerWithPriority:RACSchedulerPriorityHigh]];
+}
+
+- (RACSignal *)bufferWithTime:(NSTimeInterval)interval {
+	return [self bufferWithTime:interval onScheduler:[RACScheduler schedulerWithPriority:RACSchedulerPriorityHigh]];
+}
+
+- (RACDisposable *)toProperty:(NSString *)keyPath onObject:(NSObject *)object {
+	return [self setKeyPath:keyPath onObject:object];
+}
+
+- (RACSignal *)ignoreElements {
+	return [self ignoreValues];
+}
+
+- (RACSignal *)sequenceNext:(RACSignal * (^)(void))block {
+	return [self then:block];
+}
+
+- (RACSignal *)aggregateWithStart:(id)start combine:(id (^)(id running, id next))combineBlock {
+	return [self aggregateWithStart:start reduce:combineBlock];
+}
+
+- (RACSignal *)aggregateWithStartFactory:(id (^)(void))startFactory combine:(id (^)(id running, id next))combineBlock {
+	return [self aggregateWithStartFactory:startFactory reduce:combineBlock];
+}
+
+- (RACDisposable *)executeCommand:(RACCommand *)command {
+	NSCParameterAssert(command != nil);
+
+	return [self subscribeNext:^(id x) {
+		[command execute:x];
+	}];
+}
+
+#pragma clang diagnostic pop
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSignal.h b/ReactiveCocoaFramework/ReactiveCocoa/RACSignal.h
new file mode 100644
index 0000000..ed644cf
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSignal.h
@@ -0,0 +1,219 @@
+//
+//  RACSignal.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 3/1/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "RACStream.h"
+
+@class RACDisposable;
+@class RACScheduler;
+@class RACSubject;
+@protocol RACSubscriber;
+
+@interface RACSignal : RACStream
+
+/// Creates a new signal. This is the preferred way to create a new signal
+/// operation or behavior.
+///
+/// Events can be sent to new subscribers immediately in the `didSubscribe`
+/// block, but the subscriber will not be able to dispose of the signal until
+/// a RACDisposable is returned from `didSubscribe`. In the case of infinite
+/// signals, this won't _ever_ happen if events are sent immediately.
+///
+/// To ensure that the signal is disposable, events can be scheduled on the
+/// +[RACScheduler currentScheduler] (so that they're deferred, not sent
+/// immediately), or they can be sent in the background. The RACDisposable
+/// returned by the `didSubscribe` block should cancel any such scheduling or
+/// asynchronous work.
+///
+/// didSubscribe - Called when the signal is subscribed to. The new subscriber is
+///                passed in. You can then manually control the <RACSubscriber> by
+///                sending it -sendNext:, -sendError:, and -sendCompleted,
+///                as defined by the operation you're implementing. This block
+///                should return a RACDisposable which cancels any ongoing work
+///                triggered by the subscription, and cleans up any resources or
+///                disposables created as part of it. When the disposable is
+///                disposed of, the signal must not send any more events to the
+///                `subscriber`. If no cleanup is necessary, return nil.
+///
+/// **Note:** The `didSubscribe` block is called every time a new subscriber
+/// subscribes. Any side effects within the block will thus execute once for each
+/// subscription, not necessarily on one thread, and possibly even
+/// simultaneously!
++ (RACSignal *)createSignal:(RACDisposable * (^)(id<RACSubscriber> subscriber))didSubscribe;
+
+/// Returns a signal that immediately sends the given error.
++ (RACSignal *)error:(NSError *)error;
+
+/// Returns a signal that never completes.
++ (RACSignal *)never;
+
+/// Immediately schedules the given block on the given scheduler. The block is
+/// given a subscriber to which it can send events.
+///
+/// scheduler - The scheduler on which `block` will be scheduled and results
+///             delivered. Cannot be nil.
+/// block     - The block to invoke. Cannot be NULL.
+///
+/// Returns a signal which will send all events sent on the subscriber given to
+/// `block`. All events will be sent on `scheduler` and it will replay any missed
+/// events to new subscribers.
++ (RACSignal *)startEagerlyWithScheduler:(RACScheduler *)scheduler block:(void (^)(id<RACSubscriber> subscriber))block;
+
+/// Invokes the given block only on the first subscription. The block is given a
+/// subscriber to which it can send events.
+///
+/// Note that disposing of the subscription to the returned signal will *not*
+/// dispose of the underlying subscription. If you need that behavior, see
+/// -[RACMulticastConnection autoconnect]. The underlying subscription will never
+/// be disposed of. Because of this, `block` should never return an infinite
+/// signal since there would be no way of ending it.
+///
+/// scheduler - The scheduler on which the block should be scheduled. Note that 
+///             if given +[RACScheduler immediateScheduler], the block will be
+///             invoked synchronously on the first subscription. Cannot be nil.
+/// block     - The block to invoke on the first subscription. Cannot be NULL.
+///
+/// Returns a signal which will pass through the events sent to the subscriber
+/// given to `block` and replay any missed events to new subscribers.
++ (RACSignal *)startLazilyWithScheduler:(RACScheduler *)scheduler block:(void (^)(id<RACSubscriber> subscriber))block;
+
+@end
+
+@interface RACSignal (RACStream)
+
+/// Returns a signal that immediately sends the given value and then completes.
++ (RACSignal *)return:(id)value;
+
+/// Returns a signal that immediately completes.
++ (RACSignal *)empty;
+
+/// Subscribes to `signal` when the source signal completes.
+- (RACSignal *)concat:(RACSignal *)signal;
+
+/// Zips the values in the receiver with those of the given signal to create
+/// RACTuples.
+///
+/// The first `next` of each stream will be combined, then the second `next`, and
+/// so forth, until either signal completes or errors.
+///
+/// signal - The signal to zip with. This must not be `nil`.
+///
+/// Returns a new signal of RACTuples, representing the combined values of the
+/// two signals. Any error from one of the original signals will be forwarded on
+/// the returned signal.
+- (RACSignal *)zipWith:(RACSignal *)signal;
+
+@end
+
+@interface RACSignal (Subscription)
+
+/// Subscribes `subscriber` to changes on the receiver. The receiver defines which
+/// events it actually sends and in what situations the events are sent.
+///
+/// Subscription will always happen on a valid RACScheduler. If the
+/// +[RACScheduler currentScheduler] cannot be determined at the time of
+/// subscription (e.g., because the calling code is running on a GCD queue or
+/// NSOperationQueue), subscription will occur on a private background scheduler.
+/// On the main thread, subscriptions will always occur immediately, with a
+/// +[RACScheduler currentScheduler] of +[RACScheduler mainThreadScheduler].
+///
+/// This method must be overridden by any subclasses.
+///
+/// Returns nil or a disposable. You can call -[RACDisposable dispose] if you
+/// need to end your subscription before it would "naturally" end, either by
+/// completing or erroring. Once the disposable has been disposed, the subscriber
+/// won't receive any more events from the subscription.
+- (RACDisposable *)subscribe:(id<RACSubscriber>)subscriber;
+
+/// Convenience method to subscribe to the `next` event.
+///
+/// This corresponds to `IObserver<T>.OnNext` in Rx.
+- (RACDisposable *)subscribeNext:(void (^)(id x))nextBlock;
+
+/// Convenience method to subscribe to the `next` and `completed` events.
+- (RACDisposable *)subscribeNext:(void (^)(id x))nextBlock completed:(void (^)(void))completedBlock;
+
+/// Convenience method to subscribe to the `next`, `completed`, and `error` events.
+- (RACDisposable *)subscribeNext:(void (^)(id x))nextBlock error:(void (^)(NSError *error))errorBlock completed:(void (^)(void))completedBlock;
+
+/// Convenience method to subscribe to `error` events.
+///
+/// This corresponds to the `IObserver<T>.OnError` in Rx.
+- (RACDisposable *)subscribeError:(void (^)(NSError *error))errorBlock;
+
+/// Convenience method to subscribe to `completed` events.
+///
+/// This corresponds to the `IObserver<T>.OnCompleted` in Rx.
+- (RACDisposable *)subscribeCompleted:(void (^)(void))completedBlock;
+
+/// Convenience method to subscribe to `next` and `error` events.
+- (RACDisposable *)subscribeNext:(void (^)(id x))nextBlock error:(void (^)(NSError *error))errorBlock;
+
+/// Convenience method to subscribe to `error` and `completed` events.
+- (RACDisposable *)subscribeError:(void (^)(NSError *error))errorBlock completed:(void (^)(void))completedBlock;
+
+@end
+
+/// Additional methods to assist with debugging.
+@interface RACSignal (Debugging)
+
+/// Logs all events that the receiver sends.
+- (RACSignal *)logAll;
+
+/// Logs each `next` that the receiver sends.
+- (RACSignal *)logNext;
+
+/// Logs any error that the receiver sends.
+- (RACSignal *)logError;
+
+/// Logs any `completed` event that the receiver sends.
+- (RACSignal *)logCompleted;
+
+@end
+
+/// Additional methods to assist with unit testing.
+///
+/// **These methods should never ship in production code.**
+@interface RACSignal (Testing)
+
+/// Spins the main run loop for a short while, waiting for the receiver to send a `next`.
+///
+/// **Because this method executes the run loop recursively, it should only be used
+/// on the main thread, and only from a unit test.**
+///
+/// defaultValue - Returned if the receiver completes or errors before sending
+///                a `next`, or if the method times out. This argument may be
+///                nil.
+/// success      - If not NULL, set to whether the receiver completed
+///                successfully.
+/// error        - If not NULL, set to any error that occurred.
+///
+/// Returns the first value received, or `defaultValue` if no value is received
+/// before the signal finishes or the method times out.
+- (id)asynchronousFirstOrDefault:(id)defaultValue success:(BOOL *)success error:(NSError **)error;
+
+/// Spins the main run loop for a short while, waiting for the receiver to complete.
+///
+/// **Because this method executes the run loop recursively, it should only be used
+/// on the main thread, and only from a unit test.**
+///
+/// error - If not NULL, set to any error that occurs.
+///
+/// Returns whether the signal completed successfully before timing out. If NO,
+/// `error` will be set to any error that occurred.
+- (BOOL)asynchronouslyWaitUntilCompleted:(NSError **)error;
+
+@end
+
+@interface RACSignal (Deprecated)
+
++ (RACSignal *)start:(id (^)(BOOL *success, NSError **error))block __attribute__((deprecated("Use +startEagerlyWithScheduler:block: instead")));
++ (RACSignal *)startWithScheduler:(RACScheduler *)scheduler subjectBlock:(void (^)(RACSubject *subject))block __attribute__((deprecated("Use +startEagerlyWithScheduler:block: instead")));
++ (RACSignal *)startWithScheduler:(RACScheduler *)scheduler block:(id (^)(BOOL *success, NSError **error))block __attribute__((deprecated("Use +startEagerlyWithScheduler:block: instead")));
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSignal.m b/ReactiveCocoaFramework/ReactiveCocoa/RACSignal.m
new file mode 100644
index 0000000..69d9700
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSignal.m
@@ -0,0 +1,447 @@
+//
+//  RACSignal.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 3/15/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSignal.h"
+#import "RACCompoundDisposable.h"
+#import "RACDisposable.h"
+#import "RACDynamicSignal.h"
+#import "RACEmptySignal.h"
+#import "RACErrorSignal.h"
+#import "RACMulticastConnection.h"
+#import "RACReplaySubject.h"
+#import "RACReturnSignal.h"
+#import "RACScheduler.h"
+#import "RACSerialDisposable.h"
+#import "RACSignal+Operations.h"
+#import "RACSubject.h"
+#import "RACSubscriber+Private.h"
+#import "RACTuple.h"
+
+@implementation RACSignal
+
+#pragma mark Lifecycle
+
++ (RACSignal *)createSignal:(RACDisposable * (^)(id<RACSubscriber> subscriber))didSubscribe {
+	return [RACDynamicSignal createSignal:didSubscribe];
+}
+
++ (RACSignal *)error:(NSError *)error {
+	return [RACErrorSignal error:error];
+}
+
++ (RACSignal *)never {
+	return [[self createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) {
+		return nil;
+	}] setNameWithFormat:@"+never"];
+}
+
++ (RACSignal *)startEagerlyWithScheduler:(RACScheduler *)scheduler block:(void (^)(id<RACSubscriber> subscriber))block {
+	NSCParameterAssert(scheduler != nil);
+	NSCParameterAssert(block != NULL);
+
+	RACSignal *signal = [self startLazilyWithScheduler:scheduler block:block];
+	// Subscribe to force the lazy signal to call its block.
+	[[signal publish] connect];
+	return [signal setNameWithFormat:@"+startEagerlyWithScheduler:%@ block:", scheduler];
+}
+
++ (RACSignal *)startLazilyWithScheduler:(RACScheduler *)scheduler block:(void (^)(id<RACSubscriber> subscriber))block {
+	NSCParameterAssert(scheduler != nil);
+	NSCParameterAssert(block != NULL);
+
+	RACMulticastConnection *connection = [[RACSignal
+		createSignal:^ id (id<RACSubscriber> subscriber) {
+			block(subscriber);
+			return nil;
+		}]
+		multicast:[RACReplaySubject subject]];
+	
+	return [[[RACSignal
+		createSignal:^ id (id<RACSubscriber> subscriber) {
+			[connection.signal subscribe:subscriber];
+			[connection connect];
+			return nil;
+		}]
+		subscribeOn:scheduler]
+		setNameWithFormat:@"+startLazilyWithScheduler:%@ block:", scheduler];
+}
+
+#pragma mark NSObject
+
+- (NSString *)description {
+	return [NSString stringWithFormat:@"<%@: %p> name: %@", self.class, self, self.name];
+}
+
+@end
+
+@implementation RACSignal (RACStream)
+
++ (RACSignal *)empty {
+	return [RACEmptySignal empty];
+}
+
++ (RACSignal *)return:(id)value {
+	return [RACReturnSignal return:value];
+}
+
+- (RACSignal *)bind:(RACStreamBindBlock (^)(void))block {
+	NSCParameterAssert(block != NULL);
+
+	/*
+	 * -bind: should:
+	 * 
+	 * 1. Subscribe to the original signal of values.
+	 * 2. Any time the original signal sends a value, transform it using the binding block.
+	 * 3. If the binding block returns a signal, subscribe to it, and pass all of its values through to the subscriber as they're received.
+	 * 4. If the binding block asks the bind to terminate, complete the _original_ signal.
+	 * 5. When _all_ signals complete, send completed to the subscriber.
+	 * 
+	 * If any signal sends an error at any point, send that to the subscriber.
+	 */
+
+	return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+		RACStreamBindBlock bindingBlock = block();
+
+		NSMutableArray *signals = [NSMutableArray arrayWithObject:self];
+
+		RACCompoundDisposable *compoundDisposable = [RACCompoundDisposable compoundDisposable];
+
+		void (^completeSignal)(RACSignal *, RACDisposable *) = ^(RACSignal *signal, RACDisposable *finishedDisposable) {
+			BOOL removeDisposable = NO;
+
+			@synchronized (signals) {
+				[signals removeObject:signal];
+
+				if (signals.count == 0) {
+					[subscriber sendCompleted];
+					[compoundDisposable dispose];
+				} else {
+					removeDisposable = YES;
+				}
+			}
+
+			if (removeDisposable) [compoundDisposable removeDisposable:finishedDisposable];
+		};
+
+		void (^addSignal)(RACSignal *) = ^(RACSignal *signal) {
+			@synchronized (signals) {
+				[signals addObject:signal];
+			}
+
+			RACSerialDisposable *selfDisposable = [[RACSerialDisposable alloc] init];
+			[compoundDisposable addDisposable:selfDisposable];
+
+			RACDisposable *disposable = [signal subscribeNext:^(id x) {
+				[subscriber sendNext:x];
+			} error:^(NSError *error) {
+				[compoundDisposable dispose];
+				[subscriber sendError:error];
+			} completed:^{
+				@autoreleasepool {
+					completeSignal(signal, selfDisposable);
+				}
+			}];
+
+			selfDisposable.disposable = disposable;
+		};
+
+		@autoreleasepool {
+			RACSerialDisposable *selfDisposable = [[RACSerialDisposable alloc] init];
+			[compoundDisposable addDisposable:selfDisposable];
+
+			RACDisposable *bindingDisposable = [self subscribeNext:^(id x) {
+				BOOL stop = NO;
+				id signal = bindingBlock(x, &stop);
+
+				@autoreleasepool {
+					if (signal != nil) addSignal(signal);
+					if (signal == nil || stop) {
+						[selfDisposable dispose];
+						completeSignal(self, selfDisposable);
+					}
+				}
+			} error:^(NSError *error) {
+				[compoundDisposable dispose];
+				[subscriber sendError:error];
+			} completed:^{
+				@autoreleasepool {
+					completeSignal(self, selfDisposable);
+				}
+			}];
+
+			selfDisposable.disposable = bindingDisposable;
+		}
+
+		return compoundDisposable;
+	}] setNameWithFormat:@"[%@] -bind:", self.name];
+}
+
+- (RACSignal *)concat:(RACSignal *)signal {
+	return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+		RACSerialDisposable *serialDisposable = [[RACSerialDisposable alloc] init];
+
+		RACDisposable *sourceDisposable = [self subscribeNext:^(id x) {
+			[subscriber sendNext:x];
+		} error:^(NSError *error) {
+			[subscriber sendError:error];
+		} completed:^{
+			RACDisposable *concattedDisposable = [signal subscribe:subscriber];
+			serialDisposable.disposable = concattedDisposable;
+		}];
+
+		serialDisposable.disposable = sourceDisposable;
+		return serialDisposable;
+	}] setNameWithFormat:@"[%@] -concat: %@", self.name, signal];
+}
+
+- (RACSignal *)zipWith:(RACSignal *)signal {
+	NSCParameterAssert(signal != nil);
+
+	return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+		__block BOOL selfCompleted = NO;
+		NSMutableArray *selfValues = [NSMutableArray array];
+
+		__block BOOL otherCompleted = NO;
+		NSMutableArray *otherValues = [NSMutableArray array];
+
+		void (^sendCompletedIfNecessary)(void) = ^{
+			@synchronized (selfValues) {
+				BOOL selfEmpty = (selfCompleted && selfValues.count == 0);
+				BOOL otherEmpty = (otherCompleted && otherValues.count == 0);
+				if (selfEmpty || otherEmpty) [subscriber sendCompleted];
+			}
+		};
+
+		void (^sendNext)(void) = ^{
+			@synchronized (selfValues) {
+				if (selfValues.count == 0) return;
+				if (otherValues.count == 0) return;
+
+				RACTuple *tuple = [RACTuple tupleWithObjects:selfValues[0], otherValues[0], nil];
+				[selfValues removeObjectAtIndex:0];
+				[otherValues removeObjectAtIndex:0];
+
+				[subscriber sendNext:tuple];
+				sendCompletedIfNecessary();
+			}
+		};
+
+		RACDisposable *selfDisposable = [self subscribeNext:^(id x) {
+			@synchronized (selfValues) {
+				[selfValues addObject:x ?: RACTupleNil.tupleNil];
+				sendNext();
+			}
+		} error:^(NSError *error) {
+			[subscriber sendError:error];
+		} completed:^{
+			@synchronized (selfValues) {
+				selfCompleted = YES;
+				sendCompletedIfNecessary();
+			}
+		}];
+
+		RACDisposable *otherDisposable = [signal subscribeNext:^(id x) {
+			@synchronized (selfValues) {
+				[otherValues addObject:x ?: RACTupleNil.tupleNil];
+				sendNext();
+			}
+		} error:^(NSError *error) {
+			[subscriber sendError:error];
+		} completed:^{
+			@synchronized (selfValues) {
+				otherCompleted = YES;
+				sendCompletedIfNecessary();
+			}
+		}];
+
+		return [RACDisposable disposableWithBlock:^{
+			[selfDisposable dispose];
+			[otherDisposable dispose];
+		}];
+	}] setNameWithFormat:@"[%@] -zipWith: %@", self.name, signal];
+}
+
+@end
+
+@implementation RACSignal (Subscription)
+
+- (RACDisposable *)subscribe:(id<RACSubscriber>)subscriber {
+	NSCAssert(NO, @"This method must be overridden by subclasses");
+	return nil;
+}
+
+- (RACDisposable *)subscribeNext:(void (^)(id x))nextBlock {
+	NSCParameterAssert(nextBlock != NULL);
+	
+	RACSubscriber *o = [RACSubscriber subscriberWithNext:nextBlock error:NULL completed:NULL];
+	return [self subscribe:o];
+}
+
+- (RACDisposable *)subscribeNext:(void (^)(id x))nextBlock completed:(void (^)(void))completedBlock {
+	NSCParameterAssert(nextBlock != NULL);
+	NSCParameterAssert(completedBlock != NULL);
+	
+	RACSubscriber *o = [RACSubscriber subscriberWithNext:nextBlock error:NULL completed:completedBlock];
+	return [self subscribe:o];
+}
+
+- (RACDisposable *)subscribeNext:(void (^)(id x))nextBlock error:(void (^)(NSError *error))errorBlock completed:(void (^)(void))completedBlock {
+	NSCParameterAssert(nextBlock != NULL);
+	NSCParameterAssert(errorBlock != NULL);
+	NSCParameterAssert(completedBlock != NULL);
+	
+	RACSubscriber *o = [RACSubscriber subscriberWithNext:nextBlock error:errorBlock completed:completedBlock];
+	return [self subscribe:o];
+}
+
+- (RACDisposable *)subscribeError:(void (^)(NSError *error))errorBlock {
+	NSCParameterAssert(errorBlock != NULL);
+	
+	RACSubscriber *o = [RACSubscriber subscriberWithNext:NULL error:errorBlock completed:NULL];
+	return [self subscribe:o];
+}
+
+- (RACDisposable *)subscribeCompleted:(void (^)(void))completedBlock {
+	NSCParameterAssert(completedBlock != NULL);
+	
+	RACSubscriber *o = [RACSubscriber subscriberWithNext:NULL error:NULL completed:completedBlock];
+	return [self subscribe:o];
+}
+
+- (RACDisposable *)subscribeNext:(void (^)(id x))nextBlock error:(void (^)(NSError *error))errorBlock {
+	NSCParameterAssert(nextBlock != NULL);
+	NSCParameterAssert(errorBlock != NULL);
+	
+	RACSubscriber *o = [RACSubscriber subscriberWithNext:nextBlock error:errorBlock completed:NULL];
+	return [self subscribe:o];
+}
+
+- (RACDisposable *)subscribeError:(void (^)(NSError *))errorBlock completed:(void (^)(void))completedBlock {
+	NSCParameterAssert(completedBlock != NULL);
+	NSCParameterAssert(errorBlock != NULL);
+	
+	RACSubscriber *o = [RACSubscriber subscriberWithNext:NULL error:errorBlock completed:completedBlock];
+	return [self subscribe:o];
+}
+
+@end
+
+@implementation RACSignal (Debugging)
+
+- (RACSignal *)logAll {
+	return [[[self logNext] logError] logCompleted];
+}
+
+- (RACSignal *)logNext {
+	return [[self doNext:^(id x) {
+		NSLog(@"%@ next: %@", self, x);
+	}] setNameWithFormat:@"%@", self.name];
+}
+
+- (RACSignal *)logError {
+	return [[self doError:^(NSError *error) {
+		NSLog(@"%@ error: %@", self, error);
+	}] setNameWithFormat:@"%@", self.name];
+}
+
+- (RACSignal *)logCompleted {
+	return [[self doCompleted:^{
+		NSLog(@"%@ completed", self);
+	}] setNameWithFormat:@"%@", self.name];
+}
+
+@end
+
+@implementation RACSignal (Testing)
+
+static const NSTimeInterval RACSignalAsynchronousWaitTimeout = 10;
+
+- (id)asynchronousFirstOrDefault:(id)defaultValue success:(BOOL *)success error:(NSError **)error {
+	NSCAssert([NSThread isMainThread], @"%s should only be used from the main thread", __func__);
+
+	__block id result = defaultValue;
+	__block BOOL done = NO;
+
+	// Ensures that we don't pass values across thread boundaries by reference.
+	__block NSError *localError;
+	__block BOOL localSuccess = YES;
+
+	[[[[self
+		take:1]
+		timeout:RACSignalAsynchronousWaitTimeout onScheduler:[RACScheduler scheduler]]
+		deliverOn:RACScheduler.mainThreadScheduler]
+		subscribeNext:^(id x) {
+			result = x;
+			done = YES;
+		} error:^(NSError *e) {
+			if (!done) {
+				localSuccess = NO;
+				localError = e;
+				done = YES;
+			}
+		} completed:^{
+			done = YES;
+		}];
+	
+	do {
+		[NSRunLoop.mainRunLoop runMode:NSDefaultRunLoopMode beforeDate:[NSDate dateWithTimeIntervalSinceNow:0.1]];
+	} while (!done);
+
+	if (success != NULL) *success = localSuccess;
+	if (error != NULL) *error = localError;
+
+	return result;
+}
+
+- (BOOL)asynchronouslyWaitUntilCompleted:(NSError **)error {
+	BOOL success = NO;
+	[[self ignoreValues] asynchronousFirstOrDefault:nil success:&success error:error];
+	return success;
+}
+
+@end
+
+@implementation RACSignal (Deprecated)
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-implementations"
+
++ (RACSignal *)startWithScheduler:(RACScheduler *)scheduler subjectBlock:(void (^)(RACSubject *subject))block {
+	NSCParameterAssert(block != NULL);
+
+	RACReplaySubject *subject = [[RACReplaySubject subject] setNameWithFormat:@"+startWithScheduler:subjectBlock:"];
+
+	[scheduler schedule:^{
+		block(subject);
+	}];
+
+	return subject;
+}
+
++ (RACSignal *)start:(id (^)(BOOL *success, NSError **error))block {
+	return [[self startWithScheduler:[RACScheduler scheduler] block:block] setNameWithFormat:@"+start:"];
+}
+
++ (RACSignal *)startWithScheduler:(RACScheduler *)scheduler block:(id (^)(BOOL *success, NSError **error))block {
+	return [[self startWithScheduler:scheduler subjectBlock:^(id<RACSubscriber> subscriber) {
+		BOOL success = YES;
+		NSError *error = nil;
+		id returned = block(&success, &error);
+
+		if (!success) {
+			[subscriber sendError:error];
+		} else {
+			[subscriber sendNext:returned];
+			[subscriber sendCompleted];
+		}
+	}] setNameWithFormat:@"+startWithScheduler:block:"];
+}
+
+#pragma clang diagnostic pop
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSignalProvider.d b/ReactiveCocoaFramework/ReactiveCocoa/RACSignalProvider.d
new file mode 100644
index 0000000..8add9a1
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSignalProvider.d
@@ -0,0 +1,5 @@
+provider RACSignal {
+    probe next(char *signal, char *subscriber, char *valueDescription);
+    probe completed(char *signal, char *subscriber);
+    probe error(char *signal, char *subscriber, char *errorDescription);
+};
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSignalSequence.h b/ReactiveCocoaFramework/ReactiveCocoa/RACSignalSequence.h
new file mode 100644
index 0000000..e3ab77d
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSignalSequence.h
@@ -0,0 +1,19 @@
+//
+//  RACSignalSequence.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-11-09.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSequence.h"
+
+@class RACSignal;
+
+// Private class that adapts a RACSignal to the RACSequence interface.
+@interface RACSignalSequence : RACSequence
+
+// Returns a sequence for enumerating over the given signal.
++ (RACSequence *)sequenceWithSignal:(RACSignal *)signal;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSignalSequence.m b/ReactiveCocoaFramework/ReactiveCocoa/RACSignalSequence.m
new file mode 100644
index 0000000..52ea1b9
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSignalSequence.m
@@ -0,0 +1,79 @@
+//
+//  RACSignalSequence.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-11-09.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSignalSequence.h"
+#import "RACDisposable.h"
+#import "RACReplaySubject.h"
+#import "RACSignal+Operations.h"
+
+@interface RACSignalSequence ()
+
+// Replays the signal given on initialization.
+@property (nonatomic, strong, readonly) RACReplaySubject *subject;
+
+@end
+
+@implementation RACSignalSequence
+
+#pragma mark Lifecycle
+
++ (RACSequence *)sequenceWithSignal:(RACSignal *)signal {
+	RACSignalSequence *seq = [[self alloc] init];
+
+	RACReplaySubject *subject = [RACReplaySubject subject];
+	[signal subscribeNext:^(id value) {
+		[subject sendNext:value];
+	} error:^(NSError *error) {
+		[subject sendError:error];
+	} completed:^{
+		[subject sendCompleted];
+	}];
+
+	seq->_subject = subject;
+	return seq;
+}
+
+#pragma mark RACSequence
+
+- (id)head {
+	id value = [self.subject firstOrDefault:self];
+
+	if (value == self) {
+		return nil;
+	} else {
+		return value ?: NSNull.null;
+	}
+}
+
+- (RACSequence *)tail {
+	RACSequence *sequence = [self.class sequenceWithSignal:[self.subject skip:1]];
+	sequence.name = self.name;
+	return sequence;
+}
+
+- (NSArray *)array {
+	return self.subject.toArray;
+}
+
+#pragma mark NSObject
+
+- (NSString *)description {
+	// Synchronously accumulate the values that have been sent so far.
+	NSMutableArray *values = [NSMutableArray array];
+	RACDisposable *disposable = [self.subject subscribeNext:^(id value) {
+		@synchronized (values) {
+			[values addObject:value ?: NSNull.null];
+		}
+	}];
+
+	[disposable dispose];
+
+	return [NSString stringWithFormat:@"<%@: %p>{ name = %@, values = %@ … }", self.class, self, self.name, values];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACStream+Private.h b/ReactiveCocoaFramework/ReactiveCocoa/RACStream+Private.h
new file mode 100644
index 0000000..f6c0407
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACStream+Private.h
@@ -0,0 +1,23 @@
+//
+//  RACStream+Private.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-07-22.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACStream.h"
+
+@interface RACStream ()
+
+// Combines a list of streams using the logic of the given block.
+//
+// streams - The streams to combine.
+// block   - An operator that combines two streams and returns a new one. The
+//           returned stream should contain 2-tuples of the streams' combined
+//           values.
+//
+// Returns a combined stream.
++ (instancetype)join:(id<NSFastEnumeration>)streams block:(RACStream * (^)(id, id))block;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACStream.h b/ReactiveCocoaFramework/ReactiveCocoa/RACStream.h
new file mode 100644
index 0000000..8853ffe
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACStream.h
@@ -0,0 +1,321 @@
+//
+//  RACStream.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-10-31.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+@class RACStream;
+
+/// A block which accepts a value from a RACStream and returns a new instance
+/// of the same stream class.
+///
+/// Setting `stop` to `YES` will cause the bind to terminate after the returned
+/// value. Returning `nil` will result in immediate termination.
+typedef RACStream * (^RACStreamBindBlock)(id value, BOOL *stop);
+
+/// An abstract class representing any stream of values.
+///
+/// This class represents a monad, upon which many stream-based operations can
+/// be built.
+///
+/// When subclassing RACStream, only the methods in the main @interface body need
+/// to be overridden.
+@interface RACStream : NSObject
+
+/// Returns an empty stream.
++ (instancetype)empty;
+
+/// Lifts `value` into the stream monad.
+///
+/// Returns a stream containing only the given value.
++ (instancetype)return:(id)value;
+
+/// Lazily binds a block to the values in the receiver.
+///
+/// This should only be used if you need to terminate the bind early, or close
+/// over some state. -flattenMap: is more appropriate for all other cases.
+///
+/// block - A block returning a RACStreamBindBlock. This block will be invoked
+///         each time the bound stream is re-evaluated. This block must not be
+///         nil or return nil.
+///
+/// Returns a new stream which represents the combined result of all lazy
+/// applications of `block`.
+- (instancetype)bind:(RACStreamBindBlock (^)(void))block;
+
+/// Appends the values of `stream` to the values in the receiver.
+///
+/// stream - A stream to concatenate. This must be an instance of the same
+///          concrete class as the receiver, and should not be `nil`.
+///
+/// Returns a new stream representing the receiver followed by `stream`.
+- (instancetype)concat:(RACStream *)stream;
+
+/// Zips the values in the receiver with those of the given stream to create
+/// RACTuples.
+///
+/// The first value of each stream will be combined, then the second value, and
+/// so forth, until at least one of the streams is exhausted.
+///
+/// stream - The stream to zip with. This must be an instance of the same
+///          concrete class as the receiver, and should not be `nil`.
+///
+/// Returns a new stream of RACTuples, representing the zipped values of the
+/// two streams.
+- (instancetype)zipWith:(RACStream *)stream;
+
+@end
+
+/// This extension contains functionality to support naming streams for
+/// debugging.
+///
+/// Subclasses do not need to override the methods here.
+@interface RACStream ()
+
+/// The name of the stream. This is for debugging/human purposes only.
+@property (copy) NSString *name;
+
+/// Sets the name of the receiver to the given format string.
+///
+/// This is for debugging purposes only, and won't do anything unless the
+/// RAC_DEBUG_SIGNAL_NAMES environment variable is set.
+///
+/// Returns the receiver, for easy method chaining.
+- (instancetype)setNameWithFormat:(NSString *)format, ... NS_FORMAT_FUNCTION(1, 2);
+
+@end
+
+/// Operations built on the RACStream primitives.
+///
+/// These methods do not need to be overridden, although subclasses may
+/// occasionally gain better performance from doing so.
+@interface RACStream (Operations)
+
+/// Maps `block` across the values in the receiver and flattens the result.
+///
+/// Note that operators applied _after_ -flattenMap: behave differently from
+/// operators _within_ -flattenMap:. See the Examples section below.
+///
+/// This corresponds to the `SelectMany` method in Rx.
+///
+/// block - A block which accepts the values in the receiver and returns a new
+///         instance of the receiver's class. Returning `nil` from this block is
+///         equivalent to returning an empty signal.
+///
+/// Examples
+///
+///   [signal flattenMap:^(id x) {
+///       // Logs each time a returned signal completes.
+///       return [[RACSignal return:x] logCompleted];
+///   }];
+///
+///   [[signal
+///       flattenMap:^(id x) {
+///           return [RACSignal return:x];
+///       }]
+///       // Logs only once, when all of the signals complete.
+///       logCompleted];
+///
+/// Returns a new stream which represents the combined streams resulting from
+/// mapping `block`.
+- (instancetype)flattenMap:(RACStream * (^)(id value))block;
+
+/// Flattens a stream of streams.
+///
+/// This corresponds to the `Merge` method in Rx.
+///
+/// Returns a stream consisting of the combined streams obtained from the
+/// receiver.
+- (instancetype)flatten;
+
+/// Maps `block` across the values in the receiver.
+///
+/// This corresponds to the `Select` method in Rx.
+///
+/// Returns a new stream with the mapped values.
+- (instancetype)map:(id (^)(id value))block;
+
+/// Replace each value in the receiver with the given object.
+///
+/// Returns a new stream which includes the given object once for each value in
+/// the receiver.
+- (instancetype)mapReplace:(id)object;
+
+/// Filters out values in the receiver that don't pass the given test.
+///
+/// This corresponds to the `Where` method in Rx.
+///
+/// Returns a new stream with only those values that passed.
+- (instancetype)filter:(BOOL (^)(id value))block;
+
+/// Filters out values in the receiver that equal (via -isEqual:) the provided value.
+///
+/// value - The value can be `nil`, in which case it ignores `nil` values.
+///
+/// Returns a new stream containing only the values which did not compare equal
+/// to `value`.
+- (instancetype)ignore:(id)value;
+
+/// Unpacks each RACTuple in the receiver and maps the values to a new value.
+///
+/// reduceBlock - The block which reduces each RACTuple's values into one value.
+///               It must take as many arguments as the number of tuple elements
+///               to process. Each argument will be an object argument. The
+///               return value must be an object. This argument cannot be nil.
+///
+/// Returns a new stream of reduced tuple values.
+- (instancetype)reduceEach:(id (^)())reduceBlock;
+
+/// Returns a stream consisting of `value`, followed by the values in the
+/// receiver.
+- (instancetype)startWith:(id)value;
+
+/// Skips the first `skipCount` values in the receiver.
+///
+/// Returns the receiver after skipping the first `skipCount` values. If
+/// `skipCount` is greater than the number of values in the stream, an empty
+/// stream is returned.
+- (instancetype)skip:(NSUInteger)skipCount;
+
+/// Returns a stream of the first `count` values in the receiver. If `count` is
+/// greater than or equal to the number of values in the stream, a stream
+/// equivalent to the receiver is returned.
+- (instancetype)take:(NSUInteger)count;
+
+/// Zips the values in the given streams to create RACTuples.
+///
+/// The first value of each stream will be combined, then the second value, and
+/// so forth, until at least one of the streams is exhausted.
+///
+/// streams - The streams to combine. These must all be instances of the same
+///           concrete class implementing the protocol. If this collection is
+///           empty, the returned stream will be empty.
+///
+/// Returns a new stream containing RACTuples of the zipped values from the
+/// streams.
++ (instancetype)zip:(id<NSFastEnumeration>)streams;
+
+/// Zips streams using +zip:, then reduces the resulting tuples into a single
+/// value using -reduceEach:
+///
+/// streams     - The streams to combine. These must all be instances of the
+///               same concrete class implementing the protocol. If this
+///               collection is empty, the returned stream will be empty.
+/// reduceBlock - The block which reduces the values from all the streams
+///               into one value. It must take as many arguments as the
+///               number of streams given. Each argument will be an object
+///               argument. The return value must be an object. This argument
+///               must not be nil.
+///
+/// Example:
+///
+///   [RACStream zip:@[ stringSignal, intSignal ] reduce:^(NSString *string, NSNumber *number) {
+///       return [NSString stringWithFormat:@"%@: %@", string, number];
+///   }];
+///
+/// Returns a new stream containing the results from each invocation of
+/// `reduceBlock`.
++ (instancetype)zip:(id<NSFastEnumeration>)streams reduce:(id (^)())reduceBlock;
+
+/// Returns a stream obtained by concatenating `streams` in order.
++ (instancetype)concat:(id<NSFastEnumeration>)streams;
+
+/// Combines values in the receiver from left to right using the given block.
+///
+/// The algorithm proceeds as follows:
+///
+///  1. `startingValue` is passed into the block as the `running` value, and the
+///  first element of the receiver is passed into the block as the `next` value.
+///  2. The result of the invocation is added to the returned stream.
+///  3. The result of the invocation (`running`) and the next element of the
+///  receiver (`next`) is passed into `block`.
+///  4. Steps 2 and 3 are repeated until all values have been processed.
+///
+/// startingValue - The value to be combined with the first element of the
+///                 receiver. This value may be `nil`.
+/// block         - A block that describes how to combine values of the
+///                 receiver. If the receiver is empty, this block will never be
+///                 invoked.
+///
+/// Examples
+///
+///      RACSequence *numbers = @[ @1, @2, @3, @4 ].rac_sequence;
+///
+///      // Contains 1, 3, 6, 10
+///      RACSequence *sums = [numbers scanWithStart:@0 reduce:^(NSNumber *sum, NSNumber *next) {
+///          return @(sum.integerValue + next.integerValue);
+///      }];
+///
+/// Returns a new stream that consists of each application of `block`. If the
+/// receiver is empty, an empty stream is returned.
+- (instancetype)scanWithStart:(id)startingValue reduce:(id (^)(id running, id next))block;
+
+/// Combines each previous and current value into one object.
+///
+/// This method is similar to -scanWithStart:reduce:, but only ever operates on
+/// the previous and current values (instead of the whole stream), and does not
+/// pass the return value of `reduceBlock` into the next invocation of it.
+///
+/// start       - The value passed into `reduceBlock` as `previous` for the
+///               first value.
+/// reduceBlock - The block that combines the previous value and the current
+///               value to create the reduced value. Cannot be nil.
+///
+/// Examples
+///
+///      RACSequence *numbers = @[ @1, @2, @3, @4 ].rac_sequence;
+///
+///      // Contains 1, 3, 5, 7
+///      RACSequence *sums = [numbers combinePreviousWithStart:@0 reduce:^(NSNumber *previous, NSNumber *next) {
+///          return @(previous.integerValue + next.integerValue);
+///      }];
+///
+/// Returns a new stream consisting of the return values from each application of
+/// `reduceBlock`.
+- (instancetype)combinePreviousWithStart:(id)start reduce:(id (^)(id previous, id current))reduceBlock;
+
+/// Takes values until the given block returns `YES`.
+///
+/// Returns a stream of the initial values in the receiver that fail `predicate`.
+/// If `predicate` never returns `YES`, a stream equivalent to the receiver is
+/// returned.
+- (instancetype)takeUntilBlock:(BOOL (^)(id x))predicate;
+
+/// Takes values until the given block returns `NO`.
+///
+/// Returns a stream of the initial values in the receiver that pass `predicate`.
+/// If `predicate` never returns `NO`, a stream equivalent to the receiver is
+/// returned.
+- (instancetype)takeWhileBlock:(BOOL (^)(id x))predicate;
+
+/// Skips values until the given block returns `YES`.
+///
+/// Returns a stream containing the values of the receiver that follow any
+/// initial values failing `predicate`. If `predicate` never returns `YES`,
+/// an empty stream is returned.
+- (instancetype)skipUntilBlock:(BOOL (^)(id x))predicate;
+
+/// Skips values until the given block returns `NO`.
+///
+/// Returns a stream containing the values of the receiver that follow any
+/// initial values passing `predicate`. If `predicate` never returns `NO`, an
+/// empty stream is returned.
+- (instancetype)skipWhileBlock:(BOOL (^)(id x))predicate;
+
+/// Returns a stream of values for which -isEqual: returns NO when compared to the
+/// previous value.
+- (instancetype)distinctUntilChanged;
+
+@end
+
+@interface RACStream (Deprecated)
+
+- (instancetype)sequenceMany:(RACStream * (^)(void))block __attribute__((deprecated("Use -flattenMap: instead")));
+- (instancetype)scanWithStart:(id)startingValue combine:(id (^)(id running, id next))block __attribute__((deprecated("Renamed to -scanWithStart:reduce:")));
+- (instancetype)mapPreviousWithStart:(id)start reduce:(id (^)(id previous, id current))combineBlock __attribute__((deprecated("Renamed to -combinePreviousWithStart:reduce:")));
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACStream.m b/ReactiveCocoaFramework/ReactiveCocoa/RACStream.m
new file mode 100644
index 0000000..7c37c69
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACStream.m
@@ -0,0 +1,362 @@
+//
+//  RACStream.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-10-31.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACStream.h"
+#import "NSObject+RACDescription.h"
+#import "RACBlockTrampoline.h"
+#import "RACTuple.h"
+
+@implementation RACStream
+
+#pragma mark Lifecycle
+
+- (id)init {
+	self = [super init];
+	if (self == nil) return nil;
+
+	self.name = @"";
+	return self;
+}
+
+#pragma mark Abstract methods
+
++ (instancetype)empty {
+	return nil;
+}
+
+- (instancetype)bind:(RACStreamBindBlock (^)(void))block {
+	return nil;
+}
+
++ (instancetype)return:(id)value {
+	return nil;
+}
+
+- (instancetype)concat:(RACStream *)stream {
+	return nil;
+}
+
+- (instancetype)zipWith:(RACStream *)stream {
+	return nil;
+}
+
+#pragma mark Naming
+
+- (instancetype)setNameWithFormat:(NSString *)format, ... {
+	if (getenv("RAC_DEBUG_SIGNAL_NAMES") == NULL) return self;
+
+	NSCParameterAssert(format != nil);
+
+	va_list args;
+	va_start(args, format);
+
+	NSString *str = [[NSString alloc] initWithFormat:format arguments:args];
+	va_end(args);
+
+	self.name = str;
+	return self;
+}
+
+@end
+
+@implementation RACStream (Operations)
+
+- (instancetype)flattenMap:(RACStream * (^)(id value))block {
+	Class class = self.class;
+
+	return [[self bind:^{
+		return ^(id value, BOOL *stop) {
+			id stream = block(value) ?: [class empty];
+			NSCAssert([stream isKindOfClass:RACStream.class], @"Value returned from -flattenMap: is not a stream: %@", stream);
+
+			return stream;
+		};
+	}] setNameWithFormat:@"[%@] -flattenMap:", self.name];
+}
+
+- (instancetype)flatten {
+	__weak RACStream *stream __attribute__((unused)) = self;
+	return [[self flattenMap:^(id value) {
+		return value;
+	}] setNameWithFormat:@"[%@] -flatten", self.name];
+}
+
+- (instancetype)map:(id (^)(id value))block {
+	NSCParameterAssert(block != nil);
+
+	Class class = self.class;
+	
+	return [[self flattenMap:^(id value) {
+		return [class return:block(value)];
+	}] setNameWithFormat:@"[%@] -map:", self.name];
+}
+
+- (instancetype)mapReplace:(id)object {
+	return [[self map:^(id _) {
+		return object;
+	}] setNameWithFormat:@"[%@] -mapReplace: %@", self.name, [object rac_description]];
+}
+
+- (instancetype)combinePreviousWithStart:(id)start reduce:(id (^)(id previous, id next))reduceBlock {
+	NSCParameterAssert(reduceBlock != NULL);
+	return [[[self
+		scanWithStart:[RACTuple tupleWithObjects:start, nil]
+		reduce:^(RACTuple *previousTuple, id next) {
+			id value = reduceBlock(previousTuple[0], next);
+			return [RACTuple tupleWithObjects:next ?: RACTupleNil.tupleNil, value ?: RACTupleNil.tupleNil, nil];
+		}]
+		map:^(RACTuple *tuple) {
+			return tuple[1];
+		}]
+		setNameWithFormat:@"[%@] -combinePreviousWithStart: %@ reduce:", self.name, [start rac_description]];
+}
+
+- (instancetype)filter:(BOOL (^)(id value))block {
+	NSCParameterAssert(block != nil);
+
+	Class class = self.class;
+	
+	return [[self flattenMap:^ id (id value) {
+		if (block(value)) {
+			return [class return:value];
+		} else {
+			return class.empty;
+		}
+	}] setNameWithFormat:@"[%@] -filter:", self.name];
+}
+
+- (instancetype)ignore:(id)value {
+	return [[self filter:^ BOOL (id innerValue) {
+		return innerValue != value && ![innerValue isEqual:value];
+	}] setNameWithFormat:@"[%@] -ignore: %@", self.name, [value rac_description]];
+}
+
+- (instancetype)reduceEach:(id (^)())reduceBlock {
+	NSCParameterAssert(reduceBlock != nil);
+
+	__weak RACStream *stream __attribute__((unused)) = self;
+	return [[self map:^(RACTuple *t) {
+		NSCAssert([t isKindOfClass:RACTuple.class], @"Value from stream %@ is not a tuple: %@", stream, t);
+		return [RACBlockTrampoline invokeBlock:reduceBlock withArguments:t];
+	}] setNameWithFormat:@"[%@] -reduceEach:", self.name];
+}
+
+- (instancetype)startWith:(id)value {
+	return [[[self.class return:value]
+		concat:self]
+		setNameWithFormat:@"[%@] -startWith: %@", self.name, [value rac_description]];
+}
+
+- (instancetype)skip:(NSUInteger)skipCount {
+	Class class = self.class;
+	
+	return [[self bind:^{
+		__block NSUInteger skipped = 0;
+
+		return ^(id value, BOOL *stop) {
+			if (skipped >= skipCount) return [class return:value];
+
+			skipped++;
+			return class.empty;
+		};
+	}] setNameWithFormat:@"[%@] -skip: %lu", self.name, (unsigned long)skipCount];
+}
+
+- (instancetype)take:(NSUInteger)count {
+	Class class = self.class;
+	
+	return [[self bind:^{
+		__block NSUInteger taken = 0;
+
+		return ^ id (id value, BOOL *stop) {
+			RACStream *result = class.empty;
+
+			if (taken < count) result = [class return:value];
+			if (++taken >= count) *stop = YES;
+
+			return result;
+		};
+	}] setNameWithFormat:@"[%@] -take: %lu", self.name, (unsigned long)count];
+}
+
++ (instancetype)join:(id<NSFastEnumeration>)streams block:(RACStream * (^)(id, id))block {
+	RACStream *current = nil;
+
+	// Creates streams of successively larger tuples by combining the input
+	// streams one-by-one.
+	for (RACStream *stream in streams) {
+		// For the first stream, just wrap its values in a RACTuple. That way,
+		// if only one stream is given, the result is still a stream of tuples.
+		if (current == nil) {
+			current = [stream map:^(id x) {
+				return RACTuplePack(x);
+			}];
+
+			continue;
+		}
+
+		current = block(current, stream);
+	}
+
+	if (current == nil) return [self empty];
+
+	return [current map:^(RACTuple *xs) {
+		// Right now, each value is contained in its own tuple, sorta like:
+		//
+		// (((1), 2), 3)
+		//
+		// We need to unwrap all the layers and create a tuple out of the result.
+		NSMutableArray *values = [[NSMutableArray alloc] init];
+
+		while (xs != nil) {
+			[values insertObject:xs.last ?: RACTupleNil.tupleNil atIndex:0];
+			xs = (xs.count > 1 ? xs.first : nil);
+		}
+
+		return [RACTuple tupleWithObjectsFromArray:values];
+	}];
+}
+
++ (instancetype)zip:(id<NSFastEnumeration>)streams {
+	return [[self join:streams block:^(RACStream *left, RACStream *right) {
+		return [left zipWith:right];
+	}] setNameWithFormat:@"+zip: %@", streams];
+}
+
++ (instancetype)zip:(id<NSFastEnumeration>)streams reduce:(id (^)())reduceBlock {
+	NSCParameterAssert(reduceBlock != nil);
+
+	RACStream *result = [self zip:streams];
+
+	// Although we assert this condition above, older versions of this method
+	// supported this argument being nil. Avoid crashing Release builds of
+	// apps that depended on that.
+	if (reduceBlock != nil) result = [result reduceEach:reduceBlock];
+
+	return [result setNameWithFormat:@"+zip: %@ reduce:", streams];
+}
+
++ (instancetype)concat:(id<NSFastEnumeration>)streams {
+	RACStream *result = self.empty;
+	for (RACStream *stream in streams) {
+		result = [result concat:stream];
+	}
+
+	return [result setNameWithFormat:@"+concat: %@", streams];
+}
+
+- (instancetype)scanWithStart:(id)startingValue reduce:(id (^)(id running, id next))block {
+	NSCParameterAssert(block != nil);
+
+	Class class = self.class;
+	
+	return [[self bind:^{
+		__block id running = startingValue;
+
+		return ^(id value, BOOL *stop) {
+			running = block(running, value);
+			return [class return:running];
+		};
+	}] setNameWithFormat:@"[%@] -scanWithStart: %@ reduce:", self.name, [startingValue rac_description]];
+}
+
+- (instancetype)takeUntilBlock:(BOOL (^)(id x))predicate {
+	NSCParameterAssert(predicate != nil);
+
+	Class class = self.class;
+	
+	return [[self bind:^{
+		return ^ id (id value, BOOL *stop) {
+			if (predicate(value)) return nil;
+
+			return [class return:value];
+		};
+	}] setNameWithFormat:@"[%@] -takeUntilBlock:", self.name];
+}
+
+- (instancetype)takeWhileBlock:(BOOL (^)(id x))predicate {
+	NSCParameterAssert(predicate != nil);
+
+	return [[self takeUntilBlock:^ BOOL (id x) {
+		return !predicate(x);
+	}] setNameWithFormat:@"[%@] -takeWhileBlock:", self.name];
+}
+
+- (instancetype)skipUntilBlock:(BOOL (^)(id x))predicate {
+	NSCParameterAssert(predicate != nil);
+
+	Class class = self.class;
+	
+	return [[self bind:^{
+		__block BOOL skipping = YES;
+
+		return ^ id (id value, BOOL *stop) {
+			if (skipping) {
+				if (predicate(value)) {
+					skipping = NO;
+				} else {
+					return class.empty;
+				}
+			}
+
+			return [class return:value];
+		};
+	}] setNameWithFormat:@"[%@] -skipUntilBlock:", self.name];
+}
+
+- (instancetype)skipWhileBlock:(BOOL (^)(id x))predicate {
+	NSCParameterAssert(predicate != nil);
+
+	return [[self skipUntilBlock:^ BOOL (id x) {
+		return !predicate(x);
+	}] setNameWithFormat:@"[%@] -skipUntilBlock:", self.name];
+}
+
+- (instancetype)distinctUntilChanged {
+	Class class = self.class;
+
+	return [[self bind:^{
+		__block id lastValue = nil;
+		__block BOOL initial = YES;
+
+		return ^(id x, BOOL *stop) {
+			if (!initial && (lastValue == x || [x isEqual:lastValue])) return [class empty];
+
+			initial = NO;
+			lastValue = x;
+			return [class return:x];
+		};
+	}] setNameWithFormat:@"[%@] -distinctUntilChanged", self.name];
+}
+
+@end
+
+@implementation RACStream (Deprecated)
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-implementations"
+
+- (instancetype)sequenceMany:(RACStream * (^)(void))block {
+	NSCParameterAssert(block != NULL);
+
+	return [[self flattenMap:^(id _) {
+		return block();
+	}] setNameWithFormat:@"[%@] -sequenceMany:", self.name];
+}
+
+- (instancetype)scanWithStart:(id)startingValue combine:(id (^)(id running, id next))block {
+	return [self scanWithStart:startingValue reduce:block];
+}
+
+- (instancetype)mapPreviousWithStart:(id)start reduce:(id (^)(id previous, id current))combineBlock {
+	return [self combinePreviousWithStart:start reduce:combineBlock];
+}
+
+#pragma clang diagnostic pop
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACStringSequence.h b/ReactiveCocoaFramework/ReactiveCocoa/RACStringSequence.h
new file mode 100644
index 0000000..b37ddea
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACStringSequence.h
@@ -0,0 +1,18 @@
+//
+//  RACStringSequence.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-10-29.
+//  Copyright (c) 2012 GitHub. All rights reserved.
+//
+
+#import "RACSequence.h"
+
+// Private class that adapts a string to the RACSequence interface.
+@interface RACStringSequence : RACSequence
+
+// Returns a sequence for enumerating over the given string, starting from the
+// given character offset. The string will be copied to prevent mutation.
++ (RACSequence *)sequenceWithString:(NSString *)string offset:(NSUInteger)offset;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACStringSequence.m b/ReactiveCocoaFramework/ReactiveCocoa/RACStringSequence.m
new file mode 100644
index 0000000..dd10f3c
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACStringSequence.m
@@ -0,0 +1,65 @@
+//
+//  RACStringSequence.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-10-29.
+//  Copyright (c) 2012 GitHub. All rights reserved.
+//
+
+#import "RACStringSequence.h"
+
+@interface RACStringSequence ()
+
+// The string being sequenced.
+@property (nonatomic, copy, readonly) NSString *string;
+
+// The index in the string from which the sequence starts.
+@property (nonatomic, assign, readonly) NSUInteger offset;
+
+@end
+
+@implementation RACStringSequence
+
+#pragma mark Lifecycle
+
++ (RACSequence *)sequenceWithString:(NSString *)string offset:(NSUInteger)offset {
+	NSCParameterAssert(offset <= string.length);
+
+	if (offset == string.length) return self.empty;
+
+	RACStringSequence *seq = [[self alloc] init];
+	seq->_string = [string copy];
+	seq->_offset = offset;
+	return seq;
+}
+
+#pragma mark RACSequence
+
+- (id)head {
+	return [self.string substringWithRange:NSMakeRange(self.offset, 1)];
+}
+
+- (RACSequence *)tail {
+	RACSequence *sequence = [self.class sequenceWithString:self.string offset:self.offset + 1];
+	sequence.name = self.name;
+	return sequence;
+}
+
+- (NSArray *)array {
+	NSUInteger substringLength = self.string.length - self.offset;
+	NSMutableArray *array = [NSMutableArray arrayWithCapacity:substringLength];
+
+	[self.string enumerateSubstringsInRange:NSMakeRange(self.offset, substringLength) options:NSStringEnumerationByComposedCharacterSequences usingBlock:^(NSString *substring, NSRange substringRange, NSRange enclosingRange, BOOL *stop) {
+		[array addObject:substring];
+	}];
+
+	return [array copy];
+}
+
+#pragma mark NSObject
+
+- (NSString *)description {
+	return [NSString stringWithFormat:@"<%@: %p>{ name = %@, string = %@ }", self.class, self, self.name, [self.string substringFromIndex:self.offset]];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSubject.h b/ReactiveCocoaFramework/ReactiveCocoa/RACSubject.h
new file mode 100644
index 0000000..30c100b
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSubject.h
@@ -0,0 +1,22 @@
+//
+//  RACSubject.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 3/9/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSignal.h"
+#import "RACSubscriber.h"
+
+/// A subject can be thought of as a signal that you can manually control by
+/// sending next, completed, and error.
+///
+/// They're most helpful in bridging the non-RAC world to RAC, since they let you
+/// manually control the sending of events.
+@interface RACSubject : RACSignal <RACSubscriber>
+
+/// Returns a new subject.
++ (instancetype)subject;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSubject.m b/ReactiveCocoaFramework/ReactiveCocoa/RACSubject.m
new file mode 100644
index 0000000..fa9ba7d
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSubject.m
@@ -0,0 +1,124 @@
+//
+//  RACSubject.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 3/9/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSubject.h"
+#import "EXTScope.h"
+#import "RACCompoundDisposable.h"
+#import "RACPassthroughSubscriber.h"
+
+@interface RACSubject ()
+
+// Contains all current subscribers to the receiver.
+//
+// This should only be used while synchronized on `self`.
+@property (nonatomic, strong, readonly) NSMutableArray *subscribers;
+
+// Contains all of the receiver's subscriptions to other signals.
+@property (nonatomic, strong, readonly) RACCompoundDisposable *disposable;
+
+// Enumerates over each of the receiver's `subscribers` and invokes `block` for
+// each.
+- (void)enumerateSubscribersUsingBlock:(void (^)(id<RACSubscriber> subscriber))block;
+
+@end
+
+@implementation RACSubject
+
+#pragma mark Lifecycle
+
++ (instancetype)subject {
+	return [[self alloc] init];
+}
+
+- (id)init {
+	self = [super init];
+	if (self == nil) return nil;
+
+	_disposable = [RACCompoundDisposable compoundDisposable];
+	_subscribers = [[NSMutableArray alloc] initWithCapacity:1];
+	
+	return self;
+}
+
+- (void)dealloc {
+	[self.disposable dispose];
+}
+
+#pragma mark Subscription
+
+- (RACDisposable *)subscribe:(id<RACSubscriber>)subscriber {
+	NSCParameterAssert(subscriber != nil);
+
+	RACCompoundDisposable *disposable = [RACCompoundDisposable compoundDisposable];
+	subscriber = [[RACPassthroughSubscriber alloc] initWithSubscriber:subscriber signal:self disposable:disposable];
+
+	NSMutableArray *subscribers = self.subscribers;
+	@synchronized (subscribers) {
+		[subscribers addObject:subscriber];
+	}
+	
+	return [RACDisposable disposableWithBlock:^{
+		@synchronized (subscribers) {
+			// Since newer subscribers are generally shorter-lived, search
+			// starting from the end of the list.
+			NSUInteger index = [subscribers indexOfObjectWithOptions:NSEnumerationReverse passingTest:^ BOOL (id<RACSubscriber> obj, NSUInteger index, BOOL *stop) {
+				return obj == subscriber;
+			}];
+
+			if (index != NSNotFound) [subscribers removeObjectAtIndex:index];
+		}
+	}];
+}
+
+- (void)enumerateSubscribersUsingBlock:(void (^)(id<RACSubscriber> subscriber))block {
+	NSArray *subscribers;
+	@synchronized (self.subscribers) {
+		subscribers = [self.subscribers copy];
+	}
+
+	for (id<RACSubscriber> subscriber in subscribers) {
+		block(subscriber);
+	}
+}
+
+#pragma mark RACSubscriber
+
+- (void)sendNext:(id)value {
+	[self enumerateSubscribersUsingBlock:^(id<RACSubscriber> subscriber) {
+		[subscriber sendNext:value];
+	}];
+}
+
+- (void)sendError:(NSError *)error {
+	[self.disposable dispose];
+	
+	[self enumerateSubscribersUsingBlock:^(id<RACSubscriber> subscriber) {
+		[subscriber sendError:error];
+	}];
+}
+
+- (void)sendCompleted {
+	[self.disposable dispose];
+	
+	[self enumerateSubscribersUsingBlock:^(id<RACSubscriber> subscriber) {
+		[subscriber sendCompleted];
+	}];
+}
+
+- (void)didSubscribeWithDisposable:(RACCompoundDisposable *)d {
+	if (d.disposed) return;
+	[self.disposable addDisposable:d];
+
+	@weakify(self, d);
+	[d addDisposable:[RACDisposable disposableWithBlock:^{
+		@strongify(self, d);
+		[self.disposable removeDisposable:d];
+	}]];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriber+Private.h b/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriber+Private.h
new file mode 100644
index 0000000..0ad81d2
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriber+Private.h
@@ -0,0 +1,17 @@
+//
+//  RACSubscriber+Private.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-06-13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSubscriber.h"
+
+// A simple block-based subscriber.
+@interface RACSubscriber : NSObject <RACSubscriber>
+
+// Creates a new subscriber with the given blocks.
++ (instancetype)subscriberWithNext:(void (^)(id x))next error:(void (^)(NSError *error))error completed:(void (^)(void))completed;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriber.h b/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriber.h
new file mode 100644
index 0000000..173e6dc
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriber.h
@@ -0,0 +1,51 @@
+//
+//  RACSubscriber.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 3/1/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+@class RACCompoundDisposable;
+
+/// Represents any object which can directly receive values from a RACSignal.
+///
+/// You generally shouldn't need to implement this protocol. +[RACSignal
+/// createSignal:], RACSignal's subscription methods, or RACSubject should work
+/// for most uses.
+///
+/// Implementors of this protocol may receive messages and values from multiple
+/// threads simultaneously, and so should be thread-safe. Subscribers will also
+/// be weakly referenced so implementations must allow that.
+@protocol RACSubscriber <NSObject>
+@required
+
+/// Send the next value to subscribers.
+///
+/// value - The value to send. This can be `nil`.
+- (void)sendNext:(id)value;
+
+/// Send the error to subscribers.
+///
+/// error - The error to send. This can be `nil`.
+///
+/// This terminates the subscription, and invalidates the subscriber (such that
+/// it cannot subscribe to anything else in the future).
+- (void)sendError:(NSError *)error;
+
+/// Send completed to subscribers.
+///
+/// This terminates the subscription, and invalidates the subscriber (such that
+/// it cannot subscribe to anything else in the future).
+- (void)sendCompleted;
+
+/// Sends the subscriber a disposable that represents one of its subscriptions.
+///
+/// A subscriber may receive multiple disposables if it gets subscribed to
+/// multiple signals; however, any error or completed events must terminate _all_
+/// subscriptions.
+- (void)didSubscribeWithDisposable:(RACCompoundDisposable *)disposable;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriber.m b/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriber.m
new file mode 100644
index 0000000..b9e83f0
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriber.m
@@ -0,0 +1,108 @@
+//
+//  RACSubscriber.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 3/1/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSubscriber.h"
+#import "RACSubscriber+Private.h"
+#import "EXTScope.h"
+#import "RACCompoundDisposable.h"
+
+@interface RACSubscriber ()
+
+// These callbacks should only be accessed while synchronized on self.
+@property (nonatomic, copy) void (^next)(id value);
+@property (nonatomic, copy) void (^error)(NSError *error);
+@property (nonatomic, copy) void (^completed)(void);
+
+@property (nonatomic, strong, readonly) RACCompoundDisposable *disposable;
+
+@end
+
+@implementation RACSubscriber
+
+#pragma mark Lifecycle
+
++ (instancetype)subscriberWithNext:(void (^)(id x))next error:(void (^)(NSError *error))error completed:(void (^)(void))completed {
+	RACSubscriber *subscriber = [[self alloc] init];
+
+	subscriber->_next = [next copy];
+	subscriber->_error = [error copy];
+	subscriber->_completed = [completed copy];
+
+	return subscriber;
+}
+
+- (id)init {
+	self = [super init];
+	if (self == nil) return nil;
+
+	@weakify(self);
+
+	RACDisposable *selfDisposable = [RACDisposable disposableWithBlock:^{
+		@strongify(self);
+		if (self == nil) return;
+
+		@synchronized (self) {
+			self.next = nil;
+			self.error = nil;
+			self.completed = nil;
+		}
+	}];
+
+	_disposable = [RACCompoundDisposable compoundDisposable];
+	[_disposable addDisposable:selfDisposable];
+	
+	return self;
+}
+
+- (void)dealloc {
+	[self.disposable dispose];
+}
+
+#pragma mark RACSubscriber
+
+- (void)sendNext:(id)value {
+	@synchronized (self) {
+		void (^nextBlock)(id) = [self.next copy];
+		if (nextBlock == nil) return;
+
+		nextBlock(value);
+	}
+}
+
+- (void)sendError:(NSError *)e {
+	@synchronized (self) {
+		void (^errorBlock)(NSError *) = [self.error copy];
+		[self.disposable dispose];
+
+		if (errorBlock == nil) return;
+		errorBlock(e);
+	}
+}
+
+- (void)sendCompleted {
+	@synchronized (self) {
+		void (^completedBlock)(void) = [self.completed copy];
+		[self.disposable dispose];
+
+		if (completedBlock == nil) return;
+		completedBlock();
+	}
+}
+
+- (void)didSubscribeWithDisposable:(RACCompoundDisposable *)d {
+	if (d.disposed) return;
+	[self.disposable addDisposable:d];
+
+	@weakify(self, d);
+	[d addDisposable:[RACDisposable disposableWithBlock:^{
+		@strongify(self, d);
+		[self.disposable removeDisposable:d];
+	}]];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriptingAssignmentTrampoline.h b/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriptingAssignmentTrampoline.h
new file mode 100644
index 0000000..8987731
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriptingAssignmentTrampoline.h
@@ -0,0 +1,54 @@
+//
+//  RACSubscriptingAssignmentTrampoline.h
+//  iOSDemo
+//
+//  Created by Josh Abernathy on 9/24/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "EXTKeyPathCoding.h"
+
+@class RACSignal;
+
+/// Assigns a signal to an object property, automatically setting the given key
+/// path on every `next`. When the signal completes, the binding is automatically
+/// disposed of.
+///
+/// There are two different versions of this macro:
+///
+///  - RAC(TARGET, KEYPATH, NILVALUE) will bind the `KEYPATH` of `TARGET` to the
+///    given signal. If the signal ever sends a `nil` value, the property will be
+///    set to `NILVALUE` instead. `NILVALUE` may itself be `nil` for object
+///    properties, but an NSValue should be used for primitive properties, to
+///    avoid an exception if `nil` is sent (which might occur if an intermediate
+///    object is set to `nil`).
+///  - RAC(TARGET, KEYPATH) is the same as the above, but `NILVALUE` defaults to
+///    `nil`.
+///
+/// See -[RACSignal setKeyPath:onObject:nilValue:] for more information about the
+/// binding's semantics.
+///
+/// Examples
+///
+///  RAC(self, objectProperty) = objectSignal;
+///  RAC(self, stringProperty, @"foobar") = stringSignal;
+///  RAC(self, integerProperty, @42) = integerSignal;
+///
+/// WARNING: Under certain conditions, use of this macro can be thread-unsafe.
+///          See the documentation of -setKeyPath:onObject:nilValue:.
+#define RAC(TARGET, ...) \
+    metamacro_if_eq(1, metamacro_argcount(__VA_ARGS__)) \
+        (RAC_(TARGET, __VA_ARGS__, nil)) \
+        (RAC_(TARGET, __VA_ARGS__))
+
+/// Do not use this directly. Use the RAC macro above.
+#define RAC_(TARGET, KEYPATH, NILVALUE) \
+    [[RACSubscriptingAssignmentTrampoline alloc] initWithTarget:(TARGET) nilValue:(NILVALUE)][@keypath(TARGET, KEYPATH)]
+
+@interface RACSubscriptingAssignmentTrampoline : NSObject
+
+- (id)initWithTarget:(id)target nilValue:(id)nilValue;
+- (void)setObject:(RACSignal *)signal forKeyedSubscript:(NSString *)keyPath;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriptingAssignmentTrampoline.m b/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriptingAssignmentTrampoline.m
new file mode 100644
index 0000000..2ab8cd3
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriptingAssignmentTrampoline.m
@@ -0,0 +1,42 @@
+//
+//  RACSubscriptingAssignmentTrampoline.m
+//  iOSDemo
+//
+//  Created by Josh Abernathy on 9/24/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSubscriptingAssignmentTrampoline.h"
+#import "RACSignal+Operations.h"
+
+@interface RACSubscriptingAssignmentTrampoline ()
+
+// The object to bind to.
+@property (nonatomic, strong, readonly) id target;
+
+// A value to use when `nil` is sent on the bound signal.
+@property (nonatomic, strong, readonly) id nilValue;
+
+@end
+
+@implementation RACSubscriptingAssignmentTrampoline
+
+- (id)initWithTarget:(id)target nilValue:(id)nilValue {
+	// This is often a programmer error, but this prevents crashes if the target
+	// object has unexpectedly deallocated.
+	if (target == nil) return nil;
+
+	self = [super init];
+	if (self == nil) return nil;
+
+	_target = target;
+	_nilValue = nilValue;
+
+	return self;
+}
+
+- (void)setObject:(RACSignal *)signal forKeyedSubscript:(NSString *)keyPath {
+	[signal setKeyPath:keyPath onObject:self.target nilValue:self.nilValue];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriptionScheduler.h b/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriptionScheduler.h
new file mode 100644
index 0000000..34f5dc5
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriptionScheduler.h
@@ -0,0 +1,15 @@
+//
+//  RACSubscriptionScheduler.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 11/30/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACScheduler.h"
+
+// A private scheduler used only for subscriptions. See the private
+// +[RACScheduler subscriptionScheduler] method for more information.
+@interface RACSubscriptionScheduler : RACScheduler
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriptionScheduler.m b/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriptionScheduler.m
new file mode 100644
index 0000000..2aab9c3
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriptionScheduler.m
@@ -0,0 +1,54 @@
+//
+//  RACSubscriptionScheduler.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 11/30/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSubscriptionScheduler.h"
+#import "RACScheduler+Private.h"
+
+@interface RACSubscriptionScheduler ()
+
+// A private background scheduler on which to subscribe if the +currentScheduler
+// is unknown.
+@property (nonatomic, strong, readonly) RACScheduler *backgroundScheduler;
+
+@end
+
+@implementation RACSubscriptionScheduler
+
+#pragma mark Lifecycle
+
+- (id)init {
+	self = [super initWithName:@"com.ReactiveCocoa.RACScheduler.subscriptionScheduler"];
+	if (self == nil) return nil;
+
+	_backgroundScheduler = [RACScheduler scheduler];
+
+	return self;
+}
+
+#pragma mark RACScheduler
+
+- (RACDisposable *)schedule:(void (^)(void))block {
+	NSCParameterAssert(block != NULL);
+
+	if (RACScheduler.currentScheduler == nil) return [self.backgroundScheduler schedule:block];
+
+	block();
+	return nil;
+}
+
+- (RACDisposable *)after:(NSDate *)date schedule:(void (^)(void))block {
+	RACScheduler *scheduler = RACScheduler.currentScheduler ?: self.backgroundScheduler;
+	return [scheduler after:date schedule:block];
+}
+
+- (RACDisposable *)after:(NSDate *)date repeatingEvery:(NSTimeInterval)interval withLeeway:(NSTimeInterval)leeway schedule:(void (^)(void))block {
+	RACScheduler *scheduler = RACScheduler.currentScheduler ?: self.backgroundScheduler;
+	return [scheduler after:date repeatingEvery:interval withLeeway:leeway schedule:block];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACTargetQueueScheduler.h b/ReactiveCocoaFramework/ReactiveCocoa/RACTargetQueueScheduler.h
new file mode 100644
index 0000000..429e595
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACTargetQueueScheduler.h
@@ -0,0 +1,24 @@
+//
+//  RACTargetQueueScheduler.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 6/6/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACQueueScheduler.h"
+
+/// A scheduler that enqueues blocks on a private serial queue, targeting an
+/// arbitrary GCD queue.
+@interface RACTargetQueueScheduler : RACQueueScheduler
+
+/// Initializes the receiver with a serial queue that will target the given
+/// `targetQueue`.
+///
+/// name        - The name of the scheduler. If nil, a default name will be used.
+/// targetQueue - The queue to target. Cannot be NULL.
+///
+/// Returns the initialized object.
+- (id)initWithName:(NSString *)name targetQueue:(dispatch_queue_t)targetQueue;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACTargetQueueScheduler.m b/ReactiveCocoaFramework/ReactiveCocoa/RACTargetQueueScheduler.m
new file mode 100644
index 0000000..65114d3
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACTargetQueueScheduler.m
@@ -0,0 +1,37 @@
+//
+//  RACTargetQueueScheduler.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 6/6/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACTargetQueueScheduler.h"
+#import "RACBacktrace.h"
+#import "RACQueueScheduler+Subclass.h"
+
+@implementation RACTargetQueueScheduler
+
+#pragma mark Lifecycle
+
+- (id)initWithName:(NSString *)name targetQueue:(dispatch_queue_t)targetQueue {
+	NSCParameterAssert(targetQueue != NULL);
+
+	if (name == nil) {
+		name = [NSString stringWithFormat:@"com.ReactiveCocoa.RACTargetQueueScheduler(%s)", dispatch_queue_get_label(targetQueue)];
+	}
+
+	dispatch_queue_t queue = dispatch_queue_create(name.UTF8String, DISPATCH_QUEUE_SERIAL);
+	if (queue == NULL) return nil;
+
+	dispatch_set_target_queue(queue, targetQueue);
+
+	self = [super initWithName:name queue:queue];
+	if (self == nil) return nil;
+
+	dispatch_release(queue);
+
+	return self;
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACTestScheduler.h b/ReactiveCocoaFramework/ReactiveCocoa/RACTestScheduler.h
new file mode 100644
index 0000000..a790f5b
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACTestScheduler.h
@@ -0,0 +1,42 @@
+//
+//  RACTestScheduler.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-07-06.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACScheduler.h"
+
+/// A special kind of scheduler that steps through virtualized time.
+///
+/// This scheduler class can be used in unit tests to verify asynchronous
+/// behaviors without spending significant time waiting.
+///
+/// This class can be used from multiple threads, but only one thread can `step`
+/// through the enqueued actions at a time. Other threads will wait while the
+/// scheduled blocks are being executed.
+@interface RACTestScheduler : RACScheduler
+
+/// Initializes a new test scheduler.
+- (instancetype)init;
+
+/// Executes the next scheduled block, if any.
+///
+/// This method will block until the scheduled action has completed.
+- (void)step;
+
+/// Executes up to the next `ticks` scheduled blocks.
+///
+/// This method will block until the scheduled actions have completed.
+///
+/// ticks - The number of scheduled blocks to execute. If there aren't this many
+///         blocks enqueued, all scheduled blocks are executed.
+- (void)step:(NSUInteger)ticks;
+
+/// Executes all of the scheduled blocks on the receiver.
+///
+/// This method will block until the scheduled actions have completed.
+- (void)stepAll;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACTestScheduler.m b/ReactiveCocoaFramework/ReactiveCocoa/RACTestScheduler.m
new file mode 100644
index 0000000..b6997b2
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACTestScheduler.m
@@ -0,0 +1,223 @@
+//
+//  RACTestScheduler.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-07-06.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACTestScheduler.h"
+#import "EXTScope.h"
+#import "RACCompoundDisposable.h"
+#import "RACDisposable.h"
+#import "RACScheduler+Private.h"
+
+@interface RACTestSchedulerAction : NSObject
+
+// The date at which the action should be executed.
+//
+// This absolute time will not actually be honored. This date is only used for
+// comparison, to determine which block should be run _next_.
+@property (nonatomic, copy, readonly) NSDate *date;
+
+// The scheduled block.
+@property (nonatomic, copy, readonly) void (^block)(void);
+
+// A disposable for this action.
+//
+// When disposed, the action should not start executing if it hasn't already.
+@property (nonatomic, strong, readonly) RACDisposable *disposable;
+
+// Initializes a new scheduler action.
+- (id)initWithDate:(NSDate *)date block:(void (^)(void))block;
+
+@end
+
+static CFComparisonResult RACCompareScheduledActions(const void *ptr1, const void *ptr2, void *info) {
+	RACTestSchedulerAction *action1 = (__bridge id)ptr1;
+	RACTestSchedulerAction *action2 = (__bridge id)ptr2;
+	return CFDateCompare((__bridge CFDateRef)action1.date, (__bridge CFDateRef)action2.date, NULL);
+}
+
+static const void *RACRetainScheduledAction(CFAllocatorRef allocator, const void *ptr) {
+	return CFRetain(ptr);
+}
+
+static void RACReleaseScheduledAction(CFAllocatorRef allocator, const void *ptr) {
+	CFRelease(ptr);
+}
+
+@interface RACTestScheduler ()
+
+// All of the RACTestSchedulerActions that have been enqueued and not yet
+// executed.
+//
+// The minimum value in the heap represents the action to execute next.
+//
+// This property should only be used while synchronized on self.
+@property (nonatomic, assign, readonly) CFBinaryHeapRef scheduledActions;
+
+// The number of blocks that have been directly enqueued with -schedule: so
+// far.
+//
+// This is used to ensure unique dates when two blocks are enqueued
+// simultaneously.
+//
+// This property should only be used while synchronized on self.
+@property (nonatomic, assign) NSUInteger numberOfDirectlyScheduledBlocks;
+
+@end
+
+@implementation RACTestScheduler
+
+#pragma mark Lifecycle
+
+- (instancetype)init {
+	self = [super initWithName:@"com.github.ReactiveCocoa.RACTestScheduler"];
+	if (self == nil) return nil;
+
+	CFBinaryHeapCallBacks callbacks = (CFBinaryHeapCallBacks){
+		.version = 0,
+		.retain = &RACRetainScheduledAction,
+		.release = &RACReleaseScheduledAction,
+		.copyDescription = &CFCopyDescription,
+		.compare = &RACCompareScheduledActions
+	};
+
+	_scheduledActions = CFBinaryHeapCreate(NULL, 0, &callbacks, NULL);
+	return self;
+}
+
+- (void)dealloc {
+	[self stepAll];
+
+	if (_scheduledActions != NULL) {
+		CFRelease(_scheduledActions);
+		_scheduledActions = NULL;
+	}
+}
+
+#pragma mark Execution
+
+- (void)step {
+	[self step:1];
+}
+
+- (void)step:(NSUInteger)ticks {
+	@synchronized (self) {
+		for (NSUInteger i = 0; i < ticks; i++) {
+			const void *actionPtr = NULL;
+			if (!CFBinaryHeapGetMinimumIfPresent(self.scheduledActions, &actionPtr)) break;
+
+			RACTestSchedulerAction *action = (__bridge id)actionPtr;
+			CFBinaryHeapRemoveMinimumValue(self.scheduledActions);
+
+			if (action.disposable.disposed) continue;
+			
+			RACScheduler *previousScheduler = RACScheduler.currentScheduler;
+			NSThread.currentThread.threadDictionary[RACSchedulerCurrentSchedulerKey] = self;
+
+			action.block();
+
+			if (previousScheduler != nil) {
+				NSThread.currentThread.threadDictionary[RACSchedulerCurrentSchedulerKey] = previousScheduler;
+			} else {
+				[NSThread.currentThread.threadDictionary removeObjectForKey:RACSchedulerCurrentSchedulerKey];
+			}
+		}
+	}
+}
+
+- (void)stepAll {
+	[self step:NSUIntegerMax];
+}
+
+#pragma mark RACScheduler
+
+- (RACDisposable *)schedule:(void (^)(void))block {
+	NSCParameterAssert(block != nil);
+
+	@synchronized (self) {
+		NSDate *uniqueDate = [NSDate dateWithTimeIntervalSinceReferenceDate:self.numberOfDirectlyScheduledBlocks];
+		self.numberOfDirectlyScheduledBlocks++;
+
+		RACTestSchedulerAction *action = [[RACTestSchedulerAction alloc] initWithDate:uniqueDate block:block];
+		CFBinaryHeapAddValue(self.scheduledActions, (__bridge void *)action);
+
+		return action.disposable;
+	}
+}
+
+- (RACDisposable *)after:(NSDate *)date schedule:(void (^)(void))block {
+	NSCParameterAssert(date != nil);
+	NSCParameterAssert(block != nil);
+
+	@synchronized (self) {
+		RACTestSchedulerAction *action = [[RACTestSchedulerAction alloc] initWithDate:date block:block];
+		CFBinaryHeapAddValue(self.scheduledActions, (__bridge void *)action);
+
+		return action.disposable;
+	}
+}
+
+- (RACDisposable *)after:(NSDate *)date repeatingEvery:(NSTimeInterval)interval withLeeway:(NSTimeInterval)leeway schedule:(void (^)(void))block {
+	NSCParameterAssert(date != nil);
+	NSCParameterAssert(block != nil);
+	NSCParameterAssert(interval >= 0);
+	NSCParameterAssert(leeway >= 0);
+
+	RACCompoundDisposable *compoundDisposable = [RACCompoundDisposable compoundDisposable];
+
+	@weakify(self);
+	@synchronized (self) {
+		__block RACDisposable *thisDisposable = nil;
+
+		void (^reschedulingBlock)(void) = ^{
+			@strongify(self);
+
+			[compoundDisposable removeDisposable:thisDisposable];
+
+			// Schedule the next interval.
+			RACDisposable *schedulingDisposable = [self after:[date dateByAddingTimeInterval:interval] repeatingEvery:interval withLeeway:leeway schedule:block];
+			[compoundDisposable addDisposable:schedulingDisposable];
+		
+			block();
+		};
+
+		RACTestSchedulerAction *action = [[RACTestSchedulerAction alloc] initWithDate:date block:reschedulingBlock];
+		CFBinaryHeapAddValue(self.scheduledActions, (__bridge void *)action);
+
+		thisDisposable = action.disposable;
+		[compoundDisposable addDisposable:thisDisposable];
+	}
+
+	return compoundDisposable;
+}
+
+@end
+
+@implementation RACTestSchedulerAction
+
+#pragma mark Lifecycle
+
+- (id)initWithDate:(NSDate *)date block:(void (^)(void))block {
+	NSCParameterAssert(date != nil);
+	NSCParameterAssert(block != nil);
+
+	self = [super init];
+	if (self == nil) return nil;
+
+	_date = [date copy];
+	_block = [block copy];
+	_disposable = [[RACDisposable alloc] init];
+
+	return self;
+}
+
+#pragma mark NSObject
+
+- (NSString *)description {
+	return [NSString stringWithFormat:@"<%@: %p>{ date: %@ }", self.class, self, self.date];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACTuple.h b/ReactiveCocoaFramework/ReactiveCocoa/RACTuple.h
new file mode 100644
index 0000000..647b42c
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACTuple.h
@@ -0,0 +1,159 @@
+//
+//  RACTuple.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 4/12/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "metamacros.h"
+
+@class RACSequence;
+
+/// Creates a new tuple with the given values. At least one value must be given.
+/// Values can be nil.
+#define RACTuplePack(...) \
+    RACTuplePack_(__VA_ARGS__)
+
+/// Declares new object variables and unpacks a RACTuple into them.
+///
+/// This macro should be used on the left side of an assignment, with the
+/// tuple on the right side. Nothing else should appear on the same line, and the
+/// macro should not be the only statement in a conditional or loop body.
+///
+/// If the tuple has more values than there are variables listed, the excess
+/// values are ignored.
+///
+/// If the tuple has fewer values than there are variables listed, the excess
+/// variables are initialized to nil.
+///
+/// Examples
+///
+///   RACTupleUnpack(NSString *string, NSNumber *num) = [RACTuple tupleWithObjects:@"foo", @5, nil];
+///   NSLog(@"string: %@", string);
+///   NSLog(@"num: %@", num);
+///
+///   /* The above is equivalent to: */
+///   RACTuple *t = [RACTuple tupleWithObjects:@"foo", @5, nil];
+///   NSString *string = t[0];
+///   NSNumber *num = t[1];
+///   NSLog(@"string: %@", string);
+///   NSLog(@"num: %@", num);
+#define RACTupleUnpack(...) \
+        RACTupleUnpack_(__VA_ARGS__)
+
+/// A sentinel object that represents nils in the tuple.
+///
+/// It should never be necessary to create a tuple nil yourself. Just use
+/// +tupleNil.
+@interface RACTupleNil : NSObject <NSCopying, NSCoding>
+/// A singleton instance.
++ (RACTupleNil *)tupleNil;
+@end
+
+
+/// A tuple is an ordered collection of objects. It may contain nils, represented
+/// by RACTupleNil.
+@interface RACTuple : NSObject <NSCoding, NSCopying, NSFastEnumeration>
+
+@property (nonatomic, readonly) NSUInteger count;
+
+/// These properties all return the object at that index or nil if the number of 
+/// objects is less than the index.
+@property (nonatomic, readonly) id first;
+@property (nonatomic, readonly) id second;
+@property (nonatomic, readonly) id third;
+@property (nonatomic, readonly) id fourth;
+@property (nonatomic, readonly) id fifth;
+@property (nonatomic, readonly) id last;
+
+/// Creates a new tuple out of the array. Does not convert nulls to nils.
++ (instancetype)tupleWithObjectsFromArray:(NSArray *)array;
+
+/// Creates a new tuple out of the array. If `convert` is YES, it also converts
+/// every NSNull to RACTupleNil.
++ (instancetype)tupleWithObjectsFromArray:(NSArray *)array convertNullsToNils:(BOOL)convert;
+
+/// Creates a new tuple with the given objects. Use RACTupleNil to represent
+/// nils.
++ (instancetype)tupleWithObjects:(id)object, ... NS_REQUIRES_NIL_TERMINATION;
+
+/// Returns the object at `index` or nil if the object is a RACTupleNil. Unlike
+/// NSArray and friends, it's perfectly fine to ask for the object at an index
+/// past the tuple's count - 1. It will simply return nil.
+- (id)objectAtIndex:(NSUInteger)index;
+
+/// Returns an array of all the objects. RACTupleNils are converted to NSNulls.
+- (NSArray *)allObjects;
+
+/// Appends `obj` to the receiver.
+///
+/// obj - The object to add to the tuple. This argument may be nil.
+///
+/// Returns a new tuple.
+- (instancetype)tupleByAddingObject:(id)obj;
+
+@end
+
+@interface RACTuple (RACSequenceAdditions)
+
+/// Returns a sequence of all the objects. RACTupleNils are converted to NSNulls.
+@property (nonatomic, copy, readonly) RACSequence *rac_sequence;
+
+@end
+
+@interface RACTuple (ObjectSubscripting)
+/// Returns the object at that index or nil if the number of objects is less
+/// than the index.
+- (id)objectAtIndexedSubscript:(NSUInteger)idx; 
+@end
+
+/// This and everything below is for internal use only.
+///
+/// See RACTuplePack() and RACTupleUnpack() instead.
+#define RACTuplePack_(...) \
+    ([RACTuple tupleWithObjectsFromArray:@[ metamacro_foreach(RACTuplePack_object_or_ractuplenil,, __VA_ARGS__) ]])
+
+#define RACTuplePack_object_or_ractuplenil(INDEX, ARG) \
+    (ARG) ?: RACTupleNil.tupleNil,
+
+#define RACTupleUnpack_(...) \
+    metamacro_foreach(RACTupleUnpack_decl,, __VA_ARGS__) \
+    \
+    int RACTupleUnpack_state = 0; \
+    \
+    RACTupleUnpack_after: \
+        ; \
+        metamacro_foreach(RACTupleUnpack_assign,, __VA_ARGS__) \
+        if (RACTupleUnpack_state != 0) RACTupleUnpack_state = 2; \
+        \
+        while (RACTupleUnpack_state != 2) \
+            if (RACTupleUnpack_state == 1) { \
+                goto RACTupleUnpack_after; \
+            } else \
+                for (; RACTupleUnpack_state != 1; RACTupleUnpack_state = 1) \
+                    [RACTupleUnpackingTrampoline trampoline][ @[ metamacro_foreach(RACTupleUnpack_value,, __VA_ARGS__) ] ]
+
+#define RACTupleUnpack_state metamacro_concat(RACTupleUnpack_state, __LINE__)
+#define RACTupleUnpack_after metamacro_concat(RACTupleUnpack_after, __LINE__)
+#define RACTupleUnpack_loop metamacro_concat(RACTupleUnpack_loop, __LINE__)
+
+#define RACTupleUnpack_decl_name(INDEX) \
+    metamacro_concat(metamacro_concat(RACTupleUnpack, __LINE__), metamacro_concat(_var, INDEX))
+
+#define RACTupleUnpack_decl(INDEX, ARG) \
+    __strong id RACTupleUnpack_decl_name(INDEX);
+
+#define RACTupleUnpack_assign(INDEX, ARG) \
+    __strong ARG = RACTupleUnpack_decl_name(INDEX);
+
+#define RACTupleUnpack_value(INDEX, ARG) \
+    [NSValue valueWithPointer:&RACTupleUnpack_decl_name(INDEX)],
+
+@interface RACTupleUnpackingTrampoline : NSObject
+
++ (instancetype)trampoline;
+- (void)setObject:(RACTuple *)tuple forKeyedSubscript:(NSArray *)variables;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACTuple.m b/ReactiveCocoaFramework/ReactiveCocoa/RACTuple.m
new file mode 100644
index 0000000..9d338db
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACTuple.m
@@ -0,0 +1,252 @@
+//
+//  RACTuple.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 4/12/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACTuple.h"
+#import "EXTKeyPathCoding.h"
+#import "RACTupleSequence.h"
+
+@implementation RACTupleNil
+
++ (RACTupleNil *)tupleNil {
+	static dispatch_once_t onceToken;
+	static RACTupleNil *tupleNil = nil;
+	dispatch_once(&onceToken, ^{
+		tupleNil = [[self alloc] init];
+	});
+	
+	return tupleNil;
+}
+
+#pragma mark NSCopying
+
+- (id)copyWithZone:(NSZone *)zone {
+	return self;
+}
+
+#pragma mark NSCoding
+
+- (id)initWithCoder:(NSCoder *)coder {
+	// Always return the singleton.
+	return self.class.tupleNil;
+}
+
+- (void)encodeWithCoder:(NSCoder *)coder {
+}
+
+@end
+
+
+@interface RACTuple ()
+@property (nonatomic, strong) NSArray *backingArray;
+@end
+
+
+@implementation RACTuple
+
+- (instancetype)init {
+	self = [super init];
+	if (self == nil) return nil;
+	
+	self.backingArray = [NSArray array];
+	
+	return self;
+}
+
+- (NSString *)description {
+	return [NSString stringWithFormat:@"<%@: %p> %@", self.class, self, self.allObjects];
+}
+
+- (BOOL)isEqual:(RACTuple *)object {
+	if (object == self) return YES;
+	if (![object isKindOfClass:self.class]) return NO;
+	
+	return [self.backingArray isEqual:object.backingArray];
+}
+
+- (NSUInteger)hash {
+	return self.backingArray.hash;
+}
+
+
+#pragma mark NSFastEnumeration
+
+- (NSUInteger)countByEnumeratingWithState:(NSFastEnumerationState *)state objects:(id __unsafe_unretained [])buffer count:(NSUInteger)len {
+	return [self.backingArray countByEnumeratingWithState:state objects:buffer count:len];
+}
+
+
+#pragma mark NSCopying
+
+- (instancetype)copyWithZone:(NSZone *)zone {
+	// we're immutable, bitches!
+	return self;
+}
+
+
+#pragma mark NSCoding
+
+- (id)initWithCoder:(NSCoder *)coder {
+	self = [self init];
+	if (self == nil) return nil;
+	
+	self.backingArray = [coder decodeObjectForKey:@keypath(self.backingArray)];
+	return self;
+}
+
+- (void)encodeWithCoder:(NSCoder *)coder {
+	if (self.backingArray != nil) [coder encodeObject:self.backingArray forKey:@keypath(self.backingArray)];
+}
+
+
+#pragma mark API
+
++ (instancetype)tupleWithObjectsFromArray:(NSArray *)array {
+	return [self tupleWithObjectsFromArray:array convertNullsToNils:NO];
+}
+
++ (instancetype)tupleWithObjectsFromArray:(NSArray *)array convertNullsToNils:(BOOL)convert {
+	RACTuple *tuple = [[self alloc] init];
+	
+	if (convert) {
+		NSMutableArray *newArray = [NSMutableArray arrayWithCapacity:array.count];
+		for (id object in array) {
+			[newArray addObject:(object == NSNull.null ? RACTupleNil.tupleNil : object)];
+		}
+		
+		tuple.backingArray = newArray;
+	} else {
+		tuple.backingArray = [array copy];
+	}
+	
+	return tuple;
+}
+
++ (instancetype)tupleWithObjects:(id)object, ... {
+	RACTuple *tuple = [[self alloc] init];
+
+	va_list args;
+	va_start(args, object);
+
+	NSUInteger count = 0;
+	for (id currentObject = object; currentObject != nil; currentObject = va_arg(args, id)) {
+		++count;
+	}
+
+	va_end(args);
+
+	if (count == 0) {
+		tuple.backingArray = @[];
+		return tuple;
+	}
+	
+	NSMutableArray *objects = [[NSMutableArray alloc] initWithCapacity:count];
+	
+	va_start(args, object);
+	for (id currentObject = object; currentObject != nil; currentObject = va_arg(args, id)) {
+		[objects addObject:currentObject];
+	}
+
+	va_end(args);
+	
+	tuple.backingArray = objects;
+	return tuple;
+}
+
+- (id)objectAtIndex:(NSUInteger)index {
+	if (index >= self.count) return nil;
+	
+	id object = [self.backingArray objectAtIndex:index];
+	return (object == RACTupleNil.tupleNil ? nil : object);
+}
+
+- (NSArray *)allObjects {
+	NSMutableArray *newArray = [NSMutableArray arrayWithCapacity:self.backingArray.count];
+	for (id object in self.backingArray) {
+		[newArray addObject:(object == RACTupleNil.tupleNil ? NSNull.null : object)];
+	}
+	
+	return newArray;
+}
+
+- (instancetype)tupleByAddingObject:(id)obj {
+	NSArray *newArray = [self.backingArray arrayByAddingObject:obj ?: RACTupleNil.tupleNil];
+	return [self.class tupleWithObjectsFromArray:newArray convertNullsToNils:NO];
+}
+
+- (NSUInteger)count {
+	return self.backingArray.count;
+}
+
+- (id)first {
+	return [self objectAtIndex:0];
+}
+
+- (id)second {
+	return [self objectAtIndex:1];
+}
+
+- (id)third {
+	return [self objectAtIndex:2];
+}
+
+- (id)fourth {
+	return [self objectAtIndex:3];
+}
+
+- (id)fifth {
+	return [self objectAtIndex:4];
+}
+
+- (id)last {
+	return [self objectAtIndex:self.count - 1];
+}
+
+@end
+
+
+@implementation RACTuple (RACSequenceAdditions)
+
+- (RACSequence *)rac_sequence {
+	return [RACTupleSequence sequenceWithTupleBackingArray:self.backingArray offset:0];
+}
+
+@end
+
+@implementation RACTuple (ObjectSubscripting)
+
+- (id)objectAtIndexedSubscript:(NSUInteger)idx {
+	return [self objectAtIndex:idx];
+}
+
+@end
+
+
+@implementation RACTupleUnpackingTrampoline
+
+#pragma mark Lifecycle
+
++ (instancetype)trampoline {
+	static dispatch_once_t onceToken;
+	static id trampoline = nil;
+	dispatch_once(&onceToken, ^{
+		trampoline = [[self alloc] init];
+	});
+	
+	return trampoline;
+}
+
+- (void)setObject:(RACTuple *)tuple forKeyedSubscript:(NSArray *)variables {
+	NSCParameterAssert(variables != nil);
+	
+	[variables enumerateObjectsUsingBlock:^(NSValue *value, NSUInteger index, BOOL *stop) {
+		__strong id *ptr = (__strong id *)value.pointerValue;
+		*ptr = tuple[index];
+	}];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACTupleSequence.h b/ReactiveCocoaFramework/ReactiveCocoa/RACTupleSequence.h
new file mode 100644
index 0000000..f6cd021
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACTupleSequence.h
@@ -0,0 +1,18 @@
+//
+//  RACTupleSequence.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-05-01.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSequence.h"
+
+// Private class that adapts a RACTuple to the RACSequence interface.
+@interface RACTupleSequence : RACSequence
+
+// Returns a sequence for enumerating over the given backing array (from a
+// RACTuple), starting from the given offset.
++ (instancetype)sequenceWithTupleBackingArray:(NSArray *)backingArray offset:(NSUInteger)offset;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACTupleSequence.m b/ReactiveCocoaFramework/ReactiveCocoa/RACTupleSequence.m
new file mode 100644
index 0000000..ba268f5
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACTupleSequence.m
@@ -0,0 +1,68 @@
+//
+//  RACTupleSequence.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-05-01.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACTupleSequence.h"
+#import "RACTuple.h"
+
+@interface RACTupleSequence ()
+
+// The array being sequenced, as taken from RACTuple.backingArray.
+@property (nonatomic, strong, readonly) NSArray *tupleBackingArray;
+
+// The index in the array from which the sequence starts.
+@property (nonatomic, assign, readonly) NSUInteger offset;
+
+@end
+
+@implementation RACTupleSequence
+
+#pragma mark Lifecycle
+
++ (instancetype)sequenceWithTupleBackingArray:(NSArray *)backingArray offset:(NSUInteger)offset {
+	NSCParameterAssert(offset <= backingArray.count);
+
+	if (offset == backingArray.count) return self.empty;
+
+	RACTupleSequence *seq = [[self alloc] init];
+	seq->_tupleBackingArray = backingArray;
+	seq->_offset = offset;
+	return seq;
+}
+
+#pragma mark RACSequence
+
+- (id)head {
+	id object = [self.tupleBackingArray objectAtIndex:self.offset];
+	return (object == RACTupleNil.tupleNil ? NSNull.null : object);
+}
+
+- (RACSequence *)tail {
+	RACSequence *sequence = [self.class sequenceWithTupleBackingArray:self.tupleBackingArray offset:self.offset + 1];
+	sequence.name = self.name;
+	return sequence;
+}
+
+- (NSArray *)array {
+	NSRange range = NSMakeRange(self.offset, self.tupleBackingArray.count - self.offset);
+	NSMutableArray *array = [[NSMutableArray alloc] initWithCapacity:range.length];
+
+	[self.tupleBackingArray enumerateObjectsAtIndexes:[NSIndexSet indexSetWithIndexesInRange:range] options:0 usingBlock:^(id object, NSUInteger index, BOOL *stop) {
+		id mappedObject = (object == RACTupleNil.tupleNil ? NSNull.null : object);
+		[array addObject:mappedObject];
+	}];
+
+	return array;
+}
+
+#pragma mark NSObject
+
+- (NSString *)description {
+	return [NSString stringWithFormat:@"<%@: %p>{ name = %@, tuple = %@ }", self.class, self, self.name, self.tupleBackingArray];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACUnarySequence.h b/ReactiveCocoaFramework/ReactiveCocoa/RACUnarySequence.h
new file mode 100644
index 0000000..86a514b
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACUnarySequence.h
@@ -0,0 +1,14 @@
+//
+//  RACUnarySequence.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-05-01.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSequence.h"
+
+// Private class representing a sequence of exactly one value.
+@interface RACUnarySequence : RACSequence
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACUnarySequence.m b/ReactiveCocoaFramework/ReactiveCocoa/RACUnarySequence.m
new file mode 100644
index 0000000..f72bf09
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACUnarySequence.m
@@ -0,0 +1,81 @@
+//
+//  RACUnarySequence.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-05-01.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACUnarySequence.h"
+#import "EXTKeyPathCoding.h"
+#import "NSObject+RACDescription.h"
+
+@interface RACUnarySequence ()
+
+// The single value stored in this sequence.
+@property (nonatomic, strong, readwrite) id head;
+
+@end
+
+@implementation RACUnarySequence
+
+#pragma mark Properties
+
+@synthesize head = _head;
+
+#pragma mark Lifecycle
+
++ (instancetype)return:(id)value {
+	RACUnarySequence *sequence = [[self alloc] init];
+	sequence.head = value;
+	return [sequence setNameWithFormat:@"+return: %@", [value rac_description]];
+}
+
+#pragma mark RACSequence
+
+- (RACSequence *)tail {
+	return nil;
+}
+
+- (instancetype)bind:(RACStreamBindBlock (^)(void))block {
+	RACStreamBindBlock bindBlock = block();
+	BOOL stop = NO;
+
+	RACSequence *result = (id)[bindBlock(self.head, &stop) setNameWithFormat:@"[%@] -bind:", self.name];
+	return result ?: self.class.empty;
+}
+
+#pragma mark NSCoding
+
+- (Class)classForCoder {
+	// Unary sequences should be encoded as themselves, not array sequences.
+	return self.class;
+}
+
+- (id)initWithCoder:(NSCoder *)coder {
+	id value = [coder decodeObjectForKey:@keypath(self.head)];
+	return [self.class return:value];
+}
+
+- (void)encodeWithCoder:(NSCoder *)coder {
+	if (self.head != nil) [coder encodeObject:self.head forKey:@keypath(self.head)];
+}
+
+#pragma mark NSObject
+
+- (NSString *)description {
+	return [NSString stringWithFormat:@"<%@: %p>{ name = %@, head = %@ }", self.class, self, self.name, self.head];
+}
+
+- (NSUInteger)hash {
+	return [self.head hash];
+}
+
+- (BOOL)isEqual:(RACUnarySequence *)seq {
+	if (self == seq) return YES;
+	if (![seq isKindOfClass:RACUnarySequence.class]) return NO;
+
+	return self.head == seq.head || [(NSObject *)self.head isEqual:seq.head];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACUnit.h b/ReactiveCocoaFramework/ReactiveCocoa/RACUnit.h
new file mode 100644
index 0000000..7713e1d
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACUnit.h
@@ -0,0 +1,20 @@
+//
+//  RACUnit.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 3/27/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+
+/// A unit represents an empty value.
+///
+/// It should never be necessary to create a unit yourself. Just use +defaultUnit.
+@interface RACUnit : NSObject
+
+/// A singleton instance.
++ (RACUnit *)defaultUnit;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACUnit.m b/ReactiveCocoaFramework/ReactiveCocoa/RACUnit.m
new file mode 100644
index 0000000..76b8425
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACUnit.m
@@ -0,0 +1,27 @@
+//
+//  RACUnit.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 3/27/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACUnit.h"
+
+
+@implementation RACUnit
+
+
+#pragma mark API
+
++ (RACUnit *)defaultUnit {
+	static dispatch_once_t onceToken;
+	static RACUnit *defaultUnit = nil;
+	dispatch_once(&onceToken, ^{
+		defaultUnit = [[self alloc] init];
+	});
+	
+	return defaultUnit;
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACValueTransformer.h b/ReactiveCocoaFramework/ReactiveCocoa/RACValueTransformer.h
new file mode 100644
index 0000000..740b861
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACValueTransformer.h
@@ -0,0 +1,16 @@
+//
+//  RACValueTransformer.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 3/6/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+// A private block based transformer.
+@interface RACValueTransformer : NSValueTransformer
+
++ (instancetype)transformerWithBlock:(id (^)(id value))block;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACValueTransformer.m b/ReactiveCocoaFramework/ReactiveCocoa/RACValueTransformer.m
new file mode 100644
index 0000000..ccec07d
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/RACValueTransformer.m
@@ -0,0 +1,42 @@
+//
+//  RACValueTransformer.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 3/6/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACValueTransformer.h"
+
+@interface RACValueTransformer ()
+@property (nonatomic, copy) id (^transformBlock)(id value);
+@end
+
+
+@implementation RACValueTransformer
+
+
+#pragma mark NSValueTransformer
+
++ (BOOL)allowsReverseTransformation {
+	return NO;
+}
+
+- (id)transformedValue:(id)value {
+    return self.transformBlock(value);
+}
+
+
+#pragma mark API
+
+@synthesize transformBlock;
+
++ (instancetype)transformerWithBlock:(id (^)(id value))block {
+	NSCParameterAssert(block != NULL);
+	
+	RACValueTransformer *transformer = [[self alloc] init];
+	transformer.transformBlock = block;
+	return transformer;
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/ReactiveCocoa-Info.plist b/ReactiveCocoaFramework/ReactiveCocoa/ReactiveCocoa-Info.plist
new file mode 100644
index 0000000..4e63eab
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/ReactiveCocoa-Info.plist
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>English</string>
+	<key>CFBundleExecutable</key>
+	<string>${EXECUTABLE_NAME}</string>
+	<key>CFBundleIconFile</key>
+	<string></string>
+	<key>CFBundleIdentifier</key>
+	<string>com.github.${PRODUCT_NAME:rfc1034identifier}</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>${PRODUCT_NAME}</string>
+	<key>CFBundlePackageType</key>
+	<string>FMWK</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleVersion</key>
+	<string>1</string>
+	<key>NSHumanReadableCopyright</key>
+	<string>Copyright © 2012 GitHub, Inc. All rights reserved.</string>
+	<key>NSPrincipalClass</key>
+	<string></string>
+</dict>
+</plist>
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/ReactiveCocoa-Prefix.pch b/ReactiveCocoaFramework/ReactiveCocoa/ReactiveCocoa-Prefix.pch
new file mode 100644
index 0000000..aa9849d
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/ReactiveCocoa-Prefix.pch
@@ -0,0 +1,13 @@
+//
+// Prefix header for all source files of the 'ReactiveCocoa' target in the 'ReactiveCocoa' project
+//
+
+#ifdef __OBJC__
+	#import <Foundation/Foundation.h>
+#endif
+
+#undef NSAssert
+#undef NSParameterAssert
+
+extern void NSAssert(int condition, ...) __attribute__((unavailable("Use NSCAssert instead.")));
+extern void NSParameterAssert(int condition, ...) __attribute__((unavailable("Use NSCParameterAssert instead.")));
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/ReactiveCocoa.h b/ReactiveCocoaFramework/ReactiveCocoa/ReactiveCocoa.h
new file mode 100644
index 0000000..41f32d9
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/ReactiveCocoa.h
@@ -0,0 +1,74 @@
+//
+//  ReactiveCocoa.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 3/5/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "EXTKeyPathCoding.h"
+#import "NSArray+RACSequenceAdditions.h"
+#import "NSData+RACSupport.h"
+#import "NSDictionary+RACSequenceAdditions.h"
+#import "NSEnumerator+RACSequenceAdditions.h"
+#import "NSFileHandle+RACSupport.h"
+#import "NSNotificationCenter+RACSupport.h"
+#import "NSObject+RACDeallocating.h"
+#import "NSObject+RACLifting.h"
+#import "NSObject+RACPropertySubscribing.h"
+#import "NSObject+RACSelectorSignal.h"
+#import "NSOrderedSet+RACSequenceAdditions.h"
+#import "NSSet+RACSequenceAdditions.h"
+#import "NSString+RACSequenceAdditions.h"
+#import "NSString+RACSupport.h"
+#import "NSIndexSet+RACSequenceAdditions.h"
+#import "NSURLConnection+RACSupport.h"
+#import "NSUserDefaults+RACSupport.h"
+#import "RACBehaviorSubject.h"
+#import "RACChannel.h"
+#import "RACCommand.h"
+#import "RACCompoundDisposable.h"
+#import "RACDisposable.h"
+#import "RACEvent.h"
+#import "RACGroupedSignal.h"
+#import "RACKVOChannel.h"
+#import "RACMulticastConnection.h"
+#import "RACQueueScheduler.h"
+#import "RACReplaySubject.h"
+#import "RACScheduler.h"
+#import "RACScopedDisposable.h"
+#import "RACSequence.h"
+#import "RACSerialDisposable.h"
+#import "RACSignal+Operations.h"
+#import "RACSignal.h"
+#import "RACStream.h"
+#import "RACSubject.h"
+#import "RACSubscriber.h"
+#import "RACSubscriptingAssignmentTrampoline.h"
+#import "RACTargetQueueScheduler.h"
+#import "RACTestScheduler.h"
+#import "RACTuple.h"
+#import "RACUnit.h"
+
+#ifdef __IPHONE_OS_VERSION_MIN_REQUIRED
+	#import "UIActionSheet+RACSignalSupport.h"
+	#import "UIAlertView+RACSignalSupport.h"
+	#import "UIBarButtonItem+RACCommandSupport.h"
+	#import "UIButton+RACCommandSupport.h"
+	#import "UICollectionReusableView+RACSignalSupport.h"
+	#import "UIControl+RACSignalSupport.h"
+	#import "UIDatePicker+RACSignalSupport.h"
+	#import "UIGestureRecognizer+RACSignalSupport.h"
+	#import "UISegmentedControl+RACSignalSupport.h"
+	#import "UISlider+RACSignalSupport.h"
+	#import "UIStepper+RACSignalSupport.h"
+	#import "UISwitch+RACSignalSupport.h"
+	#import "UITableViewCell+RACSignalSupport.h"
+	#import "UITextField+RACSignalSupport.h"
+	#import "UITextView+RACSignalSupport.h"
+#elif TARGET_OS_MAC
+	#import "NSControl+RACCommandSupport.h"
+	#import "NSControl+RACTextSignalSupport.h"
+	#import "NSObject+RACAppKitBindings.h"
+	#import "NSText+RACSignalSupport.h"
+#endif
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIActionSheet+RACSignalSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/UIActionSheet+RACSignalSupport.h
new file mode 100644
index 0000000..3d667e9
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UIActionSheet+RACSignalSupport.h
@@ -0,0 +1,32 @@
+//
+//  UIActionSheet+RACSignalSupport.h
+//  ReactiveCocoa
+//
+//  Created by Dave Lee on 2013-06-22.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <UIKit/UIKit.h>
+
+@class RACDelegateProxy;
+@class RACSignal;
+
+@interface UIActionSheet (RACSignalSupport)
+
+/// A delegate proxy which will be set as the receiver's delegate when any of the
+/// methods in this category are used.
+@property (nonatomic, strong, readonly) RACDelegateProxy *rac_delegateProxy;
+
+/// Creates a signal for button clicks on the receiver.
+///
+/// When this method is invoked, the `rac_delegateProxy` will become the
+/// receiver's delegate. Any previous delegate will become the -[RACDelegateProxy
+/// rac_proxiedDelegate], so that it receives any messages that the proxy doesn't
+/// know how to handle. Setting the receiver's `delegate` afterward is
+/// considered undefined behavior.
+///
+/// Returns a signal which will send the index of the specific button clicked.
+/// The signal will complete when the receiver is deallocated.
+- (RACSignal *)rac_buttonClickedSignal;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIActionSheet+RACSignalSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/UIActionSheet+RACSignalSupport.m
new file mode 100644
index 0000000..6198797
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UIActionSheet+RACSignalSupport.m
@@ -0,0 +1,50 @@
+//
+//  UIActionSheet+RACSignalSupport.m
+//  ReactiveCocoa
+//
+//  Created by Dave Lee on 2013-06-22.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "UIActionSheet+RACSignalSupport.h"
+#import "RACDelegateProxy.h"
+#import "RACSignal+Operations.h"
+#import "NSObject+RACDeallocating.h"
+#import "RACTuple.h"
+#import "NSObject+RACDescription.h"
+#import <objc/runtime.h>
+
+@implementation UIActionSheet (RACSignalSupport)
+
+static void RACUseDelegateProxy(UIActionSheet *self) {
+    if (self.delegate == self.rac_delegateProxy) return;
+
+    self.rac_delegateProxy.rac_proxiedDelegate = self.delegate;
+    self.delegate = (id)self.rac_delegateProxy;
+}
+
+- (RACDelegateProxy *)rac_delegateProxy {
+	RACDelegateProxy *proxy = objc_getAssociatedObject(self, _cmd);
+	if (proxy == nil) {
+		proxy = [[RACDelegateProxy alloc] initWithProtocol:@protocol(UIActionSheetDelegate)];
+		objc_setAssociatedObject(self, _cmd, proxy, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+	}
+
+	return proxy;
+}
+
+- (RACSignal *)rac_buttonClickedSignal {
+	RACSignal *signal = [[[[self.rac_delegateProxy
+		signalForSelector:@selector(actionSheet:clickedButtonAtIndex:)]
+		reduceEach:^(UIActionSheet *actionSheet, NSNumber *buttonIndex) {
+			return buttonIndex;
+		}]
+		takeUntil:self.rac_willDeallocSignal]
+		setNameWithFormat:@"%@ -rac_buttonClickedSignal", [self rac_description]];
+
+	RACUseDelegateProxy(self);
+
+	return signal;
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIAlertView+RACSignalSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/UIAlertView+RACSignalSupport.h
new file mode 100644
index 0000000..4586460
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UIAlertView+RACSignalSupport.h
@@ -0,0 +1,32 @@
+//
+//  UIAlertView+RACSignalSupport.h
+//  ReactiveCocoa
+//
+//  Created by Henrik Hodne on 6/16/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <UIKit/UIKit.h>
+
+@class RACDelegateProxy;
+@class RACSignal;
+
+@interface UIAlertView (RACSignalSupport)
+
+/// A delegate proxy which will be set as the receiver's delegate when any of the
+/// methods in this category are used.
+@property (nonatomic, strong, readonly) RACDelegateProxy *rac_delegateProxy;
+
+/// Creates a signal for button clicks on the receiver.
+///
+/// When this method is invoked, the `rac_delegateProxy` will become the
+/// receiver's delegate. Any previous delegate will become the -[RACDelegateProxy
+/// rac_proxiedDelegate], so that it receives any messages that the proxy doesn't
+/// know how to handle. Setting the receiver's `delegate` afterward is considered
+/// undefined behavior.
+///
+/// Returns a signal which will send the index of the specific button clicked.
+/// The signal will complete itself when the receiver is deallocated.
+- (RACSignal *)rac_buttonClickedSignal;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIAlertView+RACSignalSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/UIAlertView+RACSignalSupport.m
new file mode 100644
index 0000000..bf15b27
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UIAlertView+RACSignalSupport.m
@@ -0,0 +1,50 @@
+//
+//  UIAlertView+RACSignalSupport.m
+//  ReactiveCocoa
+//
+//  Created by Henrik Hodne on 6/16/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "UIAlertView+RACSignalSupport.h"
+#import "RACDelegateProxy.h"
+#import "RACSignal+Operations.h"
+#import "NSObject+RACDeallocating.h"
+#import "NSObject+RACDescription.h"
+#import "RACTuple.h"
+#import <objc/runtime.h>
+
+@implementation UIAlertView (RACSignalSupport)
+
+static void RACUseDelegateProxy(UIAlertView *self) {
+	if (self.delegate == self.rac_delegateProxy) return;
+
+	self.rac_delegateProxy.rac_proxiedDelegate = self.delegate;
+	self.delegate = (id)self.rac_delegateProxy;
+}
+
+- (RACDelegateProxy *)rac_delegateProxy {
+	RACDelegateProxy *proxy = objc_getAssociatedObject(self, _cmd);
+	if (proxy == nil) {
+		proxy = [[RACDelegateProxy alloc] initWithProtocol:@protocol(UIAlertViewDelegate)];
+		objc_setAssociatedObject(self, _cmd, proxy, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+	}
+
+	return proxy;
+}
+
+- (RACSignal *)rac_buttonClickedSignal {
+	RACSignal *signal = [[[[self.rac_delegateProxy
+		signalForSelector:@selector(alertView:clickedButtonAtIndex:)]
+		reduceEach:^(UIAlertView *alertView, NSNumber *buttonIndex) {
+			return buttonIndex;
+		}]
+		takeUntil:self.rac_willDeallocSignal]
+		setNameWithFormat:@"%@ -rac_buttonClickedSignal", [self rac_description]];
+
+	RACUseDelegateProxy(self);
+
+	return signal;
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIBarButtonItem+RACCommandSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/UIBarButtonItem+RACCommandSupport.h
new file mode 100644
index 0000000..c04648a
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UIBarButtonItem+RACCommandSupport.h
@@ -0,0 +1,22 @@
+//
+//  UIBarButtonItem+RACCommandSupport.h
+//  ReactiveCocoa
+//
+//  Created by Kyle LeNeau on 3/27/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <UIKit/UIKit.h>
+
+@class RACCommand;
+
+@interface UIBarButtonItem (RACCommandSupport)
+
+/// Sets the control's command. When the control is clicked, the command is
+/// executed with the sender of the event. The control's enabledness is bound
+/// to the command's `canExecute`.
+///
+/// Note: this will reset the control's target and action.
+@property (nonatomic, strong) RACCommand *rac_command;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIBarButtonItem+RACCommandSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/UIBarButtonItem+RACCommandSupport.m
new file mode 100644
index 0000000..91b7d19
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UIBarButtonItem+RACCommandSupport.m
@@ -0,0 +1,55 @@
+//
+//  UIBarButtonItem+RACCommandSupport.m
+//  ReactiveCocoa
+//
+//  Created by Kyle LeNeau on 3/27/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "UIBarButtonItem+RACCommandSupport.h"
+#import "EXTKeyPathCoding.h"
+#import "NSObject+RACPropertySubscribing.h"
+#import "RACCommand.h"
+#import "RACDisposable.h"
+#import "RACSignal+Operations.h"
+#import <objc/runtime.h>
+
+static void *UIControlRACCommandKey = &UIControlRACCommandKey;
+static void *UIControlEnabledDisposableKey = &UIControlEnabledDisposableKey;
+
+@implementation UIBarButtonItem (RACCommandSupport)
+
+- (RACCommand *)rac_command {
+	return objc_getAssociatedObject(self, UIControlRACCommandKey);
+}
+
+- (void)setRac_command:(RACCommand *)command {
+	objc_setAssociatedObject(self, UIControlRACCommandKey, command, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+	
+	// Check for stored signal in order to remove it and add a new one
+	RACDisposable *disposable = objc_getAssociatedObject(self, UIControlEnabledDisposableKey);
+	[disposable dispose];
+	
+	if (command == nil) return;
+	
+	disposable = [command.enabled setKeyPath:@keypath(self.enabled) onObject:self];
+	objc_setAssociatedObject(self, UIControlEnabledDisposableKey, disposable, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+	
+	[self rac_hijackActionAndTargetIfNeeded];
+}
+
+- (void)rac_hijackActionAndTargetIfNeeded {
+	SEL hijackSelector = @selector(rac_commandPerformAction:);
+	if (self.target == self && self.action == hijackSelector) return;
+	
+	if (self.target != nil) NSLog(@"WARNING: UIBarButtonItem.rac_command hijacks the control's existing target and action.");
+	
+	self.target = self;
+	self.action = hijackSelector;
+}
+
+- (void)rac_commandPerformAction:(id)sender {
+	[self.rac_command execute:sender];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIButton+RACCommandSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/UIButton+RACCommandSupport.h
new file mode 100644
index 0000000..642ba8e
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UIButton+RACCommandSupport.h
@@ -0,0 +1,20 @@
+//
+//  UIButton+RACCommandSupport.h
+//  ReactiveCocoa
+//
+//  Created by Ash Furrow on 2013-06-06.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <UIKit/UIKit.h>
+
+@class RACCommand;
+
+@interface UIButton (RACCommandSupport)
+
+/// Sets the button's command. When the button is clicked, the command is
+/// executed with the sender of the event. The button's enabledness is bound
+/// to the command's `canExecute`.
+@property (nonatomic, strong) RACCommand *rac_command;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIButton+RACCommandSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/UIButton+RACCommandSupport.m
new file mode 100644
index 0000000..2f5f1a0
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UIButton+RACCommandSupport.m
@@ -0,0 +1,57 @@
+//
+//  UIButton+RACCommandSupport.m
+//  ReactiveCocoa
+//
+//  Created by Ash Furrow on 2013-06-06.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "UIButton+RACCommandSupport.h"
+#import "EXTKeyPathCoding.h"
+#import "NSObject+RACPropertySubscribing.h"
+#import "RACCommand.h"
+#import "RACDisposable.h"
+#import "RACSignal+Operations.h"
+#import <objc/runtime.h>
+
+static void *UIButtonRACCommandKey = &UIButtonRACCommandKey;
+static void *UIButtonEnabledDisposableKey = &UIButtonEnabledDisposableKey;
+
+@implementation UIButton (RACCommandSupport)
+
+- (RACCommand *)rac_command {
+	return objc_getAssociatedObject(self, UIButtonRACCommandKey);
+}
+
+- (void)setRac_command:(RACCommand *)command {
+	objc_setAssociatedObject(self, UIButtonRACCommandKey, command, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+	
+	// Check for stored signal in order to remove it and add a new one
+	RACDisposable *disposable = objc_getAssociatedObject(self, UIButtonEnabledDisposableKey);
+	[disposable dispose];
+	
+	if (command == nil) return;
+	
+	disposable = [command.enabled setKeyPath:@keypath(self.enabled) onObject:self];
+	objc_setAssociatedObject(self, UIButtonEnabledDisposableKey, disposable, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+	
+	[self rac_hijackActionAndTargetIfNeeded];
+}
+
+- (void)rac_hijackActionAndTargetIfNeeded {
+	SEL hijackSelector = @selector(rac_commandPerformAction:);
+	
+	for (NSString *selector in [self actionsForTarget:self forControlEvent:UIControlEventTouchUpInside]) {
+		if (hijackSelector == NSSelectorFromString(selector)) {
+			return;
+		}
+	}
+	
+	[self addTarget:self action:hijackSelector forControlEvents:UIControlEventTouchUpInside];
+}
+
+- (void)rac_commandPerformAction:(id)sender {
+	[self.rac_command execute:sender];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UICollectionReusableView+RACSignalSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/UICollectionReusableView+RACSignalSupport.h
new file mode 100644
index 0000000..96b3dfe
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UICollectionReusableView+RACSignalSupport.h
@@ -0,0 +1,29 @@
+//
+//  UICollectionReusableView+RACSignalSupport.h
+//  ReactiveCocoa
+//
+//  Created by Kent Wong on 2013-10-04.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <UIKit/UIKit.h>
+
+@class RACSignal;
+
+// This category is only applicable to iOS >= 6.0.
+@interface UICollectionReusableView (RACSignalSupport)
+
+/// A signal which will send a RACUnit whenever -prepareForReuse is invoked upon
+/// the receiver.
+///
+/// Examples
+///
+///  [[[self.cancelButton
+///     rac_signalForControlEvents:UIControlEventTouchUpInside]
+///     takeUntil:self.rac_prepareForReuseSignal]
+///     subscribeNext:^(UIButton *x) {
+///         // do other things
+///     }];
+@property (nonatomic, strong, readonly) RACSignal *rac_prepareForReuseSignal;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UICollectionReusableView+RACSignalSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/UICollectionReusableView+RACSignalSupport.m
new file mode 100644
index 0000000..7e8680c
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UICollectionReusableView+RACSignalSupport.m
@@ -0,0 +1,31 @@
+//
+//  UICollectionReusableView+RACSignalSupport.m
+//  ReactiveCocoa
+//
+//  Created by Kent Wong on 2013-10-04.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "UICollectionReusableView+RACSignalSupport.h"
+#import "NSObject+RACDescription.h"
+#import "NSObject+RACSelectorSignal.h"
+#import "RACSignal+Operations.h"
+#import "RACUnit.h"
+#import <objc/runtime.h>
+
+@implementation UICollectionReusableView (RACSignalSupport)
+
+- (RACSignal *)rac_prepareForReuseSignal {
+	RACSignal *signal = objc_getAssociatedObject(self, _cmd);
+	if (signal != nil) return signal;
+	
+	signal = [[[self
+		rac_signalForSelector:@selector(prepareForReuse)]
+		mapReplace:RACUnit.defaultUnit]
+		setNameWithFormat:@"%@ -rac_prepareForReuseSignal", self.rac_description];
+	
+	objc_setAssociatedObject(self, _cmd, signal, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+	return signal;
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIControl+RACSignalSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/UIControl+RACSignalSupport.h
new file mode 100644
index 0000000..2de86cf
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UIControl+RACSignalSupport.h
@@ -0,0 +1,19 @@
+//
+//  UIControl+RACSignalSupport.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 4/17/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import <UIKit/UIKit.h>
+
+@class RACSignal;
+
+@interface UIControl (RACSignalSupport)
+
+/// Creates and returns a signal that sends the sender of the control event
+/// whenever one of the control events is triggered.
+- (RACSignal *)rac_signalForControlEvents:(UIControlEvents)controlEvents;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIControl+RACSignalSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/UIControl+RACSignalSupport.m
new file mode 100644
index 0000000..9e818ca
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UIControl+RACSignalSupport.m
@@ -0,0 +1,41 @@
+//
+//  UIControl+RACSignalSupport.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 4/17/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "UIControl+RACSignalSupport.h"
+#import "EXTScope.h"
+#import "RACCompoundDisposable.h"
+#import "RACDisposable.h"
+#import "RACSignal.h"
+#import "RACSignal+Operations.h"
+#import "RACSubscriber+Private.h"
+#import "NSObject+RACDeallocating.h"
+#import "NSObject+RACDescription.h"
+
+@implementation UIControl (RACSignalSupport)
+
+- (RACSignal *)rac_signalForControlEvents:(UIControlEvents)controlEvents {
+	@weakify(self);
+
+	return [[RACSignal
+		createSignal:^(id<RACSubscriber> subscriber) {
+			@strongify(self);
+
+			[self addTarget:subscriber action:@selector(sendNext:) forControlEvents:controlEvents];
+			[self.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				[subscriber sendCompleted];
+			}]];
+
+			return [RACDisposable disposableWithBlock:^{
+				@strongify(self);
+				[self removeTarget:subscriber action:@selector(sendNext:) forControlEvents:controlEvents];
+			}];
+		}]
+		setNameWithFormat:@"%@ -rac_signalForControlEvents: %lx", [self rac_description], (unsigned long)controlEvents];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIControl+RACSignalSupportPrivate.h b/ReactiveCocoaFramework/ReactiveCocoa/UIControl+RACSignalSupportPrivate.h
new file mode 100644
index 0000000..7f778a4
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UIControl+RACSignalSupportPrivate.h
@@ -0,0 +1,29 @@
+//
+//  UIControl+RACSignalSupportPrivate.h
+//  ReactiveCocoa
+//
+//  Created by Uri Baghin on 06/08/2013.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <UIKit/UIKit.h>
+
+@class RACChannelTerminal;
+
+@interface UIControl (RACSignalSupportPrivate)
+
+// Adds a RACChannel-based interface to the receiver for the given
+// UIControlEvents and exposes it.
+//
+// controlEvents - A mask of UIControlEvents on which to send new values.
+// key           - The key whose value should be read and set when a control
+//                 event fires and when a value is sent to the
+//                 RACChannelTerminal respectively.
+// nilValue      - The value to be assigned to the key when `nil` is sent to the
+//                 RACChannelTerminal.
+//
+// Returns a RACChannelTerminal which will send future values from the receiver,
+// and update the receiver when values are sent to the terminal.
+- (RACChannelTerminal *)rac_channelForControlEvents:(UIControlEvents)controlEvents key:(NSString *)key nilValue:(id)nilValue;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIControl+RACSignalSupportPrivate.m b/ReactiveCocoaFramework/ReactiveCocoa/UIControl+RACSignalSupportPrivate.m
new file mode 100644
index 0000000..b73f817
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UIControl+RACSignalSupportPrivate.m
@@ -0,0 +1,50 @@
+//
+//  UIControl+RACSignalSupportPrivate.m
+//  ReactiveCocoa
+//
+//  Created by Uri Baghin on 06/08/2013.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "UIControl+RACSignalSupportPrivate.h"
+#import "EXTScope.h"
+#import "NSInvocation+RACTypeParsing.h"
+#import "NSObject+RACDeallocating.h"
+#import "NSObject+RACLifting.h"
+#import "RACChannel.h"
+#import "RACCompoundDisposable.h"
+#import "RACDisposable.h"
+#import "RACSignal+Operations.h"
+#import "UIControl+RACSignalSupport.h"
+
+@implementation UIControl (RACSignalSupportPrivate)
+
+- (RACChannelTerminal *)rac_channelForControlEvents:(UIControlEvents)controlEvents key:(NSString *)key nilValue:(id)nilValue {
+	NSCParameterAssert(key.length > 0);
+	key = [key copy];
+	RACChannel *channel = [[RACChannel alloc] init];
+
+	[self.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+		[channel.followingTerminal sendCompleted];
+	}]];
+
+	RACSignal *eventSignal = [[[self
+		rac_signalForControlEvents:controlEvents]
+		mapReplace:key]
+		takeUntil:[[channel.followingTerminal
+			ignoreValues]
+			catchTo:RACSignal.empty]];
+	[[self
+		rac_liftSelector:@selector(valueForKey:) withSignals:eventSignal, nil]
+		subscribe:channel.followingTerminal];
+
+	RACSignal *valuesSignal = [channel.followingTerminal
+		map:^(id value) {
+			return value ?: nilValue;
+		}];
+	[self rac_liftSelector:@selector(setValue:forKey:) withSignals:valuesSignal, [RACSignal return:key], nil];
+
+	return channel.leadingTerminal;
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIDatePicker+RACSignalSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/UIDatePicker+RACSignalSupport.h
new file mode 100644
index 0000000..e620dfc
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UIDatePicker+RACSignalSupport.h
@@ -0,0 +1,24 @@
+//
+//  UIDatePicker+RACSignalSupport.h
+//  ReactiveCocoa
+//
+//  Created by Uri Baghin on 20/07/2013.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <UIKit/UIKit.h>
+
+@class RACChannelTerminal;
+
+@interface UIDatePicker (RACSignalSupport)
+
+/// Creates a new RACChannel-based binding to the receiver.
+///
+/// nilValue - The date to set when the terminal receives `nil`.
+///
+/// Returns a RACChannelTerminal that sends the receiver's date whenever the
+/// UIControlEventValueChanged control event is fired, and sets the date to the
+/// values it receives.
+- (RACChannelTerminal *)rac_newDateChannelWithNilValue:(NSDate *)nilValue;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIDatePicker+RACSignalSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/UIDatePicker+RACSignalSupport.m
new file mode 100644
index 0000000..fbae59c
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UIDatePicker+RACSignalSupport.m
@@ -0,0 +1,20 @@
+//
+//  UIDatePicker+RACSignalSupport.m
+//  ReactiveCocoa
+//
+//  Created by Uri Baghin on 20/07/2013.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "UIDatePicker+RACSignalSupport.h"
+#import "EXTKeyPathCoding.h"
+#import "UIControl+RACSignalSupport.h"
+#import "UIControl+RACSignalSupportPrivate.h"
+
+@implementation UIDatePicker (RACSignalSupport)
+
+- (RACChannelTerminal *)rac_newDateChannelWithNilValue:(NSDate *)nilValue {
+	return [self rac_channelForControlEvents:UIControlEventValueChanged key:@keypath(self.date) nilValue:nilValue];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIGestureRecognizer+RACSignalSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/UIGestureRecognizer+RACSignalSupport.h
new file mode 100644
index 0000000..ee774fe
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UIGestureRecognizer+RACSignalSupport.h
@@ -0,0 +1,18 @@
+//
+//  UIGestureRecognizer+RACSignalSupport.h
+//  Talks
+//
+//  Created by Josh Vera on 5/5/13.
+//  Copyright (c) 2013 GitHub. All rights reserved.
+//
+
+#import <UIKit/UIKit.h>
+
+@class RACSignal;
+
+@interface UIGestureRecognizer (RACSignalSupport)
+
+/// Returns a signal that sends the receiver when its gesture occurs.
+- (RACSignal *)rac_gestureSignal;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIGestureRecognizer+RACSignalSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/UIGestureRecognizer+RACSignalSupport.m
new file mode 100644
index 0000000..afd5127
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UIGestureRecognizer+RACSignalSupport.m
@@ -0,0 +1,40 @@
+//
+//  UIGestureRecognizer+RACSignalSupport.m
+//  Talks
+//
+//  Created by Josh Vera on 5/5/13.
+//  Copyright (c) 2013 GitHub. All rights reserved.
+//
+
+#import "UIGestureRecognizer+RACSignalSupport.h"
+#import "EXTScope.h"
+#import "NSObject+RACDeallocating.h"
+#import "RACCompoundDisposable.h"
+#import "RACDisposable.h"
+#import "RACSignal.h"
+#import "RACSubscriber.h"
+#import "NSObject+RACDescription.h"
+
+@implementation UIGestureRecognizer (RACSignalSupport)
+
+- (RACSignal *)rac_gestureSignal {
+	@weakify(self);
+
+	return [[RACSignal
+		createSignal:^(id<RACSubscriber> subscriber) {
+			@strongify(self);
+
+			[self addTarget:subscriber action:@selector(sendNext:)];
+			[self.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				[subscriber sendCompleted];
+			}]];
+
+			return [RACDisposable disposableWithBlock:^{
+				@strongify(self);
+				[self removeTarget:subscriber action:@selector(sendNext:)];
+			}];
+		}]
+		setNameWithFormat:@"%@ -rac_gestureSignal", [self rac_description]];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIRefreshControl+RACCommandSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/UIRefreshControl+RACCommandSupport.h
new file mode 100644
index 0000000..0bd1bf1
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UIRefreshControl+RACCommandSupport.h
@@ -0,0 +1,22 @@
+//
+//  UIRefreshControl+RACCommandSupport.h
+//  ReactiveCocoa
+//
+//  Created by Dave Lee on 2013-10-17.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <UIKit/UIKit.h>
+
+@class RACCommand;
+
+@interface UIRefreshControl (RACCommandSupport)
+
+/// Manipulate the RACCommand property associated with this refresh control.
+///
+/// When this refresh control is activated by the user, the command will be
+/// executed. Upon completion or error of the execution signal, -endRefreshing
+/// will be invoked.
+@property (nonatomic, strong) RACCommand *rac_command;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIRefreshControl+RACCommandSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/UIRefreshControl+RACCommandSupport.m
new file mode 100644
index 0000000..9447f3e
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UIRefreshControl+RACCommandSupport.m
@@ -0,0 +1,59 @@
+//
+//  UIRefreshControl+RACCommandSupport.m
+//  ReactiveCocoa
+//
+//  Created by Dave Lee on 2013-10-17.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "UIRefreshControl+RACCommandSupport.h"
+#import "EXTKeyPathCoding.h"
+#import "NSObject+RACSelectorSignal.h"
+#import "RACDisposable.h"
+#import "RACCommand.h"
+#import "RACCompoundDisposable.h"
+#import "RACSignal.h"
+#import "RACSignal+Operations.h"
+#import "UIControl+RACSignalSupport.h"
+#import <objc/runtime.h>
+
+static void *UIRefreshControlRACCommandKey = &UIRefreshControlRACCommandKey;
+static void *UIRefreshControlDisposableKey = &UIRefreshControlDisposableKey;
+
+@implementation UIRefreshControl (RACCommandSupport)
+
+- (RACCommand *)rac_command {
+	return objc_getAssociatedObject(self, UIRefreshControlRACCommandKey);
+}
+
+- (void)setRac_command:(RACCommand *)command {
+	objc_setAssociatedObject(self, UIRefreshControlRACCommandKey, command, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+
+	// Dispose of any active command associations.
+	[objc_getAssociatedObject(self, UIRefreshControlDisposableKey) dispose];
+
+	if (command == nil) return;
+
+	// Like RAC(self, enabled) = command.enabled; but with access to disposable.
+	RACDisposable *enabledDisposable = [command.enabled setKeyPath:@keypath(self.enabled) onObject:self];
+
+	RACDisposable *executionDisposable = [[[[self
+		rac_signalForControlEvents:UIControlEventValueChanged]
+		map:^(UIRefreshControl *x) {
+			return [[[command
+				execute:x]
+				catchTo:[RACSignal empty]]
+				then:^{
+					return [RACSignal return:x];
+				}];
+		}]
+		concat]
+		subscribeNext:^(UIRefreshControl *x) {
+			[x endRefreshing];
+		}];
+
+	RACDisposable *commandDisposable = [RACCompoundDisposable compoundDisposableWithDisposables:@[ enabledDisposable, executionDisposable ]];
+	objc_setAssociatedObject(self, UIRefreshControlDisposableKey, commandDisposable, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UISegmentedControl+RACSignalSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/UISegmentedControl+RACSignalSupport.h
new file mode 100644
index 0000000..2d3c3e7
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UISegmentedControl+RACSignalSupport.h
@@ -0,0 +1,24 @@
+//
+//  UISegmentedControl+RACSignalSupport.h
+//  ReactiveCocoa
+//
+//  Created by Uri Baghin on 20/07/2013.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <UIKit/UIKit.h>
+
+@class RACChannelTerminal;
+
+@interface UISegmentedControl (RACSignalSupport)
+
+/// Creates a new RACChannel-based binding to the receiver.
+///
+/// nilValue - The segment to select when the terminal receives `nil`.
+///
+/// Returns a RACChannelTerminal that sends the receiver's currently selected
+/// segment's index whenever the UIControlEventValueChanged control event is
+/// fired, and sets the selected segment index to the values it receives.
+- (RACChannelTerminal *)rac_newSelectedSegmentIndexChannelWithNilValue:(NSNumber *)nilValue;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UISegmentedControl+RACSignalSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/UISegmentedControl+RACSignalSupport.m
new file mode 100644
index 0000000..9ccea2b
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UISegmentedControl+RACSignalSupport.m
@@ -0,0 +1,20 @@
+//
+//  UISegmentedControl+RACSignalSupport.m
+//  ReactiveCocoa
+//
+//  Created by Uri Baghin on 20/07/2013.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "UISegmentedControl+RACSignalSupport.h"
+#import "EXTKeyPathCoding.h"
+#import "UIControl+RACSignalSupport.h"
+#import "UIControl+RACSignalSupportPrivate.h"
+
+@implementation UISegmentedControl (RACSignalSupport)
+
+- (RACChannelTerminal *)rac_newSelectedSegmentIndexChannelWithNilValue:(NSNumber *)nilValue {
+	return [self rac_channelForControlEvents:UIControlEventValueChanged key:@keypath(self.selectedSegmentIndex) nilValue:nilValue];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UISlider+RACSignalSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/UISlider+RACSignalSupport.h
new file mode 100644
index 0000000..75626ad
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UISlider+RACSignalSupport.h
@@ -0,0 +1,24 @@
+//
+//  UISlider+RACSignalSupport.h
+//  ReactiveCocoa
+//
+//  Created by Uri Baghin on 20/07/2013.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <UIKit/UIKit.h>
+
+@class RACChannelTerminal;
+
+@interface UISlider (RACSignalSupport)
+
+/// Creates a new RACChannel-based binding to the receiver.
+///
+/// nilValue - The value to set when the terminal receives `nil`.
+///
+/// Returns a RACChannelTerminal that sends the receiver's value whenever the
+/// UIControlEventValueChanged control event is fired, and sets the value to the
+/// values it receives.
+- (RACChannelTerminal *)rac_newValueChannelWithNilValue:(NSNumber *)nilValue;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UISlider+RACSignalSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/UISlider+RACSignalSupport.m
new file mode 100644
index 0000000..2d37a3b
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UISlider+RACSignalSupport.m
@@ -0,0 +1,20 @@
+//
+//  UISlider+RACSignalSupport.m
+//  ReactiveCocoa
+//
+//  Created by Uri Baghin on 20/07/2013.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "UISlider+RACSignalSupport.h"
+#import "EXTKeyPathCoding.h"
+#import "UIControl+RACSignalSupport.h"
+#import "UIControl+RACSignalSupportPrivate.h"
+
+@implementation UISlider (RACSignalSupport)
+
+- (RACChannelTerminal *)rac_newValueChannelWithNilValue:(NSNumber *)nilValue {
+	return [self rac_channelForControlEvents:UIControlEventValueChanged key:@keypath(self.value) nilValue:nilValue];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIStepper+RACSignalSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/UIStepper+RACSignalSupport.h
new file mode 100644
index 0000000..da6d97b
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UIStepper+RACSignalSupport.h
@@ -0,0 +1,24 @@
+//
+//  UIStepper+RACSignalSupport.h
+//  ReactiveCocoa
+//
+//  Created by Uri Baghin on 20/07/2013.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <UIKit/UIKit.h>
+
+@class RACChannelTerminal;
+
+@interface UIStepper (RACSignalSupport)
+
+/// Creates a new RACChannel-based binding to the receiver.
+///
+/// nilValue - The value to set when the terminal receives `nil`.
+///
+/// Returns a RACChannelTerminal that sends the receiver's value whenever the
+/// UIControlEventValueChanged control event is fired, and sets the value to the
+/// values it receives.
+- (RACChannelTerminal *)rac_newValueChannelWithNilValue:(NSNumber *)nilValue;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIStepper+RACSignalSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/UIStepper+RACSignalSupport.m
new file mode 100644
index 0000000..d8c5e81
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UIStepper+RACSignalSupport.m
@@ -0,0 +1,20 @@
+//
+//  UIStepper+RACSignalSupport.m
+//  ReactiveCocoa
+//
+//  Created by Uri Baghin on 20/07/2013.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "UIStepper+RACSignalSupport.h"
+#import "EXTKeyPathCoding.h"
+#import "UIControl+RACSignalSupport.h"
+#import "UIControl+RACSignalSupportPrivate.h"
+
+@implementation UIStepper (RACSignalSupport)
+
+- (RACChannelTerminal *)rac_newValueChannelWithNilValue:(NSNumber *)nilValue {
+	return [self rac_channelForControlEvents:UIControlEventValueChanged key:@keypath(self.value) nilValue:nilValue];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UISwitch+RACSignalSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/UISwitch+RACSignalSupport.h
new file mode 100644
index 0000000..1313a2c
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UISwitch+RACSignalSupport.h
@@ -0,0 +1,22 @@
+//
+//  UISwitch+RACSignalSupport.h
+//  ReactiveCocoa
+//
+//  Created by Uri Baghin on 20/07/2013.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <UIKit/UIKit.h>
+
+@class RACChannelTerminal;
+
+@interface UISwitch (RACSignalSupport)
+
+/// Creates a new RACChannel-based binding to the receiver.
+///
+/// Returns a RACChannelTerminal that sends whether the receiver is on whenever
+/// the UIControlEventValueChanged control event is fired, and sets it on or off
+/// when it receives @YES or @NO respectively.
+- (RACChannelTerminal *)rac_newOnChannel;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UISwitch+RACSignalSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/UISwitch+RACSignalSupport.m
new file mode 100644
index 0000000..1733fc5
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UISwitch+RACSignalSupport.m
@@ -0,0 +1,20 @@
+//
+//  UISwitch+RACSignalSupport.m
+//  ReactiveCocoa
+//
+//  Created by Uri Baghin on 20/07/2013.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "UISwitch+RACSignalSupport.h"
+#import "EXTKeyPathCoding.h"
+#import "UIControl+RACSignalSupport.h"
+#import "UIControl+RACSignalSupportPrivate.h"
+
+@implementation UISwitch (RACSignalSupport)
+
+- (RACChannelTerminal *)rac_newOnChannel {
+	return [self rac_channelForControlEvents:UIControlEventValueChanged key:@keypath(self.on) nilValue:@NO];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UITableViewCell+RACSignalSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/UITableViewCell+RACSignalSupport.h
new file mode 100644
index 0000000..c29d47c
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UITableViewCell+RACSignalSupport.h
@@ -0,0 +1,28 @@
+//
+//  UITableViewCell+RACSignalSupport.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-07-22.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <UIKit/UIKit.h>
+
+@class RACSignal;
+
+@interface UITableViewCell (RACSignalSupport)
+
+/// A signal which will send a RACUnit whenever -prepareForReuse is invoked upon
+/// the receiver.
+///
+/// Examples
+///
+///  [[[self.cancelButton
+///     rac_signalForControlEvents:UIControlEventTouchUpInside]
+///     takeUntil:self.rac_prepareForReuseSignal]
+///     subscribeNext:^(UIButton *x) {
+///         // do other things
+///     }];
+@property (nonatomic, strong, readonly) RACSignal *rac_prepareForReuseSignal;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UITableViewCell+RACSignalSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/UITableViewCell+RACSignalSupport.m
new file mode 100644
index 0000000..8a81c30
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UITableViewCell+RACSignalSupport.m
@@ -0,0 +1,31 @@
+//
+//  UITableViewCell+RACSignalSupport.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-07-22.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "UITableViewCell+RACSignalSupport.h"
+#import "NSObject+RACDescription.h"
+#import "NSObject+RACSelectorSignal.h"
+#import "RACSignal+Operations.h"
+#import "RACUnit.h"
+#import <objc/runtime.h>
+
+@implementation UITableViewCell (RACSignalSupport)
+
+- (RACSignal *)rac_prepareForReuseSignal {
+	RACSignal *signal = objc_getAssociatedObject(self, _cmd);
+	if (signal != nil) return signal;
+
+	signal = [[[self
+		rac_signalForSelector:@selector(prepareForReuse)]
+		mapReplace:RACUnit.defaultUnit]
+		setNameWithFormat:@"%@ -rac_prepareForReuseSignal", self.rac_description];
+	
+	objc_setAssociatedObject(self, _cmd, signal, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+	return signal;
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UITableViewHeaderFooterView+RACSignalSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/UITableViewHeaderFooterView+RACSignalSupport.h
new file mode 100644
index 0000000..6c5d6b8
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UITableViewHeaderFooterView+RACSignalSupport.h
@@ -0,0 +1,29 @@
+//
+//  UITableViewHeaderFooterView+RACSignalSupport.h
+//  ReactiveCocoa
+//
+//  Created by Syo Ikeda on 12/30/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <UIKit/UIKit.h>
+
+@class RACSignal;
+
+// This category is only applicable to iOS >= 6.0.
+@interface UITableViewHeaderFooterView (RACSignalSupport)
+
+/// A signal which will send a RACUnit whenever -prepareForReuse is invoked upon
+/// the receiver.
+///
+/// Examples
+///
+///  [[[self.cancelButton
+///     rac_signalForControlEvents:UIControlEventTouchUpInside]
+///     takeUntil:self.rac_prepareForReuseSignal]
+///     subscribeNext:^(UIButton *x) {
+///         // do other things
+///     }];
+@property (nonatomic, strong, readonly) RACSignal *rac_prepareForReuseSignal;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UITableViewHeaderFooterView+RACSignalSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/UITableViewHeaderFooterView+RACSignalSupport.m
new file mode 100644
index 0000000..0ecfc37
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UITableViewHeaderFooterView+RACSignalSupport.m
@@ -0,0 +1,31 @@
+//
+//  UITableViewHeaderFooterView+RACSignalSupport.m
+//  ReactiveCocoa
+//
+//  Created by Syo Ikeda on 12/30/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "UITableViewHeaderFooterView+RACSignalSupport.h"
+#import "NSObject+RACDescription.h"
+#import "NSObject+RACSelectorSignal.h"
+#import "RACSignal+Operations.h"
+#import "RACUnit.h"
+#import <objc/runtime.h>
+
+@implementation UITableViewHeaderFooterView (RACSignalSupport)
+
+- (RACSignal *)rac_prepareForReuseSignal {
+	RACSignal *signal = objc_getAssociatedObject(self, _cmd);
+	if (signal != nil) return signal;
+
+	signal = [[[self
+		rac_signalForSelector:@selector(prepareForReuse)]
+		mapReplace:RACUnit.defaultUnit]
+		setNameWithFormat:@"%@ -rac_prepareForReuseSignal", self.rac_description];
+
+	objc_setAssociatedObject(self, _cmd, signal, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+	return signal;
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UITextField+RACSignalSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/UITextField+RACSignalSupport.h
new file mode 100644
index 0000000..4ff6ee4
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UITextField+RACSignalSupport.h
@@ -0,0 +1,27 @@
+//
+//  UITextField+RACSignalSupport.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 4/17/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import <UIKit/UIKit.h>
+
+@class RACSignal, RACChannelTerminal;
+
+@interface UITextField (RACSignalSupport)
+
+/// Creates and returns a signal for the text of the field. It always starts with
+/// the current text. The signal sends next when the UIControlEventEditingChanged
+/// or UIControlEventEditingDidBegin control event is fired on the control.
+- (RACSignal *)rac_textSignal;
+
+/// Creates a new RACChannel-based binding to the receiver.
+///
+/// Returns a RACChannelTerminal that sends the receiver's text whenever the
+/// UIControlEventEditingChanged or UIControlEventEditingDidBegin control event 
+/// is fired, and sets the text to the values it receives.
+- (RACChannelTerminal *)rac_newTextChannel;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UITextField+RACSignalSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/UITextField+RACSignalSupport.m
new file mode 100644
index 0000000..ca2c68c
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UITextField+RACSignalSupport.m
@@ -0,0 +1,39 @@
+//
+//  UITextField+RACSignalSupport.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 4/17/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "UITextField+RACSignalSupport.h"
+#import "EXTKeyPathCoding.h"
+#import "EXTScope.h"
+#import "NSObject+RACDeallocating.h"
+#import "NSObject+RACDescription.h"
+#import "RACSignal+Operations.h"
+#import "UIControl+RACSignalSupport.h"
+#import "UIControl+RACSignalSupportPrivate.h"
+
+@implementation UITextField (RACSignalSupport)
+
+- (RACSignal *)rac_textSignal {
+	@weakify(self);
+	return [[[[[RACSignal
+		defer:^{
+			@strongify(self);
+			return [RACSignal return:self];
+		}]
+		concat:[self rac_signalForControlEvents:UIControlEventEditingChanged | UIControlEventEditingDidBegin]]
+		map:^(UITextField *x) {
+			return x.text;
+		}]
+		takeUntil:self.rac_willDeallocSignal]
+		setNameWithFormat:@"%@ -rac_textSignal", [self rac_description]];
+}
+
+- (RACChannelTerminal *)rac_newTextChannel {
+	return [self rac_channelForControlEvents:UIControlEventEditingChanged | UIControlEventEditingDidBegin key:@keypath(self.text) nilValue:@""];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UITextView+RACSignalSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/UITextView+RACSignalSupport.h
new file mode 100644
index 0000000..174b1ba
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UITextView+RACSignalSupport.h
@@ -0,0 +1,39 @@
+//
+//  UITextView+RACSignalSupport.h
+//  ReactiveCocoa
+//
+//  Created by Cody Krieger on 5/18/12.
+//  Copyright (c) 2012 Cody Krieger. All rights reserved.
+//
+
+#import <UIKit/UIKit.h>
+
+@class RACDelegateProxy;
+@class RACSignal;
+
+@interface UITextView (RACSignalSupport)
+
+/// A delegate proxy which will be set as the receiver's delegate when any of the
+/// methods in this category are used.
+@property (nonatomic, strong, readonly) RACDelegateProxy *rac_delegateProxy;
+
+/// Creates a signal for the text of the receiver.
+///
+/// When this method is invoked, the `rac_delegateProxy` will become the
+/// receiver's delegate. Any previous delegate will become the -[RACDelegateProxy
+/// rac_proxiedDelegate], so that it receives any messages that the proxy doesn't
+/// know how to handle. Setting the receiver's `delegate` afterward is
+/// considered undefined behavior.
+///
+/// Returns a signal which will send the current text upon subscription, then
+/// again whenever the receiver's text is changed. The signal will complete when
+/// the receiver is deallocated.
+- (RACSignal *)rac_textSignal;
+
+@end
+
+@interface UITextView (RACSignalSupportUnavailable)
+
+- (RACSignal *)rac_signalForDelegateMethod:(SEL)method __attribute__((unavailable("Use -rac_signalForSelector:fromProtocol: instead")));
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UITextView+RACSignalSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/UITextView+RACSignalSupport.m
new file mode 100644
index 0000000..aa1cf12
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/UITextView+RACSignalSupport.m
@@ -0,0 +1,56 @@
+//
+//  UITextView+RACSignalSupport.m
+//  ReactiveCocoa
+//
+//  Created by Cody Krieger on 5/18/12.
+//  Copyright (c) 2012 Cody Krieger. All rights reserved.
+//
+
+#import "UITextView+RACSignalSupport.h"
+#import "EXTScope.h"
+#import "NSObject+RACDeallocating.h"
+#import "RACDelegateProxy.h"
+#import "RACSignal+Operations.h"
+#import "RACTuple.h"
+#import "NSObject+RACDescription.h"
+#import <objc/runtime.h>
+
+@implementation UITextView (RACSignalSupport)
+
+static void RACUseDelegateProxy(UITextView *self) {
+    if (self.delegate == self.rac_delegateProxy) return;
+
+    self.rac_delegateProxy.rac_proxiedDelegate = self.delegate;
+    self.delegate = (id)self.rac_delegateProxy;
+}
+
+- (RACDelegateProxy *)rac_delegateProxy {
+	RACDelegateProxy *proxy = objc_getAssociatedObject(self, _cmd);
+	if (proxy == nil) {
+		proxy = [[RACDelegateProxy alloc] initWithProtocol:@protocol(UITextViewDelegate)];
+		objc_setAssociatedObject(self, _cmd, proxy, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+	}
+
+	return proxy;
+}
+
+- (RACSignal *)rac_textSignal {
+	@weakify(self);
+	RACSignal *signal = [[[[[RACSignal
+		defer:^{
+			@strongify(self);
+			return [RACSignal return:RACTuplePack(self)];
+		}]
+		concat:[self.rac_delegateProxy signalForSelector:@selector(textViewDidChange:)]]
+		reduceEach:^(UITextView *x) {
+			return x.text;
+		}]
+		takeUntil:self.rac_willDeallocSignal]
+		setNameWithFormat:@"%@ -rac_textSignal", [self rac_description]];
+
+	RACUseDelegateProxy(self);
+
+	return signal;
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/en.lproj/InfoPlist.strings b/ReactiveCocoaFramework/ReactiveCocoa/en.lproj/InfoPlist.strings
new file mode 100644
index 0000000..477b28f
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/en.lproj/InfoPlist.strings
@@ -0,0 +1,2 @@
+/* Localized versions of Info.plist keys */
+
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/extobjc/EXTKeyPathCoding.h b/ReactiveCocoaFramework/ReactiveCocoa/extobjc/EXTKeyPathCoding.h
new file mode 100644
index 0000000..f34dc4a
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/extobjc/EXTKeyPathCoding.h
@@ -0,0 +1,68 @@
+//
+//  EXTKeyPathCoding.h
+//  extobjc
+//
+//  Created by Justin Spahr-Summers on 19.06.12.
+//  Copyright (C) 2012 Justin Spahr-Summers.
+//  Released under the MIT license.
+//
+
+#import <Foundation/Foundation.h>
+#import "metamacros.h"
+
+/**
+ * \@keypath allows compile-time verification of key paths. Given a real object
+ * receiver and key path:
+ *
+ * @code
+
+NSString *UTF8StringPath = @keypath(str.lowercaseString.UTF8String);
+// => @"lowercaseString.UTF8String"
+
+NSString *versionPath = @keypath(NSObject, version);
+// => @"version"
+
+NSString *lowercaseStringPath = @keypath(NSString.new, lowercaseString);
+// => @"lowercaseString"
+
+ * @endcode
+ *
+ * ... the macro returns an \c NSString containing all but the first path
+ * component or argument (e.g., @"lowercaseString.UTF8String", @"version").
+ *
+ * In addition to simply creating a key path, this macro ensures that the key
+ * path is valid at compile-time (causing a syntax error if not), and supports
+ * refactoring, such that changing the name of the property will also update any
+ * uses of \@keypath.
+ */
+#define keypath(...) \
+    metamacro_if_eq(1, metamacro_argcount(__VA_ARGS__))(keypath1(__VA_ARGS__))(keypath2(__VA_ARGS__))
+
+#define keypath1(PATH) \
+    (((void)(NO && ((void)PATH, NO)), strchr(# PATH, '.') + 1))
+
+#define keypath2(OBJ, PATH) \
+    (((void)(NO && ((void)OBJ.PATH, NO)), # PATH))
+
+/**
+ * \@collectionKeypath allows compile-time verification of key paths across collections NSArray/NSSet etc. Given a real object
+ * receiver, collection object receiver and related keypaths:
+ *
+ * @code
+ 
+ NSString *employessFirstNamePath = @collectionKeypath(department.employees, Employee.new, firstName)
+ // => @"employees.firstName"
+ 
+ NSString *employessFirstNamePath = @collectionKeypath(Department.new, employees, Employee.new, firstName)
+ // => @"employees.firstName"
+
+ * @endcode
+ *
+ */
+#define collectionKeypath(...) \
+    metamacro_if_eq(3, metamacro_argcount(__VA_ARGS__))(collectionKeypath3(__VA_ARGS__))(collectionKeypath4(__VA_ARGS__))
+
+#define collectionKeypath3(PATH, COLLECTION_OBJECT, COLLECTION_PATH) ([[NSString stringWithFormat:@"%s.%s",keypath(PATH), keypath(COLLECTION_OBJECT, COLLECTION_PATH)] UTF8String])
+
+#define collectionKeypath4(OBJ, PATH, COLLECTION_OBJECT, COLLECTION_PATH) ([[NSString stringWithFormat:@"%s.%s",keypath(OBJ, PATH), keypath(COLLECTION_OBJECT, COLLECTION_PATH)] UTF8String])
+
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/extobjc/EXTRuntimeExtensions.h b/ReactiveCocoaFramework/ReactiveCocoa/extobjc/EXTRuntimeExtensions.h
new file mode 100644
index 0000000..ab4e11d
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/extobjc/EXTRuntimeExtensions.h
@@ -0,0 +1,122 @@
+//
+//  EXTRuntimeExtensions.h
+//  extobjc
+//
+//  Created by Justin Spahr-Summers on 2011-03-05.
+//  Copyright (C) 2012 Justin Spahr-Summers.
+//  Released under the MIT license.
+//
+
+#import <objc/runtime.h>
+
+/**
+ * Describes the memory management policy of a property.
+ */
+typedef enum {
+    /**
+     * The value is assigned.
+     */
+    rac_propertyMemoryManagementPolicyAssign = 0,
+
+    /**
+     * The value is retained.
+     */
+    rac_propertyMemoryManagementPolicyRetain,
+
+    /**
+     * The value is copied.
+     */
+    rac_propertyMemoryManagementPolicyCopy
+} rac_propertyMemoryManagementPolicy;
+
+/**
+ * Describes the attributes and type information of a property.
+ */
+typedef struct {
+    /**
+     * Whether this property was declared with the \c readonly attribute.
+     */
+    BOOL readonly;
+
+    /**
+     * Whether this property was declared with the \c nonatomic attribute.
+     */
+    BOOL nonatomic;
+
+    /**
+     * Whether the property is a weak reference.
+     */
+    BOOL weak;
+
+    /**
+     * Whether the property is eligible for garbage collection.
+     */
+    BOOL canBeCollected;
+
+    /**
+     * Whether this property is defined with \c \@dynamic.
+     */
+    BOOL dynamic;
+
+    /**
+     * The memory management policy for this property. This will always be
+     * #rac_propertyMemoryManagementPolicyAssign if #readonly is \c YES.
+     */
+    rac_propertyMemoryManagementPolicy memoryManagementPolicy;
+
+    /**
+     * The selector for the getter of this property. This will reflect any
+     * custom \c getter= attribute provided in the property declaration, or the
+     * inferred getter name otherwise.
+     */
+    SEL getter;
+
+    /**
+     * The selector for the setter of this property. This will reflect any
+     * custom \c setter= attribute provided in the property declaration, or the
+     * inferred setter name otherwise.
+     *
+     * @note If #readonly is \c YES, this value will represent what the setter
+     * \e would be, if the property were writable.
+     */
+    SEL setter;
+
+    /**
+     * The backing instance variable for this property, or \c NULL if \c
+     * \c @synthesize was not used, and therefore no instance variable exists. This
+     * would also be the case if the property is implemented dynamically.
+     */
+    const char *ivar;
+
+    /**
+     * If this property is defined as being an instance of a specific class,
+     * this will be the class object representing it.
+     *
+     * This will be \c nil if the property was defined as type \c id, if the
+     * property is not of an object type, or if the class could not be found at
+     * runtime.
+     */
+    Class objectClass;
+
+    /**
+     * The type encoding for the value of this property. This is the type as it
+     * would be returned by the \c \@encode() directive.
+     */
+    char type[];
+} rac_propertyAttributes;
+
+/**
+ * Finds the instance method named \a aSelector on \a aClass and returns it, or
+ * returns \c NULL if no such instance method exists. Unlike \c
+ * class_getInstanceMethod(), this does not search superclasses.
+ *
+ * @note To get class methods in this manner, use a metaclass for \a aClass.
+ */
+Method rac_getImmediateInstanceMethod (Class aClass, SEL aSelector);
+
+/**
+ * Returns a pointer to a structure containing information about \a property.
+ * You must \c free() the returned pointer. Returns \c NULL if there is an error
+ * obtaining information from \a property.
+ */
+rac_propertyAttributes *rac_copyPropertyAttributes (objc_property_t property);
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/extobjc/EXTRuntimeExtensions.m b/ReactiveCocoaFramework/ReactiveCocoa/extobjc/EXTRuntimeExtensions.m
new file mode 100644
index 0000000..4d35a3e
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/extobjc/EXTRuntimeExtensions.m
@@ -0,0 +1,232 @@
+//
+//  EXTRuntimeExtensions.m
+//  extobjc
+//
+//  Created by Justin Spahr-Summers on 2011-03-05.
+//  Copyright (C) 2012 Justin Spahr-Summers.
+//  Released under the MIT license.
+//
+
+#import "EXTRuntimeExtensions.h"
+#import <ctype.h>
+#import <libkern/OSAtomic.h>
+#import <objc/message.h>
+#import <pthread.h>
+#import <stdio.h>
+#import <stdlib.h>
+#import <string.h>
+
+rac_propertyAttributes *rac_copyPropertyAttributes (objc_property_t property) {
+    const char * const attrString = property_getAttributes(property);
+    if (!attrString) {
+        fprintf(stderr, "ERROR: Could not get attribute string from property %s\n", property_getName(property));
+        return NULL;
+    }
+
+    if (attrString[0] != 'T') {
+        fprintf(stderr, "ERROR: Expected attribute string \"%s\" for property %s to start with 'T'\n", attrString, property_getName(property));
+        return NULL;
+    }
+
+    const char *typeString = attrString + 1;
+    const char *next = NSGetSizeAndAlignment(typeString, NULL, NULL);
+    if (!next) {
+        fprintf(stderr, "ERROR: Could not read past type in attribute string \"%s\" for property %s\n", attrString, property_getName(property));
+        return NULL;
+    }
+
+    size_t typeLength = (size_t)(next - typeString);
+    if (!typeLength) {
+        fprintf(stderr, "ERROR: Invalid type in attribute string \"%s\" for property %s\n", attrString, property_getName(property));
+        return NULL;
+    }
+
+    // allocate enough space for the structure and the type string (plus a NUL)
+    rac_propertyAttributes *attributes = calloc(1, sizeof(rac_propertyAttributes) + typeLength + 1);
+    if (!attributes) {
+        fprintf(stderr, "ERROR: Could not allocate rac_propertyAttributes structure for attribute string \"%s\" for property %s\n", attrString, property_getName(property));
+        return NULL;
+    }
+
+    // copy the type string
+    strncpy(attributes->type, typeString, typeLength);
+    attributes->type[typeLength] = '\0';
+
+    // if this is an object type, and immediately followed by a quoted string...
+    if (typeString[0] == *(@encode(id)) && typeString[1] == '"') {
+        // we should be able to extract a class name
+        const char *className = typeString + 2;
+        next = strchr(className, '"');
+
+        if (!next) {
+            fprintf(stderr, "ERROR: Could not read class name in attribute string \"%s\" for property %s\n", attrString, property_getName(property));
+            return NULL;
+        }
+
+        if (className != next) {
+            size_t classNameLength = (size_t)(next - className);
+            char trimmedName[classNameLength + 1];
+
+            strncpy(trimmedName, className, classNameLength);
+            trimmedName[classNameLength] = '\0';
+
+            // attempt to look up the class in the runtime
+            attributes->objectClass = objc_getClass(trimmedName);
+        }
+    }
+
+    if (*next != '\0') {
+        // skip past any junk before the first flag
+        next = strchr(next, ',');
+    }
+
+    while (next && *next == ',') {
+        char flag = next[1];
+        next += 2;
+
+        switch (flag) {
+        case '\0':
+            break;
+
+        case 'R':
+            attributes->readonly = YES;
+            break;
+
+        case 'C':
+            attributes->memoryManagementPolicy = rac_propertyMemoryManagementPolicyCopy;
+            break;
+
+        case '&':
+            attributes->memoryManagementPolicy = rac_propertyMemoryManagementPolicyRetain;
+            break;
+
+        case 'N':
+            attributes->nonatomic = YES;
+            break;
+
+        case 'G':
+        case 'S':
+            {
+                const char *nextFlag = strchr(next, ',');
+                SEL name = NULL;
+
+                if (!nextFlag) {
+                    // assume that the rest of the string is the selector
+                    const char *selectorString = next;
+                    next = "";
+
+                    name = sel_registerName(selectorString);
+                } else {
+                    size_t selectorLength = (size_t)(nextFlag - next);
+                    if (!selectorLength) {
+                        fprintf(stderr, "ERROR: Found zero length selector name in attribute string \"%s\" for property %s\n", attrString, property_getName(property));
+                        goto errorOut;
+                    }
+
+                    char selectorString[selectorLength + 1];
+
+                    strncpy(selectorString, next, selectorLength);
+                    selectorString[selectorLength] = '\0';
+
+                    name = sel_registerName(selectorString);
+                    next = nextFlag;
+                }
+
+                if (flag == 'G')
+                    attributes->getter = name;
+                else
+                    attributes->setter = name;
+            }
+
+            break;
+
+        case 'D':
+            attributes->dynamic = YES;
+            attributes->ivar = NULL;
+            break;
+
+        case 'V':
+            // assume that the rest of the string (if present) is the ivar name
+            if (*next == '\0') {
+                // if there's nothing there, let's assume this is dynamic
+                attributes->ivar = NULL;
+            } else {
+                attributes->ivar = next;
+                next = "";
+            }
+
+            break;
+
+        case 'W':
+            attributes->weak = YES;
+            break;
+
+        case 'P':
+            attributes->canBeCollected = YES;
+            break;
+
+        case 't':
+            fprintf(stderr, "ERROR: Old-style type encoding is unsupported in attribute string \"%s\" for property %s\n", attrString, property_getName(property));
+
+            // skip over this type encoding
+            while (*next != ',' && *next != '\0')
+                ++next;
+
+            break;
+
+        default:
+            fprintf(stderr, "ERROR: Unrecognized attribute string flag '%c' in attribute string \"%s\" for property %s\n", flag, attrString, property_getName(property));
+        }
+    }
+
+    if (next && *next != '\0') {
+        fprintf(stderr, "Warning: Unparsed data \"%s\" in attribute string \"%s\" for property %s\n", next, attrString, property_getName(property));
+    }
+
+    if (!attributes->getter) {
+        // use the property name as the getter by default
+        attributes->getter = sel_registerName(property_getName(property));
+    }
+
+    if (!attributes->setter) {
+        const char *propertyName = property_getName(property);
+        size_t propertyNameLength = strlen(propertyName);
+
+        // we want to transform the name to setProperty: style
+        size_t setterLength = propertyNameLength + 4;
+
+        char setterName[setterLength + 1];
+        strncpy(setterName, "set", 3);
+        strncpy(setterName + 3, propertyName, propertyNameLength);
+
+        // capitalize property name for the setter
+        setterName[3] = (char)toupper(setterName[3]);
+
+        setterName[setterLength - 1] = ':';
+        setterName[setterLength] = '\0';
+
+        attributes->setter = sel_registerName(setterName);
+    }
+
+    return attributes;
+
+errorOut:
+    free(attributes);
+    return NULL;
+}
+
+Method rac_getImmediateInstanceMethod (Class aClass, SEL aSelector) {
+    unsigned methodCount = 0;
+    Method *methods = class_copyMethodList(aClass, &methodCount);
+    Method foundMethod = NULL;
+
+    for (unsigned methodIndex = 0;methodIndex < methodCount;++methodIndex) {
+        if (method_getName(methods[methodIndex]) == aSelector) {
+            foundMethod = methods[methodIndex];
+            break;
+        }
+    }
+
+    free(methods);
+    return foundMethod;
+}
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/extobjc/EXTScope.h b/ReactiveCocoaFramework/ReactiveCocoa/extobjc/EXTScope.h
new file mode 100644
index 0000000..2e51747
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/extobjc/EXTScope.h
@@ -0,0 +1,101 @@
+//
+//  EXTScope.h
+//  extobjc
+//
+//  Created by Justin Spahr-Summers on 2011-05-04.
+//  Copyright (C) 2012 Justin Spahr-Summers.
+//  Released under the MIT license.
+//
+
+#import "metamacros.h"
+
+/**
+ * \@onExit defines some code to be executed when the current scope exits. The
+ * code must be enclosed in braces and terminated with a semicolon, and will be
+ * executed regardless of how the scope is exited, including from exceptions,
+ * \c goto, \c return, \c break, and \c continue.
+ *
+ * Provided code will go into a block to be executed later. Keep this in mind as
+ * it pertains to memory management, restrictions on assignment, etc. Because
+ * the code is used within a block, \c return is a legal (though perhaps
+ * confusing) way to exit the cleanup block early.
+ *
+ * Multiple \@onExit statements in the same scope are executed in reverse
+ * lexical order. This helps when pairing resource acquisition with \@onExit
+ * statements, as it guarantees teardown in the opposite order of acquisition.
+ *
+ * @note This statement cannot be used within scopes defined without braces
+ * (like a one line \c if). In practice, this is not an issue, since \@onExit is
+ * a useless construct in such a case anyways.
+ */
+#define onExit \
+    autoreleasepool {} \
+    __strong rac_cleanupBlock_t metamacro_concat(rac_exitBlock_, __LINE__) __attribute__((cleanup(rac_executeCleanupBlock), unused)) = ^
+
+/**
+ * Creates \c __weak shadow variables for each of the variables provided as
+ * arguments, which can later be made strong again with #strongify.
+ *
+ * This is typically used to weakly reference variables in a block, but then
+ * ensure that the variables stay alive during the actual execution of the block
+ * (if they were live upon entry).
+ *
+ * See #strongify for an example of usage.
+ */
+#define weakify(...) \
+    autoreleasepool {} \
+    metamacro_foreach_cxt(rac_weakify_,, __weak, __VA_ARGS__)
+
+/**
+ * Like #weakify, but uses \c __unsafe_unretained instead, for targets or
+ * classes that do not support weak references.
+ */
+#define unsafeify(...) \
+    autoreleasepool {} \
+    metamacro_foreach_cxt(rac_weakify_,, __unsafe_unretained, __VA_ARGS__)
+
+/**
+ * Strongly references each of the variables provided as arguments, which must
+ * have previously been passed to #weakify.
+ *
+ * The strong references created will shadow the original variable names, such
+ * that the original names can be used without issue (and a significantly
+ * reduced risk of retain cycles) in the current scope.
+ *
+ * @code
+
+    id foo = [[NSObject alloc] init];
+    id bar = [[NSObject alloc] init];
+
+    @weakify(foo, bar);
+
+    // this block will not keep 'foo' or 'bar' alive
+    BOOL (^matchesFooOrBar)(id) = ^ BOOL (id obj){
+        // but now, upon entry, 'foo' and 'bar' will stay alive until the block has
+        // finished executing
+        @strongify(foo, bar);
+
+        return [foo isEqual:obj] || [bar isEqual:obj];
+    };
+
+ * @endcode
+ */
+#define strongify(...) \
+    try {} @finally {} \
+    _Pragma("clang diagnostic push") \
+    _Pragma("clang diagnostic ignored \"-Wshadow\"") \
+    metamacro_foreach(rac_strongify_,, __VA_ARGS__) \
+    _Pragma("clang diagnostic pop")
+
+/*** implementation details follow ***/
+typedef void (^rac_cleanupBlock_t)();
+
+static inline void rac_executeCleanupBlock (__strong rac_cleanupBlock_t *block) {
+    (*block)();
+}
+
+#define rac_weakify_(INDEX, CONTEXT, VAR) \
+    CONTEXT __typeof__(VAR) metamacro_concat(VAR, _weak_) = (VAR);
+
+#define rac_strongify_(INDEX, VAR) \
+    __strong __typeof__(VAR) VAR = metamacro_concat(VAR, _weak_);
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/extobjc/metamacros.h b/ReactiveCocoaFramework/ReactiveCocoa/extobjc/metamacros.h
new file mode 100644
index 0000000..77a77b5
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoa/extobjc/metamacros.h
@@ -0,0 +1,666 @@
+/**
+ * Macros for metaprogramming
+ * ExtendedC
+ *
+ * Copyright (C) 2012 Justin Spahr-Summers
+ * Released under the MIT license
+ */
+
+#ifndef EXTC_METAMACROS_H
+#define EXTC_METAMACROS_H
+
+/**
+ * Executes one or more expressions (which may have a void type, such as a call
+ * to a function that returns no value) and always returns true.
+ */
+#define metamacro_exprify(...) \
+    ((__VA_ARGS__), true)
+
+/**
+ * Returns a string representation of VALUE after full macro expansion.
+ */
+#define metamacro_stringify(VALUE) \
+        metamacro_stringify_(VALUE)
+
+/**
+ * Returns A and B concatenated after full macro expansion.
+ */
+#define metamacro_concat(A, B) \
+        metamacro_concat_(A, B)
+
+/**
+ * Returns the Nth variadic argument (starting from zero). At least
+ * N + 1 variadic arguments must be given. N must be between zero and twenty,
+ * inclusive.
+ */
+#define metamacro_at(N, ...) \
+        metamacro_concat(metamacro_at, N)(__VA_ARGS__)
+
+/**
+ * Returns the number of arguments (up to twenty) provided to the macro. At
+ * least one argument must be provided.
+ *
+ * Inspired by P99: http://p99.gforge.inria.fr
+ */
+#define metamacro_argcount(...) \
+        metamacro_at(20, __VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)
+
+/**
+ * Identical to #metamacro_foreach_cxt, except that no CONTEXT argument is
+ * given. Only the index and current argument will thus be passed to MACRO.
+ */
+#define metamacro_foreach(MACRO, SEP, ...) \
+        metamacro_foreach_cxt(metamacro_foreach_iter, SEP, MACRO, __VA_ARGS__)
+
+/**
+ * For each consecutive variadic argument (up to twenty), MACRO is passed the
+ * zero-based index of the current argument, CONTEXT, and then the argument
+ * itself. The results of adjoining invocations of MACRO are then separated by
+ * SEP.
+ *
+ * Inspired by P99: http://p99.gforge.inria.fr
+ */
+#define metamacro_foreach_cxt(MACRO, SEP, CONTEXT, ...) \
+        metamacro_concat(metamacro_foreach_cxt, metamacro_argcount(__VA_ARGS__))(MACRO, SEP, CONTEXT, __VA_ARGS__)
+
+/**
+ * Identical to #metamacro_foreach_cxt. This can be used when the former would
+ * fail due to recursive macro expansion.
+ */
+#define metamacro_foreach_cxt_recursive(MACRO, SEP, CONTEXT, ...) \
+        metamacro_concat(metamacro_foreach_cxt_recursive, metamacro_argcount(__VA_ARGS__))(MACRO, SEP, CONTEXT, __VA_ARGS__)
+
+/**
+ * In consecutive order, appends each variadic argument (up to twenty) onto
+ * BASE. The resulting concatenations are then separated by SEP.
+ *
+ * This is primarily useful to manipulate a list of macro invocations into instead
+ * invoking a different, possibly related macro.
+ */
+#define metamacro_foreach_concat(BASE, SEP, ...) \
+        metamacro_foreach_cxt(metamacro_foreach_concat_iter, SEP, BASE, __VA_ARGS__)
+
+/**
+ * Iterates COUNT times, each time invoking MACRO with the current index
+ * (starting at zero) and CONTEXT. The results of adjoining invocations of MACRO
+ * are then separated by SEP.
+ *
+ * COUNT must be an integer between zero and twenty, inclusive.
+ */
+#define metamacro_for_cxt(COUNT, MACRO, SEP, CONTEXT) \
+        metamacro_concat(metamacro_for_cxt, COUNT)(MACRO, SEP, CONTEXT)
+
+/**
+ * Returns the first argument given. At least one argument must be provided.
+ *
+ * This is useful when implementing a variadic macro, where you may have only
+ * one variadic argument, but no way to retrieve it (for example, because \c ...
+ * always needs to match at least one argument).
+ *
+ * @code
+
+#define varmacro(...) \
+    metamacro_head(__VA_ARGS__)
+
+ * @endcode
+ */
+#define metamacro_head(...) \
+        metamacro_head_(__VA_ARGS__, 0)
+
+/**
+ * Returns every argument except the first. At least two arguments must be
+ * provided.
+ */
+#define metamacro_tail(...) \
+        metamacro_tail_(__VA_ARGS__)
+
+/**
+ * Returns the first N (up to twenty) variadic arguments as a new argument list.
+ * At least N variadic arguments must be provided.
+ */
+#define metamacro_take(N, ...) \
+        metamacro_concat(metamacro_take, N)(__VA_ARGS__)
+
+/**
+ * Removes the first N (up to twenty) variadic arguments from the given argument
+ * list. At least N variadic arguments must be provided.
+ */
+#define metamacro_drop(N, ...) \
+        metamacro_concat(metamacro_drop, N)(__VA_ARGS__)
+
+/**
+ * Decrements VAL, which must be a number between zero and twenty, inclusive.
+ *
+ * This is primarily useful when dealing with indexes and counts in
+ * metaprogramming.
+ */
+#define metamacro_dec(VAL) \
+        metamacro_at(VAL, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19)
+
+/**
+ * Increments VAL, which must be a number between zero and twenty, inclusive.
+ *
+ * This is primarily useful when dealing with indexes and counts in
+ * metaprogramming.
+ */
+#define metamacro_inc(VAL) \
+        metamacro_at(VAL, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21)
+
+/**
+ * If A is equal to B, the next argument list is expanded; otherwise, the
+ * argument list after that is expanded. A and B must be numbers between zero
+ * and twenty, inclusive. Additionally, B must be greater than or equal to A.
+ *
+ * @code
+
+// expands to true
+metamacro_if_eq(0, 0)(true)(false)
+
+// expands to false
+metamacro_if_eq(0, 1)(true)(false)
+
+ * @endcode
+ *
+ * This is primarily useful when dealing with indexes and counts in
+ * metaprogramming.
+ */
+#define metamacro_if_eq(A, B) \
+        metamacro_concat(metamacro_if_eq, A)(B)
+
+/**
+ * Identical to #metamacro_if_eq. This can be used when the former would fail
+ * due to recursive macro expansion.
+ */
+#define metamacro_if_eq_recursive(A, B) \
+        metamacro_concat(metamacro_if_eq_recursive, A)(B)
+
+/**
+ * Returns 1 if N is an even number, or 0 otherwise. N must be between zero and
+ * twenty, inclusive.
+ *
+ * For the purposes of this test, zero is considered even.
+ */
+#define metamacro_is_even(N) \
+        metamacro_at(N, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1)
+
+/**
+ * Returns the logical NOT of B, which must be the number zero or one.
+ */
+#define metamacro_not(B) \
+        metamacro_at(B, 1, 0)
+
+// IMPLEMENTATION DETAILS FOLLOW!
+// Do not write code that depends on anything below this line.
+#define metamacro_stringify_(VALUE) # VALUE
+#define metamacro_concat_(A, B) A ## B
+#define metamacro_foreach_iter(INDEX, MACRO, ARG) MACRO(INDEX, ARG)
+#define metamacro_head_(FIRST, ...) FIRST
+#define metamacro_tail_(FIRST, ...) __VA_ARGS__
+#define metamacro_consume_(...)
+#define metamacro_expand_(...) __VA_ARGS__
+
+// implemented from scratch so that metamacro_concat() doesn't end up nesting
+#define metamacro_foreach_concat_iter(INDEX, BASE, ARG) metamacro_foreach_concat_iter_(BASE, ARG)
+#define metamacro_foreach_concat_iter_(BASE, ARG) BASE ## ARG
+
+// metamacro_at expansions
+#define metamacro_at0(...) metamacro_head(__VA_ARGS__)
+#define metamacro_at1(_0, ...) metamacro_head(__VA_ARGS__)
+#define metamacro_at2(_0, _1, ...) metamacro_head(__VA_ARGS__)
+#define metamacro_at3(_0, _1, _2, ...) metamacro_head(__VA_ARGS__)
+#define metamacro_at4(_0, _1, _2, _3, ...) metamacro_head(__VA_ARGS__)
+#define metamacro_at5(_0, _1, _2, _3, _4, ...) metamacro_head(__VA_ARGS__)
+#define metamacro_at6(_0, _1, _2, _3, _4, _5, ...) metamacro_head(__VA_ARGS__)
+#define metamacro_at7(_0, _1, _2, _3, _4, _5, _6, ...) metamacro_head(__VA_ARGS__)
+#define metamacro_at8(_0, _1, _2, _3, _4, _5, _6, _7, ...) metamacro_head(__VA_ARGS__)
+#define metamacro_at9(_0, _1, _2, _3, _4, _5, _6, _7, _8, ...) metamacro_head(__VA_ARGS__)
+#define metamacro_at10(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, ...) metamacro_head(__VA_ARGS__)
+#define metamacro_at11(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, ...) metamacro_head(__VA_ARGS__)
+#define metamacro_at12(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, ...) metamacro_head(__VA_ARGS__)
+#define metamacro_at13(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, ...) metamacro_head(__VA_ARGS__)
+#define metamacro_at14(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, ...) metamacro_head(__VA_ARGS__)
+#define metamacro_at15(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, ...) metamacro_head(__VA_ARGS__)
+#define metamacro_at16(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, ...) metamacro_head(__VA_ARGS__)
+#define metamacro_at17(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, ...) metamacro_head(__VA_ARGS__)
+#define metamacro_at18(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, ...) metamacro_head(__VA_ARGS__)
+#define metamacro_at19(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, ...) metamacro_head(__VA_ARGS__)
+#define metamacro_at20(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, ...) metamacro_head(__VA_ARGS__)
+
+// metamacro_foreach_cxt expansions
+#define metamacro_foreach_cxt0(MACRO, SEP, CONTEXT)
+#define metamacro_foreach_cxt1(MACRO, SEP, CONTEXT, _0) MACRO(0, CONTEXT, _0)
+
+#define metamacro_foreach_cxt2(MACRO, SEP, CONTEXT, _0, _1) \
+    metamacro_foreach_cxt1(MACRO, SEP, CONTEXT, _0) \
+    SEP \
+    MACRO(1, CONTEXT, _1)
+
+#define metamacro_foreach_cxt3(MACRO, SEP, CONTEXT, _0, _1, _2) \
+    metamacro_foreach_cxt2(MACRO, SEP, CONTEXT, _0, _1) \
+    SEP \
+    MACRO(2, CONTEXT, _2)
+
+#define metamacro_foreach_cxt4(MACRO, SEP, CONTEXT, _0, _1, _2, _3) \
+    metamacro_foreach_cxt3(MACRO, SEP, CONTEXT, _0, _1, _2) \
+    SEP \
+    MACRO(3, CONTEXT, _3)
+
+#define metamacro_foreach_cxt5(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4) \
+    metamacro_foreach_cxt4(MACRO, SEP, CONTEXT, _0, _1, _2, _3) \
+    SEP \
+    MACRO(4, CONTEXT, _4)
+
+#define metamacro_foreach_cxt6(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5) \
+    metamacro_foreach_cxt5(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4) \
+    SEP \
+    MACRO(5, CONTEXT, _5)
+
+#define metamacro_foreach_cxt7(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6) \
+    metamacro_foreach_cxt6(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5) \
+    SEP \
+    MACRO(6, CONTEXT, _6)
+
+#define metamacro_foreach_cxt8(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7) \
+    metamacro_foreach_cxt7(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6) \
+    SEP \
+    MACRO(7, CONTEXT, _7)
+
+#define metamacro_foreach_cxt9(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8) \
+    metamacro_foreach_cxt8(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7) \
+    SEP \
+    MACRO(8, CONTEXT, _8)
+
+#define metamacro_foreach_cxt10(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9) \
+    metamacro_foreach_cxt9(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8) \
+    SEP \
+    MACRO(9, CONTEXT, _9)
+
+#define metamacro_foreach_cxt11(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) \
+    metamacro_foreach_cxt10(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9) \
+    SEP \
+    MACRO(10, CONTEXT, _10)
+
+#define metamacro_foreach_cxt12(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) \
+    metamacro_foreach_cxt11(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) \
+    SEP \
+    MACRO(11, CONTEXT, _11)
+
+#define metamacro_foreach_cxt13(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) \
+    metamacro_foreach_cxt12(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) \
+    SEP \
+    MACRO(12, CONTEXT, _12)
+
+#define metamacro_foreach_cxt14(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13) \
+    metamacro_foreach_cxt13(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) \
+    SEP \
+    MACRO(13, CONTEXT, _13)
+
+#define metamacro_foreach_cxt15(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14) \
+    metamacro_foreach_cxt14(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13) \
+    SEP \
+    MACRO(14, CONTEXT, _14)
+
+#define metamacro_foreach_cxt16(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) \
+    metamacro_foreach_cxt15(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14) \
+    SEP \
+    MACRO(15, CONTEXT, _15)
+
+#define metamacro_foreach_cxt17(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) \
+    metamacro_foreach_cxt16(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) \
+    SEP \
+    MACRO(16, CONTEXT, _16)
+
+#define metamacro_foreach_cxt18(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17) \
+    metamacro_foreach_cxt17(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) \
+    SEP \
+    MACRO(17, CONTEXT, _17)
+
+#define metamacro_foreach_cxt19(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18) \
+    metamacro_foreach_cxt18(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17) \
+    SEP \
+    MACRO(18, CONTEXT, _18)
+
+#define metamacro_foreach_cxt20(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19) \
+    metamacro_foreach_cxt19(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18) \
+    SEP \
+    MACRO(19, CONTEXT, _19)
+
+// metamacro_foreach_cxt_recursive expansions
+#define metamacro_foreach_cxt_recursive0(MACRO, SEP, CONTEXT)
+#define metamacro_foreach_cxt_recursive1(MACRO, SEP, CONTEXT, _0) MACRO(0, CONTEXT, _0)
+
+#define metamacro_foreach_cxt_recursive2(MACRO, SEP, CONTEXT, _0, _1) \
+    metamacro_foreach_cxt_recursive1(MACRO, SEP, CONTEXT, _0) \
+    SEP \
+    MACRO(1, CONTEXT, _1)
+
+#define metamacro_foreach_cxt_recursive3(MACRO, SEP, CONTEXT, _0, _1, _2) \
+    metamacro_foreach_cxt_recursive2(MACRO, SEP, CONTEXT, _0, _1) \
+    SEP \
+    MACRO(2, CONTEXT, _2)
+
+#define metamacro_foreach_cxt_recursive4(MACRO, SEP, CONTEXT, _0, _1, _2, _3) \
+    metamacro_foreach_cxt_recursive3(MACRO, SEP, CONTEXT, _0, _1, _2) \
+    SEP \
+    MACRO(3, CONTEXT, _3)
+
+#define metamacro_foreach_cxt_recursive5(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4) \
+    metamacro_foreach_cxt_recursive4(MACRO, SEP, CONTEXT, _0, _1, _2, _3) \
+    SEP \
+    MACRO(4, CONTEXT, _4)
+
+#define metamacro_foreach_cxt_recursive6(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5) \
+    metamacro_foreach_cxt_recursive5(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4) \
+    SEP \
+    MACRO(5, CONTEXT, _5)
+
+#define metamacro_foreach_cxt_recursive7(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6) \
+    metamacro_foreach_cxt_recursive6(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5) \
+    SEP \
+    MACRO(6, CONTEXT, _6)
+
+#define metamacro_foreach_cxt_recursive8(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7) \
+    metamacro_foreach_cxt_recursive7(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6) \
+    SEP \
+    MACRO(7, CONTEXT, _7)
+
+#define metamacro_foreach_cxt_recursive9(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8) \
+    metamacro_foreach_cxt_recursive8(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7) \
+    SEP \
+    MACRO(8, CONTEXT, _8)
+
+#define metamacro_foreach_cxt_recursive10(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9) \
+    metamacro_foreach_cxt_recursive9(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8) \
+    SEP \
+    MACRO(9, CONTEXT, _9)
+
+#define metamacro_foreach_cxt_recursive11(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) \
+    metamacro_foreach_cxt_recursive10(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9) \
+    SEP \
+    MACRO(10, CONTEXT, _10)
+
+#define metamacro_foreach_cxt_recursive12(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) \
+    metamacro_foreach_cxt_recursive11(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) \
+    SEP \
+    MACRO(11, CONTEXT, _11)
+
+#define metamacro_foreach_cxt_recursive13(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) \
+    metamacro_foreach_cxt_recursive12(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) \
+    SEP \
+    MACRO(12, CONTEXT, _12)
+
+#define metamacro_foreach_cxt_recursive14(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13) \
+    metamacro_foreach_cxt_recursive13(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) \
+    SEP \
+    MACRO(13, CONTEXT, _13)
+
+#define metamacro_foreach_cxt_recursive15(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14) \
+    metamacro_foreach_cxt_recursive14(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13) \
+    SEP \
+    MACRO(14, CONTEXT, _14)
+
+#define metamacro_foreach_cxt_recursive16(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) \
+    metamacro_foreach_cxt_recursive15(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14) \
+    SEP \
+    MACRO(15, CONTEXT, _15)
+
+#define metamacro_foreach_cxt_recursive17(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) \
+    metamacro_foreach_cxt_recursive16(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) \
+    SEP \
+    MACRO(16, CONTEXT, _16)
+
+#define metamacro_foreach_cxt_recursive18(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17) \
+    metamacro_foreach_cxt_recursive17(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) \
+    SEP \
+    MACRO(17, CONTEXT, _17)
+
+#define metamacro_foreach_cxt_recursive19(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18) \
+    metamacro_foreach_cxt_recursive18(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17) \
+    SEP \
+    MACRO(18, CONTEXT, _18)
+
+#define metamacro_foreach_cxt_recursive20(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19) \
+    metamacro_foreach_cxt_recursive19(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18) \
+    SEP \
+    MACRO(19, CONTEXT, _19)
+
+// metamacro_for_cxt expansions
+#define metamacro_for_cxt0(MACRO, SEP, CONTEXT)
+#define metamacro_for_cxt1(MACRO, SEP, CONTEXT) MACRO(0, CONTEXT)
+
+#define metamacro_for_cxt2(MACRO, SEP, CONTEXT) \
+    metamacro_for_cxt1(MACRO, SEP, CONTEXT) \
+    SEP \
+    MACRO(1, CONTEXT)
+
+#define metamacro_for_cxt3(MACRO, SEP, CONTEXT) \
+    metamacro_for_cxt2(MACRO, SEP, CONTEXT) \
+    SEP \
+    MACRO(2, CONTEXT)
+
+#define metamacro_for_cxt4(MACRO, SEP, CONTEXT) \
+    metamacro_for_cxt3(MACRO, SEP, CONTEXT) \
+    SEP \
+    MACRO(3, CONTEXT)
+
+#define metamacro_for_cxt5(MACRO, SEP, CONTEXT) \
+    metamacro_for_cxt4(MACRO, SEP, CONTEXT) \
+    SEP \
+    MACRO(4, CONTEXT)
+
+#define metamacro_for_cxt6(MACRO, SEP, CONTEXT) \
+    metamacro_for_cxt5(MACRO, SEP, CONTEXT) \
+    SEP \
+    MACRO(5, CONTEXT)
+
+#define metamacro_for_cxt7(MACRO, SEP, CONTEXT) \
+    metamacro_for_cxt6(MACRO, SEP, CONTEXT) \
+    SEP \
+    MACRO(6, CONTEXT)
+
+#define metamacro_for_cxt8(MACRO, SEP, CONTEXT) \
+    metamacro_for_cxt7(MACRO, SEP, CONTEXT) \
+    SEP \
+    MACRO(7, CONTEXT)
+
+#define metamacro_for_cxt9(MACRO, SEP, CONTEXT) \
+    metamacro_for_cxt8(MACRO, SEP, CONTEXT) \
+    SEP \
+    MACRO(8, CONTEXT)
+
+#define metamacro_for_cxt10(MACRO, SEP, CONTEXT) \
+    metamacro_for_cxt9(MACRO, SEP, CONTEXT) \
+    SEP \
+    MACRO(9, CONTEXT)
+
+#define metamacro_for_cxt11(MACRO, SEP, CONTEXT) \
+    metamacro_for_cxt10(MACRO, SEP, CONTEXT) \
+    SEP \
+    MACRO(10, CONTEXT)
+
+#define metamacro_for_cxt12(MACRO, SEP, CONTEXT) \
+    metamacro_for_cxt11(MACRO, SEP, CONTEXT) \
+    SEP \
+    MACRO(11, CONTEXT)
+
+#define metamacro_for_cxt13(MACRO, SEP, CONTEXT) \
+    metamacro_for_cxt12(MACRO, SEP, CONTEXT) \
+    SEP \
+    MACRO(12, CONTEXT)
+
+#define metamacro_for_cxt14(MACRO, SEP, CONTEXT) \
+    metamacro_for_cxt13(MACRO, SEP, CONTEXT) \
+    SEP \
+    MACRO(13, CONTEXT)
+
+#define metamacro_for_cxt15(MACRO, SEP, CONTEXT) \
+    metamacro_for_cxt14(MACRO, SEP, CONTEXT) \
+    SEP \
+    MACRO(14, CONTEXT)
+
+#define metamacro_for_cxt16(MACRO, SEP, CONTEXT) \
+    metamacro_for_cxt15(MACRO, SEP, CONTEXT) \
+    SEP \
+    MACRO(15, CONTEXT)
+
+#define metamacro_for_cxt17(MACRO, SEP, CONTEXT) \
+    metamacro_for_cxt16(MACRO, SEP, CONTEXT) \
+    SEP \
+    MACRO(16, CONTEXT)
+
+#define metamacro_for_cxt18(MACRO, SEP, CONTEXT) \
+    metamacro_for_cxt17(MACRO, SEP, CONTEXT) \
+    SEP \
+    MACRO(17, CONTEXT)
+
+#define metamacro_for_cxt19(MACRO, SEP, CONTEXT) \
+    metamacro_for_cxt18(MACRO, SEP, CONTEXT) \
+    SEP \
+    MACRO(18, CONTEXT)
+
+#define metamacro_for_cxt20(MACRO, SEP, CONTEXT) \
+    metamacro_for_cxt19(MACRO, SEP, CONTEXT) \
+    SEP \
+    MACRO(19, CONTEXT)
+
+// metamacro_if_eq expansions
+#define metamacro_if_eq0(VALUE) \
+    metamacro_concat(metamacro_if_eq0_, VALUE)
+
+#define metamacro_if_eq0_0(...) __VA_ARGS__ metamacro_consume_
+#define metamacro_if_eq0_1(...) metamacro_expand_
+#define metamacro_if_eq0_2(...) metamacro_expand_
+#define metamacro_if_eq0_3(...) metamacro_expand_
+#define metamacro_if_eq0_4(...) metamacro_expand_
+#define metamacro_if_eq0_5(...) metamacro_expand_
+#define metamacro_if_eq0_6(...) metamacro_expand_
+#define metamacro_if_eq0_7(...) metamacro_expand_
+#define metamacro_if_eq0_8(...) metamacro_expand_
+#define metamacro_if_eq0_9(...) metamacro_expand_
+#define metamacro_if_eq0_10(...) metamacro_expand_
+#define metamacro_if_eq0_11(...) metamacro_expand_
+#define metamacro_if_eq0_12(...) metamacro_expand_
+#define metamacro_if_eq0_13(...) metamacro_expand_
+#define metamacro_if_eq0_14(...) metamacro_expand_
+#define metamacro_if_eq0_15(...) metamacro_expand_
+#define metamacro_if_eq0_16(...) metamacro_expand_
+#define metamacro_if_eq0_17(...) metamacro_expand_
+#define metamacro_if_eq0_18(...) metamacro_expand_
+#define metamacro_if_eq0_19(...) metamacro_expand_
+#define metamacro_if_eq0_20(...) metamacro_expand_
+
+#define metamacro_if_eq1(VALUE) metamacro_if_eq0(metamacro_dec(VALUE))
+#define metamacro_if_eq2(VALUE) metamacro_if_eq1(metamacro_dec(VALUE))
+#define metamacro_if_eq3(VALUE) metamacro_if_eq2(metamacro_dec(VALUE))
+#define metamacro_if_eq4(VALUE) metamacro_if_eq3(metamacro_dec(VALUE))
+#define metamacro_if_eq5(VALUE) metamacro_if_eq4(metamacro_dec(VALUE))
+#define metamacro_if_eq6(VALUE) metamacro_if_eq5(metamacro_dec(VALUE))
+#define metamacro_if_eq7(VALUE) metamacro_if_eq6(metamacro_dec(VALUE))
+#define metamacro_if_eq8(VALUE) metamacro_if_eq7(metamacro_dec(VALUE))
+#define metamacro_if_eq9(VALUE) metamacro_if_eq8(metamacro_dec(VALUE))
+#define metamacro_if_eq10(VALUE) metamacro_if_eq9(metamacro_dec(VALUE))
+#define metamacro_if_eq11(VALUE) metamacro_if_eq10(metamacro_dec(VALUE))
+#define metamacro_if_eq12(VALUE) metamacro_if_eq11(metamacro_dec(VALUE))
+#define metamacro_if_eq13(VALUE) metamacro_if_eq12(metamacro_dec(VALUE))
+#define metamacro_if_eq14(VALUE) metamacro_if_eq13(metamacro_dec(VALUE))
+#define metamacro_if_eq15(VALUE) metamacro_if_eq14(metamacro_dec(VALUE))
+#define metamacro_if_eq16(VALUE) metamacro_if_eq15(metamacro_dec(VALUE))
+#define metamacro_if_eq17(VALUE) metamacro_if_eq16(metamacro_dec(VALUE))
+#define metamacro_if_eq18(VALUE) metamacro_if_eq17(metamacro_dec(VALUE))
+#define metamacro_if_eq19(VALUE) metamacro_if_eq18(metamacro_dec(VALUE))
+#define metamacro_if_eq20(VALUE) metamacro_if_eq19(metamacro_dec(VALUE))
+
+// metamacro_if_eq_recursive expansions
+#define metamacro_if_eq_recursive0(VALUE) \
+    metamacro_concat(metamacro_if_eq_recursive0_, VALUE)
+
+#define metamacro_if_eq_recursive0_0(...) __VA_ARGS__ metamacro_consume_
+#define metamacro_if_eq_recursive0_1(...) metamacro_expand_
+#define metamacro_if_eq_recursive0_2(...) metamacro_expand_
+#define metamacro_if_eq_recursive0_3(...) metamacro_expand_
+#define metamacro_if_eq_recursive0_4(...) metamacro_expand_
+#define metamacro_if_eq_recursive0_5(...) metamacro_expand_
+#define metamacro_if_eq_recursive0_6(...) metamacro_expand_
+#define metamacro_if_eq_recursive0_7(...) metamacro_expand_
+#define metamacro_if_eq_recursive0_8(...) metamacro_expand_
+#define metamacro_if_eq_recursive0_9(...) metamacro_expand_
+#define metamacro_if_eq_recursive0_10(...) metamacro_expand_
+#define metamacro_if_eq_recursive0_11(...) metamacro_expand_
+#define metamacro_if_eq_recursive0_12(...) metamacro_expand_
+#define metamacro_if_eq_recursive0_13(...) metamacro_expand_
+#define metamacro_if_eq_recursive0_14(...) metamacro_expand_
+#define metamacro_if_eq_recursive0_15(...) metamacro_expand_
+#define metamacro_if_eq_recursive0_16(...) metamacro_expand_
+#define metamacro_if_eq_recursive0_17(...) metamacro_expand_
+#define metamacro_if_eq_recursive0_18(...) metamacro_expand_
+#define metamacro_if_eq_recursive0_19(...) metamacro_expand_
+#define metamacro_if_eq_recursive0_20(...) metamacro_expand_
+
+#define metamacro_if_eq_recursive1(VALUE) metamacro_if_eq_recursive0(metamacro_dec(VALUE))
+#define metamacro_if_eq_recursive2(VALUE) metamacro_if_eq_recursive1(metamacro_dec(VALUE))
+#define metamacro_if_eq_recursive3(VALUE) metamacro_if_eq_recursive2(metamacro_dec(VALUE))
+#define metamacro_if_eq_recursive4(VALUE) metamacro_if_eq_recursive3(metamacro_dec(VALUE))
+#define metamacro_if_eq_recursive5(VALUE) metamacro_if_eq_recursive4(metamacro_dec(VALUE))
+#define metamacro_if_eq_recursive6(VALUE) metamacro_if_eq_recursive5(metamacro_dec(VALUE))
+#define metamacro_if_eq_recursive7(VALUE) metamacro_if_eq_recursive6(metamacro_dec(VALUE))
+#define metamacro_if_eq_recursive8(VALUE) metamacro_if_eq_recursive7(metamacro_dec(VALUE))
+#define metamacro_if_eq_recursive9(VALUE) metamacro_if_eq_recursive8(metamacro_dec(VALUE))
+#define metamacro_if_eq_recursive10(VALUE) metamacro_if_eq_recursive9(metamacro_dec(VALUE))
+#define metamacro_if_eq_recursive11(VALUE) metamacro_if_eq_recursive10(metamacro_dec(VALUE))
+#define metamacro_if_eq_recursive12(VALUE) metamacro_if_eq_recursive11(metamacro_dec(VALUE))
+#define metamacro_if_eq_recursive13(VALUE) metamacro_if_eq_recursive12(metamacro_dec(VALUE))
+#define metamacro_if_eq_recursive14(VALUE) metamacro_if_eq_recursive13(metamacro_dec(VALUE))
+#define metamacro_if_eq_recursive15(VALUE) metamacro_if_eq_recursive14(metamacro_dec(VALUE))
+#define metamacro_if_eq_recursive16(VALUE) metamacro_if_eq_recursive15(metamacro_dec(VALUE))
+#define metamacro_if_eq_recursive17(VALUE) metamacro_if_eq_recursive16(metamacro_dec(VALUE))
+#define metamacro_if_eq_recursive18(VALUE) metamacro_if_eq_recursive17(metamacro_dec(VALUE))
+#define metamacro_if_eq_recursive19(VALUE) metamacro_if_eq_recursive18(metamacro_dec(VALUE))
+#define metamacro_if_eq_recursive20(VALUE) metamacro_if_eq_recursive19(metamacro_dec(VALUE))
+
+// metamacro_take expansions
+#define metamacro_take0(...)
+#define metamacro_take1(...) metamacro_head(__VA_ARGS__)
+#define metamacro_take2(...) metamacro_head(__VA_ARGS__), metamacro_take1(metamacro_tail(__VA_ARGS__))
+#define metamacro_take3(...) metamacro_head(__VA_ARGS__), metamacro_take2(metamacro_tail(__VA_ARGS__))
+#define metamacro_take4(...) metamacro_head(__VA_ARGS__), metamacro_take3(metamacro_tail(__VA_ARGS__))
+#define metamacro_take5(...) metamacro_head(__VA_ARGS__), metamacro_take4(metamacro_tail(__VA_ARGS__))
+#define metamacro_take6(...) metamacro_head(__VA_ARGS__), metamacro_take5(metamacro_tail(__VA_ARGS__))
+#define metamacro_take7(...) metamacro_head(__VA_ARGS__), metamacro_take6(metamacro_tail(__VA_ARGS__))
+#define metamacro_take8(...) metamacro_head(__VA_ARGS__), metamacro_take7(metamacro_tail(__VA_ARGS__))
+#define metamacro_take9(...) metamacro_head(__VA_ARGS__), metamacro_take8(metamacro_tail(__VA_ARGS__))
+#define metamacro_take10(...) metamacro_head(__VA_ARGS__), metamacro_take9(metamacro_tail(__VA_ARGS__))
+#define metamacro_take11(...) metamacro_head(__VA_ARGS__), metamacro_take10(metamacro_tail(__VA_ARGS__))
+#define metamacro_take12(...) metamacro_head(__VA_ARGS__), metamacro_take11(metamacro_tail(__VA_ARGS__))
+#define metamacro_take13(...) metamacro_head(__VA_ARGS__), metamacro_take12(metamacro_tail(__VA_ARGS__))
+#define metamacro_take14(...) metamacro_head(__VA_ARGS__), metamacro_take13(metamacro_tail(__VA_ARGS__))
+#define metamacro_take15(...) metamacro_head(__VA_ARGS__), metamacro_take14(metamacro_tail(__VA_ARGS__))
+#define metamacro_take16(...) metamacro_head(__VA_ARGS__), metamacro_take15(metamacro_tail(__VA_ARGS__))
+#define metamacro_take17(...) metamacro_head(__VA_ARGS__), metamacro_take16(metamacro_tail(__VA_ARGS__))
+#define metamacro_take18(...) metamacro_head(__VA_ARGS__), metamacro_take17(metamacro_tail(__VA_ARGS__))
+#define metamacro_take19(...) metamacro_head(__VA_ARGS__), metamacro_take18(metamacro_tail(__VA_ARGS__))
+#define metamacro_take20(...) metamacro_head(__VA_ARGS__), metamacro_take19(metamacro_tail(__VA_ARGS__))
+
+// metamacro_drop expansions
+#define metamacro_drop0(...) __VA_ARGS__
+#define metamacro_drop1(...) metamacro_tail(__VA_ARGS__)
+#define metamacro_drop2(...) metamacro_drop1(metamacro_tail(__VA_ARGS__))
+#define metamacro_drop3(...) metamacro_drop2(metamacro_tail(__VA_ARGS__))
+#define metamacro_drop4(...) metamacro_drop3(metamacro_tail(__VA_ARGS__))
+#define metamacro_drop5(...) metamacro_drop4(metamacro_tail(__VA_ARGS__))
+#define metamacro_drop6(...) metamacro_drop5(metamacro_tail(__VA_ARGS__))
+#define metamacro_drop7(...) metamacro_drop6(metamacro_tail(__VA_ARGS__))
+#define metamacro_drop8(...) metamacro_drop7(metamacro_tail(__VA_ARGS__))
+#define metamacro_drop9(...) metamacro_drop8(metamacro_tail(__VA_ARGS__))
+#define metamacro_drop10(...) metamacro_drop9(metamacro_tail(__VA_ARGS__))
+#define metamacro_drop11(...) metamacro_drop10(metamacro_tail(__VA_ARGS__))
+#define metamacro_drop12(...) metamacro_drop11(metamacro_tail(__VA_ARGS__))
+#define metamacro_drop13(...) metamacro_drop12(metamacro_tail(__VA_ARGS__))
+#define metamacro_drop14(...) metamacro_drop13(metamacro_tail(__VA_ARGS__))
+#define metamacro_drop15(...) metamacro_drop14(metamacro_tail(__VA_ARGS__))
+#define metamacro_drop16(...) metamacro_drop15(metamacro_tail(__VA_ARGS__))
+#define metamacro_drop17(...) metamacro_drop16(metamacro_tail(__VA_ARGS__))
+#define metamacro_drop18(...) metamacro_drop17(metamacro_tail(__VA_ARGS__))
+#define metamacro_drop19(...) metamacro_drop18(metamacro_tail(__VA_ARGS__))
+#define metamacro_drop20(...) metamacro_drop19(metamacro_tail(__VA_ARGS__))
+
+#endif
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/NSControlRACSupportSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/NSControlRACSupportSpec.m
new file mode 100644
index 0000000..1825277
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/NSControlRACSupportSpec.m
@@ -0,0 +1,106 @@
+//
+//  NSControlRACSupportSpec.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 9/4/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACControlCommandExamples.h"
+
+#import "NSControl+RACCommandSupport.h"
+#import "NSControl+RACTextSignalSupport.h"
+#import "NSObject+RACDeallocating.h"
+#import "NSObject+RACPropertySubscribing.h"
+#import "RACCommand.h"
+#import "RACCompoundDisposable.h"
+#import "RACDisposable.h"
+#import "RACSubject.h"
+
+SpecBegin(NSControlRACSupport)
+
+describe(@"NSButton", ^{
+	__block NSButton *button;
+
+	beforeEach(^{
+		button = [[NSButton alloc] initWithFrame:NSZeroRect];
+		expect(button).notTo.beNil();
+	});
+
+	itShouldBehaveLike(RACControlCommandExamples, ^{
+		return @{
+			RACControlCommandExampleControl: button,
+			RACControlCommandExampleActivateBlock: ^(NSButton *button) {
+				[button performClick:nil];
+			}
+		};
+	});
+});
+
+describe(@"NSTextField", ^{
+	__block NSTextField *field;
+	__block NSWindow *window;
+	
+	beforeEach(^{
+		field = [[NSTextField alloc] initWithFrame:NSZeroRect];
+		expect(field).notTo.beNil();
+
+		[field.cell setSendsActionOnEndEditing:YES];
+
+		window = [[NSWindow alloc] initWithContentRect:NSZeroRect styleMask:NSTitledWindowMask backing:NSBackingStoreBuffered defer:NO];
+		expect(window).notTo.beNil();
+
+		[window.contentView addSubview:field];
+
+		expect([window makeFirstResponder:field]).to.beTruthy();
+		expect(window.firstResponder).notTo.equal(window);
+	});
+
+	itShouldBehaveLike(RACControlCommandExamples, ^{
+		return @{
+			RACControlCommandExampleControl: field,
+			RACControlCommandExampleActivateBlock: ^(NSTextField *field) {
+				expect([window makeFirstResponder:nil]).to.beTruthy();
+				expect(window.firstResponder).to.equal(window);
+			}
+		};
+	});
+
+	describe(@"-rac_textSignal", ^{
+		it(@"should send changes", ^{
+			NSMutableArray *strings = [NSMutableArray array];
+			[field.rac_textSignal subscribeNext:^(NSString *str) {
+				[strings addObject:str];
+			}];
+
+			expect(strings).to.equal(@[ @"" ]);
+
+			NSText *fieldEditor = (id)window.firstResponder;
+			expect(fieldEditor).to.beKindOf(NSText.class);
+
+			[fieldEditor insertText:@"f"];
+			[fieldEditor insertText:@"o"];
+			[fieldEditor insertText:@"b"];
+
+			NSArray *expected = @[ @"", @"f", @"fo", @"fob" ];
+			expect(strings).to.equal(expected);
+		});
+
+		it(@"shouldn't give the text field eternal life", ^{
+			__block BOOL dealloced = NO;
+			@autoreleasepool {
+				NSTextField *field __attribute__((objc_precise_lifetime)) = [[NSTextField alloc] initWithFrame:CGRectZero];
+				[field.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+					dealloced = YES;
+				}]];
+				[field.rac_textSignal subscribeNext:^(id x) {
+
+				}];
+			}
+
+			expect(dealloced).will.beTruthy();
+		});
+	});
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/NSControllerRACSupportSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/NSControllerRACSupportSpec.m
new file mode 100644
index 0000000..d309b25
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/NSControllerRACSupportSpec.m
@@ -0,0 +1,44 @@
+//
+//  NSControllerRACSupportSpec.m
+//  ReactiveCocoa
+//
+//  Created by Uri Baghin on 26/10/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <AppKit/AppKit.h>
+#import "RACKVOChannel.h"
+
+@interface RACTestController : NSController
+
+@property (nonatomic, strong) id object;
+
+@end
+
+@implementation RACTestController
+
+@end
+
+SpecBegin(NSControllerRACSupport)
+
+it(@"RACKVOChannel should support NSController", ^{
+	RACTestController *a = [[RACTestController alloc] init];
+	RACTestController *b = [[RACTestController alloc] init];
+	RACChannelTo(a, object) = RACChannelTo(b, object);
+	expect(a.object).to.beNil();
+	expect(b.object).to.beNil();
+
+	a.object = a;
+	expect(a.object).to.equal(a);
+	expect(b.object).to.equal(a);
+
+	b.object = b;
+	expect(a.object).to.equal(b);
+	expect(b.object).to.equal(b);
+
+	a.object = nil;
+	expect(a.object).to.beNil();
+	expect(b.object).to.beNil();
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/NSEnumeratorRACSequenceAdditionsSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/NSEnumeratorRACSequenceAdditionsSpec.m
new file mode 100644
index 0000000..50328bd
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/NSEnumeratorRACSequenceAdditionsSpec.m
@@ -0,0 +1,25 @@
+//
+//  NSEnumeratorRACSequenceAdditionsSpec.m
+//  ReactiveCocoa
+//
+//  Created by Uri Baghin on 07/01/2013.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSequenceExamples.h"
+
+#import "NSEnumerator+RACSequenceAdditions.h"
+
+SpecBegin(NSEnumeratorRACSequenceAdditions)
+
+describe(@"-rac_sequence", ^{
+	NSArray *values = @[ @0, @1, @2, @3, @4 ];
+	itShouldBehaveLike(RACSequenceExamples, ^{
+		return @{
+			RACSequenceExampleSequence: values.objectEnumerator.rac_sequence,
+			RACSequenceExampleExpectedValues: values
+		};
+	});
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/NSNotificationCenterRACSupportSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/NSNotificationCenterRACSupportSpec.m
new file mode 100644
index 0000000..26143df
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/NSNotificationCenterRACSupportSpec.m
@@ -0,0 +1,84 @@
+//
+//  NSNotificationCenterRACSupportSpec.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-12-07.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "NSNotificationCenter+RACSupport.h"
+#import "RACSignal.h"
+#import "RACCompoundDisposable.h"
+#import "RACDisposable.h"
+#import "NSObject+RACDeallocating.h"
+
+static NSString * const TestNotification = @"TestNotification";
+
+SpecBegin(NSNotificationCenterRACSupport)
+
+__block NSNotificationCenter *notificationCenter;
+
+beforeEach(^{
+	// The compiler gets confused and thinks you might be messaging
+	// NSDistributedNotificationCenter otherwise. Wtf?
+	notificationCenter = NSNotificationCenter.defaultCenter;
+});
+
+it(@"should send the notification when posted by any object", ^{
+	RACSignal *signal = [notificationCenter rac_addObserverForName:TestNotification object:nil];
+
+	__block NSUInteger count = 0;
+	[signal subscribeNext:^(NSNotification *notification) {
+		++count;
+
+		expect(notification).to.beKindOf(NSNotification.class);
+		expect(notification.name).to.equal(TestNotification);
+	}];
+
+	expect(count).to.equal(0);
+
+	[notificationCenter postNotificationName:TestNotification object:nil];
+	expect(count).to.equal(1);
+
+	[notificationCenter postNotificationName:TestNotification object:self];
+	expect(count).to.equal(2);
+});
+
+it(@"should send the notification when posted by a specific object", ^{
+	RACSignal *signal = [notificationCenter rac_addObserverForName:TestNotification object:self];
+
+	__block NSUInteger count = 0;
+	[signal subscribeNext:^(NSNotification *notification) {
+		++count;
+
+		expect(notification).to.beKindOf(NSNotification.class);
+		expect(notification.name).to.equal(TestNotification);
+		expect(notification.object).to.equal(self);
+	}];
+
+	expect(count).to.equal(0);
+
+	[notificationCenter postNotificationName:TestNotification object:nil];
+	expect(count).to.equal(0);
+
+	[notificationCenter postNotificationName:TestNotification object:self];
+	expect(count).to.equal(1);
+});
+
+it(@"shouldn't strongly capture the notification object", ^{
+	RACSignal *signal __attribute__((objc_precise_lifetime, unused));
+	
+	__block BOOL dealloced = NO;
+	@autoreleasepool {
+		NSObject *notificationObject = [[NSObject alloc] init];
+		[notificationObject.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+			dealloced = YES;
+		}]];
+		
+		signal = [notificationCenter rac_addObserverForName:TestNotification object:notificationObject];
+	}
+
+	expect(dealloced).to.beTruthy();
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACAppKitBindingsSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACAppKitBindingsSpec.m
new file mode 100644
index 0000000..fcb4837
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACAppKitBindingsSpec.m
@@ -0,0 +1,36 @@
+//
+//  NSObjectRACAppKitBindingsSpec.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-07-01.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACChannelExamples.h"
+
+#import "EXTKeyPathCoding.h"
+#import "NSObject+RACAppKitBindings.h"
+
+SpecBegin(NSObjectRACAppKitBindings)
+
+itShouldBehaveLike(RACViewChannelExamples, ^{
+	return @{
+		RACViewChannelExampleCreateViewBlock: ^{
+			return [[NSSlider alloc] initWithFrame:NSZeroRect];
+		},
+		RACViewChannelExampleCreateTerminalBlock: ^(NSSlider *view) {
+			return [view rac_channelToBinding:NSValueBinding];
+		},
+		RACViewChannelExampleKeyPath: @keypath(NSSlider.new, objectValue),
+		RACViewChannelExampleSetViewValueBlock: ^(NSSlider *view, NSNumber *value) {
+			view.objectValue = value;
+
+			// Bindings don't actually trigger from programmatic modification. Do it
+			// manually.
+			NSDictionary *bindingInfo = [view infoForBinding:NSValueBinding];
+			[bindingInfo[NSObservedObjectKey] setValue:value forKeyPath:bindingInfo[NSObservedKeyPathKey]];
+		}
+	};
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACDeallocatingSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACDeallocatingSpec.m
new file mode 100644
index 0000000..b5e80b2
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACDeallocatingSpec.m
@@ -0,0 +1,195 @@
+//
+//  NSObject+RACDeallocating.m
+//  ReactiveCocoa
+//
+//  Created by Kazuo Koga on 2013/03/15.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACTestObject.h"
+
+#import "NSObject+RACDeallocating.h"
+#import "RACCompoundDisposable.h"
+#import "RACDisposable.h"
+#import "RACSignal+Operations.h"
+#import <objc/runtime.h>
+
+@interface RACDeallocSwizzlingTestClass : NSObject
+@end
+
+@implementation RACDeallocSwizzlingTestClass
+
+- (void)dealloc {
+	// Provide an empty implementation just so we can swizzle it.
+}
+
+@end
+
+@interface RACDeallocSwizzlingTestSubclass : RACDeallocSwizzlingTestClass
+@end
+
+@implementation RACDeallocSwizzlingTestSubclass
+@end
+
+SpecBegin(NSObjectRACDeallocatingSpec)
+
+describe(@"-dealloc swizzling", ^{
+	SEL selector = NSSelectorFromString(@"dealloc");
+
+	it(@"should not invoke superclass -dealloc method twice", ^{
+		__block NSUInteger superclassDeallocatedCount = 0;
+		__block BOOL subclassDeallocated = NO;
+
+		@autoreleasepool {
+			RACDeallocSwizzlingTestSubclass *object __attribute__((objc_precise_lifetime)) = [[RACDeallocSwizzlingTestSubclass alloc] init];
+
+			Method oldDeallocMethod = class_getInstanceMethod(RACDeallocSwizzlingTestClass.class, selector);
+			void (*oldDealloc)(id, SEL) = (__typeof__(oldDealloc))method_getImplementation(oldDeallocMethod);
+
+			id newDealloc = ^(__unsafe_unretained id self) {
+				superclassDeallocatedCount++;
+				oldDealloc(self, selector);
+			};
+
+			class_replaceMethod(RACDeallocSwizzlingTestClass.class, selector, imp_implementationWithBlock(newDealloc), method_getTypeEncoding(oldDeallocMethod));
+
+			[object.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				subclassDeallocated = YES;
+			}]];
+
+			expect(subclassDeallocated).to.beFalsy();
+			expect(superclassDeallocatedCount).to.equal(0);
+		}
+
+		expect(subclassDeallocated).to.beTruthy();
+		expect(superclassDeallocatedCount).to.equal(1);
+	});
+
+	it(@"should invoke superclass -dealloc method swizzled in after the subclass", ^{
+		__block BOOL superclassDeallocated = NO;
+		__block BOOL subclassDeallocated = NO;
+
+		@autoreleasepool {
+			RACDeallocSwizzlingTestSubclass *object __attribute__((objc_precise_lifetime)) = [[RACDeallocSwizzlingTestSubclass alloc] init];
+			[object.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				subclassDeallocated = YES;
+			}]];
+
+			Method oldDeallocMethod = class_getInstanceMethod(RACDeallocSwizzlingTestClass.class, selector);
+			void (*oldDealloc)(id, SEL) = (__typeof__(oldDealloc))method_getImplementation(oldDeallocMethod);
+
+			id newDealloc = ^(__unsafe_unretained id self) {
+				superclassDeallocated = YES;
+				oldDealloc(self, selector);
+			};
+
+			class_replaceMethod(RACDeallocSwizzlingTestClass.class, selector, imp_implementationWithBlock(newDealloc), method_getTypeEncoding(oldDeallocMethod));
+
+			expect(subclassDeallocated).to.beFalsy();
+			expect(superclassDeallocated).to.beFalsy();
+		}
+
+		expect(subclassDeallocated).to.beTruthy();
+		expect(superclassDeallocated).to.beTruthy();
+	});
+});
+
+describe(@"-rac_deallocDisposable", ^{
+	it(@"should dispose of the disposable when it is dealloc'd", ^{
+		__block BOOL wasDisposed = NO;
+		@autoreleasepool {
+			NSObject *object __attribute__((objc_precise_lifetime)) = [[NSObject alloc] init];
+			[object.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				wasDisposed = YES;
+			}]];
+
+			expect(wasDisposed).to.beFalsy();
+		}
+
+		expect(wasDisposed).to.beTruthy();
+	});
+
+	it(@"should be able to use the object during disposal", ^{
+		@autoreleasepool {
+			RACTestObject *object __attribute__((objc_precise_lifetime)) = [[RACTestObject alloc] init];
+
+			@autoreleasepool {
+				object.objectValue = [@"foo" mutableCopy];
+			}
+
+			__unsafe_unretained RACTestObject *weakObject = object;
+
+			[object.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				expect(weakObject.objectValue).to.equal(@"foo");
+			}]];
+		}
+	});
+});
+
+describe(@"-rac_willDeallocSignal", ^{
+	it(@"should complete on dealloc", ^{
+		__block BOOL completed = NO;
+		@autoreleasepool {
+			[[[[RACTestObject alloc] init] rac_willDeallocSignal] subscribeCompleted:^{
+				completed = YES;
+			}];
+		}
+
+		expect(completed).to.beTruthy();
+	});
+
+	it(@"should not send anything", ^{
+		__block BOOL valueReceived = NO;
+		__block BOOL completed = NO;
+		@autoreleasepool {
+			[[[[RACTestObject alloc] init] rac_willDeallocSignal] subscribeNext:^(id x) {
+				valueReceived = YES;
+			} completed:^{
+				completed = YES;
+			}];
+		}
+
+		expect(valueReceived).to.beFalsy();
+		expect(completed).to.beTruthy();
+	});
+
+	it(@"should complete upon subscription if already deallocated", ^{
+		__block BOOL deallocated = NO;
+
+		RACSignal *signal;
+
+		@autoreleasepool {
+			RACTestObject *object = [[RACTestObject alloc] init];
+
+			signal = [object rac_willDeallocSignal];
+			[signal subscribeCompleted:^{
+				deallocated = YES;
+			}];
+		}
+
+		expect(deallocated).to.beTruthy();
+		expect([signal waitUntilCompleted:NULL]).to.beTruthy();
+	});
+
+	it(@"should complete before the object is invalid", ^{
+		__block NSString *objectValue;
+
+		@autoreleasepool {
+			RACTestObject *object __attribute__((objc_precise_lifetime)) = [[RACTestObject alloc] init];
+
+			@autoreleasepool {
+				object.objectValue = [@"foo" mutableCopy];
+			}
+
+			__unsafe_unretained RACTestObject *weakObject = object;
+
+			[[object rac_willDeallocSignal] subscribeCompleted:^{
+				objectValue = [weakObject.objectValue copy];
+			}];
+		}
+
+		expect(objectValue).to.equal(@"foo");
+	});
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACLiftingSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACLiftingSpec.m
new file mode 100644
index 0000000..7a2acfc
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACLiftingSpec.m
@@ -0,0 +1,407 @@
+//
+//  NSObjectRACLifting.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 10/2/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACTestObject.h"
+
+#import "NSObject+RACLifting.h"
+#import "NSObject+RACDeallocating.h"
+#import "NSObject+RACPropertySubscribing.h"
+#import "RACCompoundDisposable.h"
+#import "RACDisposable.h"
+#import "RACSubject.h"
+#import "RACTuple.h"
+#import "RACUnit.h"
+
+SpecBegin(NSObjectRACLifting)
+
+describe(@"-rac_liftSelector:withSignals:", ^{
+	__block RACTestObject *object;
+
+	beforeEach(^{
+		object = [[RACTestObject alloc] init];
+	});
+
+	it(@"should call the selector with the value of the signal", ^{
+		RACSubject *subject = [RACSubject subject];
+		[object rac_liftSelector:@selector(setObjectValue:) withSignals:subject, nil];
+
+		expect(object.objectValue).to.beNil();
+
+		[subject sendNext:@1];
+		expect(object.objectValue).to.equal(@1);
+
+		[subject sendNext:@42];
+		expect(object.objectValue).to.equal(@42);
+	});
+});
+
+describe(@"-rac_liftSelector:withSignalsFromArray:", ^{
+	__block RACTestObject *object;
+
+	beforeEach(^{
+		object = [[RACTestObject alloc] init];
+	});
+
+	it(@"should call the selector with the value of the signal", ^{
+		RACSubject *subject = [RACSubject subject];
+		[object rac_liftSelector:@selector(setObjectValue:) withSignalsFromArray:@[ subject ]];
+
+		expect(object.objectValue).to.beNil();
+
+		[subject sendNext:@1];
+		expect(object.objectValue).to.equal(@1);
+
+		[subject sendNext:@42];
+		expect(object.objectValue).to.equal(@42);
+	});
+
+	it(@"should call the selector with the value of the signal unboxed", ^{
+		RACSubject *subject = [RACSubject subject];
+		[object rac_liftSelector:@selector(setIntegerValue:) withSignalsFromArray:@[ subject ]];
+
+		expect(object.integerValue).to.equal(0);
+
+		[subject sendNext:@1];
+		expect(object.integerValue).to.equal(1);
+
+		[subject sendNext:@42];
+		expect(object.integerValue).to.equal(42);
+	});
+
+	it(@"should work with multiple arguments", ^{
+		RACSubject *objectValueSubject = [RACSubject subject];
+		RACSubject *integerValueSubject = [RACSubject subject];
+		[object rac_liftSelector:@selector(setObjectValue:andIntegerValue:) withSignalsFromArray:@[ objectValueSubject, integerValueSubject ]];
+
+		expect(object.hasInvokedSetObjectValueAndIntegerValue).to.beFalsy();
+		expect(object.objectValue).to.beNil();
+		expect(object.integerValue).to.equal(0);
+
+		[objectValueSubject sendNext:@1];
+		expect(object.hasInvokedSetObjectValueAndIntegerValue).to.beFalsy();
+		expect(object.objectValue).to.beNil();
+		expect(object.integerValue).to.equal(0);
+
+		[integerValueSubject sendNext:@42];
+		expect(object.hasInvokedSetObjectValueAndIntegerValue).to.beTruthy();
+		expect(object.objectValue).to.equal(@1);
+		expect(object.integerValue).to.equal(42);
+	});
+
+	it(@"should work with signals that immediately start with a value", ^{
+		RACSubject *subject = [RACSubject subject];
+		[object rac_liftSelector:@selector(setObjectValue:) withSignalsFromArray:@[ [subject startWith:@42] ]];
+
+		expect(object.objectValue).to.equal(@42);
+
+		[subject sendNext:@1];
+		expect(object.objectValue).to.equal(@1);
+	});
+
+	it(@"should work with signals that send nil", ^{
+		RACSubject *subject = [RACSubject subject];
+		[object rac_liftSelector:@selector(setObjectValue:) withSignalsFromArray:@[ subject ]];
+
+		[subject sendNext:nil];
+		expect(object.objectValue).to.equal(nil);
+
+		[subject sendNext:RACTupleNil.tupleNil];
+		expect(object.objectValue).to.equal(nil);
+	});
+
+	it(@"should work with integers", ^{
+		RACSubject *subject = [RACSubject subject];
+		[object rac_liftSelector:@selector(setIntegerValue:) withSignalsFromArray:@[ subject ]];
+
+		expect(object.integerValue).to.equal(0);
+
+		[subject sendNext:@1];
+		expect(object.integerValue).to.equal(@1);
+	});
+
+	it(@"should convert between numeric types", ^{
+		RACSubject *subject = [RACSubject subject];
+		[object rac_liftSelector:@selector(setIntegerValue:) withSignalsFromArray:@[ subject ]];
+
+		expect(object.integerValue).to.equal(0);
+
+		[subject sendNext:@1.0];
+		expect(object.integerValue).to.equal(@1);
+	});
+	
+	it(@"should work with class objects", ^{
+		RACSubject *subject = [RACSubject subject];
+		[object rac_liftSelector:@selector(setObjectValue:) withSignalsFromArray:@[ subject ]];
+
+		expect(object.objectValue).to.equal(nil);
+
+		[subject sendNext:self.class];
+		expect(object.objectValue).to.equal(self.class);
+	});
+
+	it(@"should work for char pointer", ^{
+		RACSubject *subject = [RACSubject subject];
+		[object rac_liftSelector:@selector(setCharPointerValue:) withSignalsFromArray:@[ subject ]];
+		
+		expect(object.charPointerValue).to.equal(NULL);
+
+		NSString *string = @"blah blah blah";
+		[subject sendNext:string];
+		expect(@(object.charPointerValue)).to.equal(string);
+	});
+
+	it(@"should work for const char pointer", ^{
+		RACSubject *subject = [RACSubject subject];
+		[object rac_liftSelector:@selector(setConstCharPointerValue:) withSignalsFromArray:@[ subject ]];
+
+		expect(object.constCharPointerValue).to.equal(NULL);
+
+		NSString *string = @"blah blah blah";
+		[subject sendNext:string];
+		expect(@(object.constCharPointerValue)).to.equal(string);
+	});
+
+	it(@"should work for CGRect", ^{
+		RACSubject *subject = [RACSubject subject];
+		[object rac_liftSelector:@selector(setRectValue:) withSignalsFromArray:@[ subject ]];
+
+		expect(object.rectValue).to.equal(CGRectZero);
+
+		CGRect value = CGRectMake(10, 20, 30, 40);
+		[subject sendNext:[NSValue valueWithBytes:&value objCType:@encode(CGRect)]];
+		expect(object.rectValue).to.equal(value);
+	});
+
+	it(@"should work for CGSize", ^{
+		RACSubject *subject = [RACSubject subject];
+		[object rac_liftSelector:@selector(setSizeValue:) withSignalsFromArray:@[ subject ]];
+
+		expect(object.sizeValue).to.equal(CGSizeZero);
+
+		CGSize value = CGSizeMake(10, 20);
+		[subject sendNext:[NSValue valueWithBytes:&value objCType:@encode(CGSize)]];
+		expect(object.sizeValue).to.equal(value);
+	});
+
+	it(@"should work for CGPoint", ^{
+		RACSubject *subject = [RACSubject subject];
+		[object rac_liftSelector:@selector(setPointValue:) withSignalsFromArray:@[ subject ]];
+
+		expect(object.pointValue).to.equal(CGPointZero);
+
+		CGPoint value = CGPointMake(10, 20);
+		[subject sendNext:[NSValue valueWithBytes:&value objCType:@encode(CGPoint)]];
+		expect(object.pointValue).to.equal(value);
+	});
+
+	it(@"should work for NSRange", ^{
+		RACSubject *subject = [RACSubject subject];
+		[object rac_liftSelector:@selector(setRangeValue:) withSignalsFromArray:@[ subject ]];
+
+		expect(NSEqualRanges(object.rangeValue, NSMakeRange(0, 0))).to.beTruthy();
+
+		NSRange value = NSMakeRange(10, 20);
+		[subject sendNext:[NSValue valueWithRange:value]];
+		expect(NSEqualRanges(object.rangeValue, value)).to.beTruthy();
+	});
+
+	it(@"should work for _Bool", ^{
+		RACSubject *subject = [RACSubject subject];
+		[object rac_liftSelector:@selector(setC99BoolValue:) withSignalsFromArray:@[ subject ]];
+
+		expect(object.c99BoolValue).to.beFalsy();
+
+		_Bool value = true;
+		[subject sendNext:@(value)];
+		expect(object.c99BoolValue).to.beTruthy();
+	});
+
+	it(@"should work for primitive pointers", ^{
+		RACSubject *subject = [RACSubject subject];
+		[object rac_liftSelector:@selector(write5ToIntPointer:) withSignalsFromArray:@[ subject ]];
+
+		int value = 0;
+		int *valuePointer = &value;
+		expect(value).to.equal(0);
+
+		[subject sendNext:[NSValue valueWithPointer:valuePointer]];
+		expect(value).to.equal(5);
+	});
+
+	it(@"should work for custom structs", ^{
+		RACSubject *subject = [RACSubject subject];
+		[object rac_liftSelector:@selector(setStructValue:) withSignalsFromArray:@[ subject ]];
+
+		expect(object.structValue.integerField).to.equal(0);
+		expect(object.structValue.doubleField).to.equal(0.0);
+
+		RACTestStruct value = (RACTestStruct){7, 1.23};
+		[subject sendNext:[NSValue valueWithBytes:&value objCType:@encode(typeof(value))]];
+		expect(object.structValue.integerField).to.equal(value.integerField);
+		expect(object.structValue.doubleField).to.equal(value.doubleField);
+	});
+
+	it(@"should send the latest value of the signal as the right argument", ^{
+		RACSubject *subject = [RACSubject subject];
+		[object rac_liftSelector:@selector(setObjectValue:andIntegerValue:) withSignalsFromArray:@[ [RACSignal return:@"object"], subject ]];
+		[subject sendNext:@1];
+
+		expect(object.objectValue).to.equal(@"object");
+		expect(object.integerValue).to.equal(1);
+	});
+
+	describe(@"the returned signal", ^{
+		it(@"should send the return value of the method invocation", ^{
+			RACSubject *objectSubject = [RACSubject subject];
+			RACSubject *integerSubject = [RACSubject subject];
+			RACSignal *signal = [object rac_liftSelector:@selector(combineObjectValue:andIntegerValue:) withSignalsFromArray:@[ objectSubject, integerSubject ]];
+
+			__block NSString *result;
+			[signal subscribeNext:^(id x) {
+				result = x;
+			}];
+
+			[objectSubject sendNext:@"Magic number"];
+			expect(result).to.beNil();
+
+			[integerSubject sendNext:@42];
+			expect(result).to.equal(@"Magic number: 42");
+		});
+
+		it(@"should send RACUnit.defaultUnit for void-returning methods", ^{
+			RACSubject *subject = [RACSubject subject];
+			RACSignal *signal = [object rac_liftSelector:@selector(setObjectValue:) withSignalsFromArray:@[ subject ]];
+
+			__block id result;
+			[signal subscribeNext:^(id x) {
+				result = x;
+			}];
+
+			[subject sendNext:@1];
+
+			expect(result).to.equal(RACUnit.defaultUnit);
+		});
+
+		it(@"should support integer returning methods", ^{
+			RACSubject *subject = [RACSubject subject];
+			RACSignal *signal = [object rac_liftSelector:@selector(doubleInteger:) withSignalsFromArray:@[ subject ]];
+
+			__block id result;
+			[signal subscribeNext:^(id x) {
+				result = x;
+			}];
+
+			[subject sendNext:@1];
+
+			expect(result).to.equal(@2);
+		});
+
+		it(@"should support char * returning methods", ^{
+			RACSubject *subject = [RACSubject subject];
+			RACSignal *signal = [object rac_liftSelector:@selector(doubleString:) withSignalsFromArray:@[ subject ]];
+
+			__block id result;
+			[signal subscribeNext:^(id x) {
+				result = x;
+			}];
+
+			[subject sendNext:@"test"];
+
+			expect(result).to.equal(@"testtest");
+		});
+		
+		it(@"should support const char * returning methods", ^{
+			RACSubject *subject = [RACSubject subject];
+			RACSignal *signal = [object rac_liftSelector:@selector(doubleConstString:) withSignalsFromArray:@[ subject ]];
+
+			__block id result;
+			[signal subscribeNext:^(id x) {
+				result = x;
+			}];
+
+			[subject sendNext:@"test"];
+
+			expect(result).to.equal(@"testtest");
+		});
+		
+		it(@"should support struct returning methods", ^{
+			RACSubject *subject = [RACSubject subject];
+			RACSignal *signal = [object rac_liftSelector:@selector(doubleStruct:) withSignalsFromArray:@[ subject ]];
+
+			__block NSValue *boxedResult;
+			[signal subscribeNext:^(id x) {
+				boxedResult = x;
+			}];
+
+			RACTestStruct value = {4, 12.3};
+			NSValue *boxedValue = [NSValue valueWithBytes:&value objCType:@encode(typeof(value))];
+			[subject sendNext:boxedValue];
+
+			RACTestStruct result = {0, 0.0};
+			[boxedResult getValue:&result];
+			expect(result.integerField).to.equal(8);
+			expect(result.doubleField).to.equal(24.6);
+		});
+		
+		it(@"should support block arguments and returns", ^{
+			RACSubject *subject = [RACSubject subject];
+			RACSignal *signal = [object rac_liftSelector:@selector(wrapBlock:) withSignalsFromArray:@[ subject ]];
+
+			__block BOOL blockInvoked = NO;
+			dispatch_block_t testBlock = ^{
+				blockInvoked = YES;
+			};
+
+			__block dispatch_block_t result;
+			[signal subscribeNext:^(id x) {
+				result = x;
+			}];
+
+			[subject sendNext:testBlock];
+			expect(result).notTo.beNil();
+
+			result();
+			expect(blockInvoked).to.beTruthy();
+		});
+		
+		it(@"should replay the last value", ^{
+			RACSubject *objectSubject = [RACSubject subject];
+			RACSubject *integerSubject = [RACSubject subject];
+			RACSignal *signal = [object rac_liftSelector:@selector(combineObjectValue:andIntegerValue:) withSignalsFromArray:@[ objectSubject, integerSubject ]];
+
+			[objectSubject sendNext:@"Magic number"];
+			[integerSubject sendNext:@42];
+			[integerSubject sendNext:@43];
+
+			__block NSString *result;
+			[signal subscribeNext:^(id x) {
+				result = x;
+			}];
+
+			expect(result).to.equal(@"Magic number: 43");
+		});
+	});
+
+	it(@"shouldn't strongly capture the receiver", ^{
+		__block BOOL dealloced = NO;
+		@autoreleasepool {
+			RACTestObject *testObject __attribute__((objc_precise_lifetime)) = [[RACTestObject alloc] init];
+			[testObject.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				dealloced = YES;
+			}]];
+
+			RACSubject *subject = [RACSubject subject];
+			[testObject rac_liftSelector:@selector(setObjectValue:) withSignalsFromArray:@[ subject ]];
+			[subject sendNext:@1];
+		}
+
+		expect(dealloced).to.beTruthy();
+	});
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACPropertySubscribingExamples.h b/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACPropertySubscribingExamples.h
new file mode 100644
index 0000000..694ce59
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACPropertySubscribingExamples.h
@@ -0,0 +1,16 @@
+//
+//  NSObjectRACPropertySubscribingExamples.h
+//  ReactiveCocoa
+//
+//  Created by Josh Vera on 4/10/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+// The name of the shared examples for a signal-driven observation.
+extern NSString * const RACPropertySubscribingExamples;
+
+// The block should have the signature:
+//   RACSignal * (^)(RACTestObject *testObject, NSString *keyPath, id observer)
+// and should observe the value of the key path on testObject with observer. The value
+// for this key should not be nil.
+extern NSString * const RACPropertySubscribingExamplesSetupBlock;
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACPropertySubscribingExamples.m b/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACPropertySubscribingExamples.m
new file mode 100644
index 0000000..1dae113
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACPropertySubscribingExamples.m
@@ -0,0 +1,279 @@
+//
+//  NSObjectRACPropertySubscribingExamples.m
+//  ReactiveCocoa
+//
+//  Created by Josh Vera on 4/10/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACTestObject.h"
+#import "NSObjectRACPropertySubscribingExamples.h"
+
+#import "EXTScope.h"
+#import "NSObject+RACDeallocating.h"
+#import "NSObject+RACPropertySubscribing.h"
+#import "RACCompoundDisposable.h"
+#import "RACDisposable.h"
+#import "RACSignal.h"
+
+NSString * const RACPropertySubscribingExamples = @"RACPropertySubscribingExamples";
+NSString * const RACPropertySubscribingExamplesSetupBlock = @"RACPropertySubscribingExamplesSetupBlock";
+
+SharedExamplesBegin(NSObjectRACPropertySubscribingExamples)
+
+sharedExamples(RACPropertySubscribingExamples, ^(NSDictionary *data) {
+	__block RACSignal *(^signalBlock)(RACTestObject *object, NSString *keyPath, id observer);
+
+	before(^{
+		signalBlock = data[RACPropertySubscribingExamplesSetupBlock];
+	});
+
+	it(@"should send the current value once on subscription", ^{
+		RACTestObject *object = [[RACTestObject alloc] init];
+		RACSignal *signal = signalBlock(object, @keypath(object, objectValue), self);
+		NSMutableArray *values = [NSMutableArray array];
+
+		object.objectValue = @0;
+		[signal subscribeNext:^(id x) {
+			[values addObject:x];
+		}];
+
+		expect(values).to.equal((@[ @0 ]));
+	});
+
+	it(@"should send the new value when it changes", ^{
+		RACTestObject *object = [[RACTestObject alloc] init];
+		RACSignal *signal = signalBlock(object, @keypath(object, objectValue), self);
+		NSMutableArray *values = [NSMutableArray array];
+
+		object.objectValue = @0;
+		[signal subscribeNext:^(id x) {
+			[values addObject:x];
+		}];
+
+		expect(values).to.equal((@[ @0 ]));
+
+		object.objectValue = @1;
+		expect(values).to.equal((@[ @0, @1 ]));
+
+	});
+
+	it(@"should stop observing when disposed", ^{
+		RACTestObject *object = [[RACTestObject alloc] init];
+		RACSignal *signal = signalBlock(object, @keypath(object, objectValue), self);
+		NSMutableArray *values = [NSMutableArray array];
+
+		object.objectValue = @0;
+		RACDisposable *disposable = [signal subscribeNext:^(id x) {
+			[values addObject:x];
+		}];
+
+		object.objectValue = @1;
+		NSArray *expected = @[ @0, @1 ];
+		expect(values).to.equal(expected);
+
+		[disposable dispose];
+		object.objectValue = @2;
+		expect(values).to.equal(expected);
+	});
+
+	it(@"shouldn't send any more values after the observer is gone", ^{
+		__block BOOL observerDealloced = NO;
+		RACTestObject *object = [[RACTestObject alloc] init];
+		NSMutableArray *values = [NSMutableArray array];
+		@autoreleasepool {
+			RACTestObject *observer __attribute__((objc_precise_lifetime)) = [[RACTestObject alloc] init];
+			[observer.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				observerDealloced = YES;
+			}]];
+
+			RACSignal *signal = signalBlock(object, @keypath(object, objectValue), observer);
+			object.objectValue = @1;
+			[signal subscribeNext:^(id x) {
+				[values addObject:x];
+			}];
+		}
+
+		expect(observerDealloced).to.beTruthy();
+
+		NSArray *expected = @[ @1 ];
+		expect(values).to.equal(expected);
+
+		object.objectValue = @2;
+		expect(values).to.equal(expected);
+	});
+
+	it(@"shouldn't keep either object alive unnaturally long", ^{
+		__block BOOL objectDealloced = NO;
+		__block BOOL scopeObjectDealloced = NO;
+		@autoreleasepool {
+			RACTestObject *object __attribute__((objc_precise_lifetime)) = [[RACTestObject alloc] init];
+			[object.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				objectDealloced = YES;
+			}]];
+			RACTestObject *scopeObject __attribute__((objc_precise_lifetime)) = [[RACTestObject alloc] init];
+			[scopeObject.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				scopeObjectDealloced = YES;
+			}]];
+
+			RACSignal *signal = signalBlock(object, @keypath(object, objectValue), scopeObject);
+
+			[signal subscribeNext:^(id _) {
+
+			}];
+		}
+
+		expect(objectDealloced).to.beTruthy();
+		expect(scopeObjectDealloced).to.beTruthy();
+	});
+
+	it(@"shouldn't keep the signal alive past the lifetime of the object", ^{
+		__block BOOL objectDealloced = NO;
+		__block BOOL signalDealloced = NO;
+		@autoreleasepool {
+			RACTestObject *object __attribute__((objc_precise_lifetime)) = [[RACTestObject alloc] init];
+			[object.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				objectDealloced = YES;
+			}]];
+
+			RACSignal *signal = [signalBlock(object, @keypath(object, objectValue), self) map:^(id value) {
+				return value;
+			}];
+
+			[signal.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				signalDealloced = YES;
+			}]];
+
+			[signal subscribeNext:^(id _) {
+
+			}];
+		}
+
+		expect(signalDealloced).will.beTruthy();
+		expect(objectDealloced).to.beTruthy();
+	});
+
+	it(@"should not resurrect a deallocated object upon subscription", ^{
+		dispatch_queue_t queue = dispatch_queue_create(NULL, DISPATCH_QUEUE_CONCURRENT);
+		@onExit {
+			dispatch_release(queue);
+		};
+
+		dispatch_set_target_queue(queue, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0));
+
+		// Fuzz out race conditions.
+		for (unsigned i = 0; i < 100; i++) {
+			dispatch_suspend(queue);
+
+			__block CFTypeRef object;
+			__block BOOL deallocated;
+
+			RACSignal *signal;
+
+			@autoreleasepool {
+				RACTestObject *testObject = [[RACTestObject alloc] init];
+				[testObject.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+					deallocated = YES;
+				}]];
+
+				signal = signalBlock(testObject, @keypath(testObject, objectValue), nil);
+				object = CFBridgingRetain(testObject);
+			}
+
+			dispatch_block_t testSubscription = ^{
+				RACDisposable *disposable = [signal subscribeCompleted:^{}];
+				expect(disposable).notTo.beNil();
+			};
+
+			unsigned beforeCount = arc4random_uniform(20);
+			for (unsigned j = 0; j < beforeCount; j++) {
+				dispatch_async(queue, testSubscription);
+			}
+
+			dispatch_async(queue, ^{
+				CFRelease(object);
+
+				// expect() is a bit finicky on background threads.
+				STAssertTrue(deallocated, @"Object did not deallocate after being released");
+			});
+
+			unsigned afterCount = arc4random_uniform(20);
+			for (unsigned j = 0; j < afterCount; j++) {
+				dispatch_async(queue, testSubscription);
+			}
+
+			dispatch_barrier_async(queue, testSubscription);
+
+			// Start everything and wait for it all to complete.
+			dispatch_resume(queue);
+
+			expect(deallocated).will.beTruthy();
+			dispatch_barrier_sync(queue, ^{});
+		}
+	});
+
+	it(@"shouldn't crash when the value is changed on a different queue", ^{
+		__block id value;
+		@autoreleasepool {
+			RACTestObject *object __attribute__((objc_precise_lifetime)) = [[RACTestObject alloc] init];
+
+			RACSignal *signal = signalBlock(object, @keypath(object, objectValue), self);
+
+			[signal subscribeNext:^(id x) {
+				value = x;
+			}];
+
+			NSOperationQueue *queue = [[NSOperationQueue alloc] init];
+			[queue addOperationWithBlock:^{
+				object.objectValue = @1;
+			}];
+
+			[queue waitUntilAllOperationsAreFinished];
+		}
+
+		expect(value).will.equal(@1);
+	});
+
+	describe(@"mutating collections", ^{
+		__block RACTestObject *object;
+		__block NSMutableOrderedSet *lastValue;
+		__block NSMutableOrderedSet *proxySet;
+
+		before(^{
+			object = [[RACTestObject alloc] init];
+			object.objectValue = [NSMutableOrderedSet orderedSetWithObject:@1];
+
+			NSString *keyPath = @keypath(object, objectValue);
+
+			[signalBlock(object, keyPath, self) subscribeNext:^(NSMutableOrderedSet *x) {
+				lastValue = x;
+			}];
+
+			proxySet = [object mutableOrderedSetValueForKey:keyPath];
+		});
+
+		it(@"sends the newest object when inserting values into an observed object", ^{
+			NSMutableOrderedSet *expected = [NSMutableOrderedSet orderedSetWithObjects: @1, @2, nil];
+
+			[proxySet addObject:@2];
+			expect(lastValue).to.equal(expected);
+		});
+
+		it(@"sends the newest object when removing values in an observed object", ^{
+			NSMutableOrderedSet *expected = [NSMutableOrderedSet orderedSet];
+
+			[proxySet removeAllObjects];
+			expect(lastValue).to.equal(expected);
+		});
+
+		it(@"sends the newest object when replacing values in an observed object", ^{
+			NSMutableOrderedSet *expected = [NSMutableOrderedSet orderedSetWithObjects: @2, nil];
+
+			[proxySet replaceObjectAtIndex:0 withObject:@2];
+			expect(lastValue).to.equal(expected);
+		});
+	});
+
+});
+
+SharedExamplesEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACPropertySubscribingSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACPropertySubscribingSpec.m
new file mode 100644
index 0000000..1b69c2a
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACPropertySubscribingSpec.m
@@ -0,0 +1,155 @@
+//
+//  NSObjectRACPropertySubscribingSpec.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 9/28/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "NSObjectRACPropertySubscribingExamples.h"
+#import "RACTestObject.h"
+
+#import "NSObject+RACPropertySubscribing.h"
+#import "RACDisposable.h"
+#import "RACSignal.h"
+
+SpecBegin(NSObjectRACPropertySubscribing)
+
+describe(@"-rac_valuesForKeyPath:observer:", ^{
+	id (^setupBlock)(id, id, id) = ^(RACTestObject *object, NSString *keyPath, id observer) {
+		return [object rac_valuesForKeyPath:keyPath observer:observer];
+	};
+
+	itShouldBehaveLike(RACPropertySubscribingExamples, ^{
+		return @{ RACPropertySubscribingExamplesSetupBlock: setupBlock };
+	});
+
+});
+
+describe(@"+rac_signalWithChangesFor:keyPath:options:observer:", ^{
+	describe(@"KVO options argument", ^{
+		__block RACTestObject *object;
+		__block id actual;
+		__block RACSignal *(^objectValueSignal)(NSKeyValueObservingOptions);
+
+		before(^{
+			object = [[RACTestObject alloc] init];
+
+			objectValueSignal = ^(NSKeyValueObservingOptions options) {
+				return [[object rac_valuesAndChangesForKeyPath:@keypath(object, objectValue) options:options observer:self] reduceEach:^(id value, NSDictionary *change) {
+					return change;
+				}];
+			};
+		});
+
+		it(@"sends a KVO dictionary", ^{
+			[objectValueSignal(0) subscribeNext:^(NSDictionary *x) {
+				actual = x;
+			}];
+
+			object.objectValue = @1;
+
+			expect(actual).to.beKindOf(NSDictionary.class);
+		});
+
+		it(@"sends a kind key by default", ^{
+			[objectValueSignal(0) subscribeNext:^(NSDictionary *x) {
+				actual = x[NSKeyValueChangeKindKey];
+			}];
+
+			object.objectValue = @1;
+
+			expect(actual).notTo.beNil();
+		});
+
+		it(@"sends the newest changes with NSKeyValueObservingOptionNew", ^{
+			[objectValueSignal(NSKeyValueObservingOptionNew) subscribeNext:^(NSDictionary *x) {
+				actual = x[NSKeyValueChangeNewKey];
+			}];
+
+			object.objectValue = @1;
+			expect(actual).to.equal(@1);
+
+			object.objectValue = @2;
+			expect(actual).to.equal(@2);
+		});
+
+		it(@"sends an additional change value with NSKeyValueObservingOptionPrior", ^{
+			NSMutableArray *values = [NSMutableArray new];
+			NSArray *expected = @[ @(YES), @(NO) ];
+
+			[objectValueSignal(NSKeyValueObservingOptionPrior) subscribeNext:^(NSDictionary *x) {
+				BOOL isPrior = [x[NSKeyValueChangeNotificationIsPriorKey] boolValue];
+				[values addObject:@(isPrior)];
+			}];
+
+			object.objectValue = @[ @1 ];
+
+			expect(values).to.equal(expected);
+		});
+
+		it(@"sends index changes when adding, inserting or removing a value from an observed object", ^{
+			__block NSUInteger hasIndexesCount = 0;
+
+			[objectValueSignal(0) subscribeNext:^(NSDictionary *x) {
+				if (x[NSKeyValueChangeIndexesKey] != nil) {
+					hasIndexesCount += 1;
+				}
+			}];
+
+			object.objectValue = [NSMutableOrderedSet orderedSet];
+			expect(hasIndexesCount).to.equal(0);
+
+			NSMutableOrderedSet *objectValue = [object mutableOrderedSetValueForKey:@"objectValue"];
+
+			[objectValue addObject:@1];
+			expect(hasIndexesCount).to.equal(1);
+
+			[objectValue replaceObjectAtIndex:0 withObject:@2];
+			expect(hasIndexesCount).to.equal(2);
+
+			[objectValue removeObject:@2];
+			expect(hasIndexesCount).to.equal(3);
+		});
+
+		it(@"sends the previous value with NSKeyValueObservingOptionOld", ^{
+			[objectValueSignal(NSKeyValueObservingOptionOld) subscribeNext:^(NSDictionary *x) {
+				actual = x[NSKeyValueChangeOldKey];
+			}];
+
+			object.objectValue = @1;
+			expect(actual).to.equal(NSNull.null);
+
+			object.objectValue = @2;
+			expect(actual).to.equal(@1);
+		});
+
+		it(@"sends the initial value with NSKeyValueObservingOptionInitial", ^{
+			[objectValueSignal(NSKeyValueObservingOptionInitial | NSKeyValueObservingOptionNew) subscribeNext:^(NSDictionary *x) {
+				actual = x[NSKeyValueChangeNewKey];
+			}];
+			
+			expect(actual).to.equal(NSNull.null);
+		});
+	});
+});
+
+describe(@"-rac_valuesAndChangesForKeyPath:options:observer:", ^{
+	it(@"should complete immediately if the receiver or observer have deallocated", ^{
+		RACSignal *signal;
+		@autoreleasepool {
+			RACTestObject *object __attribute__((objc_precise_lifetime)) = [[RACTestObject alloc] init];
+			RACTestObject *observer __attribute__((objc_precise_lifetime)) = [[RACTestObject alloc] init];
+			signal = [object rac_valuesAndChangesForKeyPath:@keypath(object, stringValue) options:0 observer:observer];
+		}
+
+		__block BOOL completed = NO;
+		[signal subscribeCompleted:^{
+			completed = YES;
+		}];
+
+		expect(completed).to.beTruthy();
+	});
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACSelectorSignalSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACSelectorSignalSpec.m
new file mode 100644
index 0000000..b5b1839
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACSelectorSignalSpec.m
@@ -0,0 +1,434 @@
+//
+//  NSObjectRACSelectorSignalSpec.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 3/18/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACTestObject.h"
+#import "RACSubclassObject.h"
+
+#import "NSObject+RACDeallocating.h"
+#import "NSObject+RACPropertySubscribing.h"
+#import "NSObject+RACSelectorSignal.h"
+#import "RACCompoundDisposable.h"
+#import "RACDisposable.h"
+#import "RACMulticastConnection.h"
+#import "RACSignal+Operations.h"
+#import "RACSignal.h"
+#import "RACTuple.h"
+
+@protocol TestProtocol
+
+@required
+- (BOOL)requiredMethod:(NSUInteger)number;
+- (void)lifeIsGood:(id)sender;
+
+@optional
+- (NSUInteger)optionalMethodWithObject:(id)object flag:(BOOL)flag;
+- (id)objectValue;
+
+@end
+
+SpecBegin(NSObjectRACSelectorSignal)
+
+describe(@"RACTestObject", ^{
+	it(@"should send the argument for each invocation", ^{
+		RACTestObject *object = [[RACTestObject alloc] init];
+		__block id value;
+		[[object rac_signalForSelector:@selector(lifeIsGood:)] subscribeNext:^(RACTuple *x) {
+			value = x.first;
+		}];
+
+		[object lifeIsGood:@42];
+
+		expect(value).to.equal(@42);
+	});
+
+	it(@"should send completed on deallocation", ^{
+		__block BOOL completed = NO;
+		__block BOOL deallocated = NO;
+
+		@autoreleasepool {
+			RACTestObject *object __attribute__((objc_precise_lifetime)) = [[RACTestObject alloc] init];
+
+			[object.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				deallocated = YES;
+			}]];
+
+			[[object rac_signalForSelector:@selector(lifeIsGood:)] subscribeCompleted:^{
+				completed = YES;
+			}];
+
+			expect(deallocated).to.beFalsy();
+			expect(completed).to.beFalsy();
+		}
+
+		expect(deallocated).to.beTruthy();
+		expect(completed).to.beTruthy();
+	});
+
+	it(@"should send for a zero-argument method", ^{
+		RACTestObject *object = [[RACTestObject alloc] init];
+
+		__block RACTuple *value;
+		[[object rac_signalForSelector:@selector(objectValue)] subscribeNext:^(RACTuple *x) {
+			value = x;
+		}];
+
+		[object objectValue];
+		expect(value).to.equal([RACTuple tupleWithObjectsFromArray:@[]]);
+	});
+
+	it(@"should send the argument for each invocation to the instance's own signal", ^{
+		RACTestObject *object1 = [[RACTestObject alloc] init];
+		__block id value1;
+		[[object1 rac_signalForSelector:@selector(lifeIsGood:)] subscribeNext:^(RACTuple *x) {
+			value1 = x.first;
+		}];
+
+		RACTestObject *object2 = [[RACTestObject alloc] init];
+		__block id value2;
+		[[object2 rac_signalForSelector:@selector(lifeIsGood:)] subscribeNext:^(RACTuple *x) {
+			value2 = x.first;
+		}];
+
+		[object1 lifeIsGood:@42];
+		[object2 lifeIsGood:@"Carpe diem"];
+
+		expect(value1).to.equal(@42);
+		expect(value2).to.equal(@"Carpe diem");
+	});
+
+	it(@"should send multiple arguments for each invocation", ^{
+		RACTestObject *object = [[RACTestObject alloc] init];
+
+		__block id value1;
+		__block id value2;
+		[[object rac_signalForSelector:@selector(combineObjectValue:andSecondObjectValue:)] subscribeNext:^(RACTuple *x) {
+			value1 = x.first;
+			value2 = x.second;
+		}];
+
+		expect([object combineObjectValue:@42 andSecondObjectValue:@"foo"]).to.equal(@"42: foo");
+		expect(value1).to.equal(@42);
+		expect(value2).to.equal(@"foo");
+	});
+
+	it(@"should send arguments for invocation of non-existant methods", ^{
+		RACTestObject *object = [[RACTestObject alloc] init];
+		__block id key;
+		__block id value;
+		[[object rac_signalForSelector:@selector(setObject:forKey:)] subscribeNext:^(RACTuple *x) {
+			value = x.first;
+			key = x.second;
+		}];
+
+		[object performSelector:@selector(setObject:forKey:) withObject:@YES withObject:@"Winner"];
+
+		expect(value).to.equal(@YES);
+		expect(key).to.equal(@"Winner");
+	});
+
+	it(@"should send arguments for invocation and invoke the original method on previously KVO'd receiver", ^{
+		RACTestObject *object = [[RACTestObject alloc] init];
+
+		[[RACObserve(object, objectValue) publish] connect];
+
+		__block id key;
+		__block id value;
+		[[object rac_signalForSelector:@selector(setObjectValue:andSecondObjectValue:)] subscribeNext:^(RACTuple *x) {
+			value = x.first;
+			key = x.second;
+		}];
+
+		[object setObjectValue:@YES andSecondObjectValue:@"Winner"];
+
+		expect(object.hasInvokedSetObjectValueAndSecondObjectValue).to.beTruthy();
+		expect(object.objectValue).to.equal(@YES);
+		expect(object.secondObjectValue).to.equal(@"Winner");
+
+		expect(value).to.equal(@YES);
+		expect(key).to.equal(@"Winner");
+	});
+
+	it(@"should send arguments for invocation and invoke the original method when receiver is subsequently KVO'd", ^{
+		RACTestObject *object = [[RACTestObject alloc] init];
+
+		__block id key;
+		__block id value;
+		[[object rac_signalForSelector:@selector(setObjectValue:andSecondObjectValue:)] subscribeNext:^(RACTuple *x) {
+			value = x.first;
+			key = x.second;
+		}];
+
+		[[RACObserve(object, objectValue) publish] connect];
+
+		[object setObjectValue:@YES andSecondObjectValue:@"Winner"];
+
+		expect(object.hasInvokedSetObjectValueAndSecondObjectValue).to.beTruthy();
+		expect(object.objectValue).to.equal(@YES);
+		expect(object.secondObjectValue).to.equal(@"Winner");
+
+		expect(value).to.equal(@YES);
+		expect(key).to.equal(@"Winner");
+	});
+
+	it(@"should properly implement -respondsToSelector: when called on KVO'd receiver", ^{
+		RACTestObject *object = [[RACTestObject alloc] init];
+
+		// First, setup KVO on `object`, which gives us the desired side-effect
+		// of `object` taking on a KVO-custom subclass.
+		[[RACObserve(object, objectValue) publish] connect];
+
+		SEL selector = NSSelectorFromString(@"anyOldSelector:");
+
+		// With the KVO subclass in place, call -rac_signalForSelector: to
+		// implement -anyOldSelector: directly on the KVO subclass.
+		[object rac_signalForSelector:selector];
+
+		expect([object respondsToSelector:selector]).to.beTruthy();
+	});
+	
+	it(@"should properly implement -respondsToSelector: for optional method from a protocol", ^{
+		// Selector for the targeted optional method from a protocol.
+		SEL selector = @selector(optionalProtocolMethodWithObjectValue:);
+
+		RACTestObject *object1 = [[RACTestObject alloc] init];
+
+		// Method implementation of the selector is added to its swizzled class.
+		[object1 rac_signalForSelector:selector fromProtocol:@protocol(RACTestProtocol)];
+
+		expect([object1 respondsToSelector:selector]).to.beTruthy();
+
+		RACTestObject *object2 = [[RACTestObject alloc] init];
+
+		// Call -rac_signalForSelector: to swizzle this instance's class,
+		// method implementations of -respondsToSelector: and
+		// -forwardInvocation:.
+		[object2 rac_signalForSelector:@selector(lifeIsGood:)];
+
+		// This instance should not respond to the selector because of not
+		// calling -rac_signalForSelector: with the selector.
+		expect([object2 respondsToSelector:selector]).to.beFalsy();
+	});
+
+	it(@"should send non-object arguments", ^{
+		RACTestObject *object = [[RACTestObject alloc] init];
+
+		__block id value;
+		[[object rac_signalForSelector:@selector(setIntegerValue:)] subscribeNext:^(RACTuple *x) {
+			value = x.first;
+		}];
+
+		object.integerValue = 42;
+		expect(value).to.equal(@42);
+	});
+
+	it(@"should send on signal after the original method is invoked", ^{
+		RACTestObject *object = [[RACTestObject alloc] init];
+
+		__block BOOL invokedMethodBefore = NO;
+		[[object rac_signalForSelector:@selector(setObjectValue:andSecondObjectValue:)] subscribeNext:^(RACTuple *x) {
+			invokedMethodBefore = object.hasInvokedSetObjectValueAndSecondObjectValue;
+		}];
+		
+		[object setObjectValue:@YES andSecondObjectValue:@"Winner"];
+		expect(invokedMethodBefore).to.beTruthy();
+	});
+});
+
+it(@"should swizzle an NSObject method", ^{
+	NSObject *object = [[NSObject alloc] init];
+
+	__block RACTuple *value;
+	[[object rac_signalForSelector:@selector(description)] subscribeNext:^(RACTuple *x) {
+		value = x;
+	}];
+
+	expect([object description]).notTo.beNil();
+	expect(value).to.equal([RACTuple tupleWithObjectsFromArray:@[]]);
+});
+
+describe(@"a class that already overrides -forwardInvocation:", ^{
+	it(@"should invoke the superclass' implementation", ^{
+		RACSubclassObject *object = [[RACSubclassObject alloc] init];
+
+		__block id value;
+		[[object rac_signalForSelector:@selector(lifeIsGood:)] subscribeNext:^(RACTuple *x) {
+			value = x.first;
+		}];
+
+		[object lifeIsGood:@42];
+		expect(value).to.equal(@42);
+
+		expect(object.forwardedSelector).to.beNil();
+
+		[object performSelector:@selector(allObjects)];
+
+		expect(value).to.equal(@42);
+		expect(object.forwardedSelector).to.equal(@selector(allObjects));
+	});
+
+	it(@"should not infinite recurse when KVO'd after RAC swizzled", ^{
+		RACSubclassObject *object = [[RACSubclassObject alloc] init];
+
+		__block id value;
+		[[object rac_signalForSelector:@selector(lifeIsGood:)] subscribeNext:^(RACTuple *x) {
+			value = x.first;
+		}];
+
+		[[RACObserve(object, objectValue) publish] connect];
+
+		[object lifeIsGood:@42];
+		expect(value).to.equal(@42);
+
+		expect(object.forwardedSelector).to.beNil();
+		[object performSelector:@selector(allObjects)];
+		expect(object.forwardedSelector).to.equal(@selector(allObjects));
+	});
+});
+
+describe(@"two classes in the same hierarchy", ^{
+	__block RACTestObject *superclassObj;
+	__block RACTuple *superclassTuple;
+
+	__block RACSubclassObject *subclassObj;
+	__block RACTuple *subclassTuple;
+
+	beforeEach(^{
+		superclassObj = [[RACTestObject alloc] init];
+		expect(superclassObj).notTo.beNil();
+
+		subclassObj = [[RACSubclassObject alloc] init];
+		expect(subclassObj).notTo.beNil();
+	});
+
+	it(@"should not collide", ^{
+		[[superclassObj rac_signalForSelector:@selector(combineObjectValue:andIntegerValue:)] subscribeNext:^(RACTuple *t) {
+			superclassTuple = t;
+		}];
+
+		[[subclassObj rac_signalForSelector:@selector(combineObjectValue:andIntegerValue:)] subscribeNext:^(RACTuple *t) {
+			subclassTuple = t;
+		}];
+
+		expect([superclassObj combineObjectValue:@"foo" andIntegerValue:42]).to.equal(@"foo: 42");
+
+		NSArray *expectedValues = @[ @"foo", @42 ];
+		expect(superclassTuple.allObjects).to.equal(expectedValues);
+
+		expect([subclassObj combineObjectValue:@"foo" andIntegerValue:42]).to.equal(@"fooSUBCLASS: 42");
+
+		expectedValues = @[ @"foo", @42 ];
+		expect(subclassTuple.allObjects).to.equal(expectedValues);
+	});
+
+	it(@"should not collide when the superclass is invoked asynchronously", ^{
+		[[superclassObj rac_signalForSelector:@selector(setObjectValue:andSecondObjectValue:)] subscribeNext:^(RACTuple *t) {
+			superclassTuple = t;
+		}];
+
+		[[subclassObj rac_signalForSelector:@selector(setObjectValue:andSecondObjectValue:)] subscribeNext:^(RACTuple *t) {
+			subclassTuple = t;
+		}];
+
+		[superclassObj setObjectValue:@"foo" andSecondObjectValue:@"42"];
+		expect(superclassObj.hasInvokedSetObjectValueAndSecondObjectValue).to.beTruthy();
+
+		NSArray *expectedValues = @[ @"foo", @"42" ];
+		expect(superclassTuple.allObjects).to.equal(expectedValues);
+
+		[subclassObj setObjectValue:@"foo" andSecondObjectValue:@"42"];
+		expect(subclassObj.hasInvokedSetObjectValueAndSecondObjectValue).to.beFalsy();
+		expect(subclassObj.hasInvokedSetObjectValueAndSecondObjectValue).will.beTruthy();
+
+		expectedValues = @[ @"foo", @"42" ];
+		expect(subclassTuple.allObjects).to.equal(expectedValues);
+	});
+});
+
+describe(@"-rac_signalForSelector:fromProtocol", ^{
+	__block RACTestObject<TestProtocol> *object;
+	__block Protocol *protocol;
+	
+	beforeEach(^{
+		object = (id)[[RACTestObject alloc] init];
+		expect(object).notTo.beNil();
+
+		protocol = @protocol(TestProtocol);
+		expect(protocol).notTo.beNil();
+	});
+
+	it(@"should not clobber a required method already implemented", ^{
+		__block id value;
+		[[object rac_signalForSelector:@selector(lifeIsGood:) fromProtocol:protocol] subscribeNext:^(RACTuple *x) {
+			value = x.first;
+		}];
+
+		[object lifeIsGood:@42];
+		expect(value).to.equal(@42);
+	});
+
+	it(@"should not clobber an optional method already implemented", ^{
+		object.objectValue = @"foo";
+
+		__block id value;
+		[[object rac_signalForSelector:@selector(objectValue) fromProtocol:protocol] subscribeNext:^(RACTuple *x) {
+			value = x;
+		}];
+
+		expect([object objectValue]).to.equal(@"foo");
+		expect(value).to.equal([RACTuple tupleWithObjectsFromArray:@[]]);
+	});
+
+	it(@"should inject a required method", ^{
+		__block id value;
+		[[object rac_signalForSelector:@selector(requiredMethod:) fromProtocol:protocol] subscribeNext:^(RACTuple *x) {
+			value = x.first;
+		}];
+
+		expect([object requiredMethod:42]).to.beFalsy();
+		expect(value).to.equal(42);
+	});
+
+	it(@"should inject an optional method", ^{
+		__block id value;
+		[[object rac_signalForSelector:@selector(optionalMethodWithObject:flag:) fromProtocol:protocol] subscribeNext:^(RACTuple *x) {
+			value = x;
+		}];
+
+		expect([object optionalMethodWithObject:@"foo" flag:YES]).to.equal(0);
+		expect(value).to.equal(RACTuplePack(@"foo", @YES));
+	});
+});
+
+describe(@"class reporting", ^{
+	__block RACTestObject *object;
+	__block Class originalClass;
+
+	beforeEach(^{
+		object = [[RACTestObject alloc] init];
+		originalClass = object.class;
+	});
+
+	it(@"should report the original class", ^{
+		[object rac_signalForSelector:@selector(lifeIsGood:)];
+		expect(object.class).to.beIdenticalTo(originalClass);
+	});
+
+	it(@"should report the original class when it's KVO'd after dynamically subclassing", ^{
+		[object rac_signalForSelector:@selector(lifeIsGood:)];
+		[[RACObserve(object, objectValue) publish] connect];
+		expect(object.class).to.beIdenticalTo(originalClass);
+	});
+
+	it(@"should report the original class when it's KVO'd before dynamically subclassing", ^{
+		[[RACObserve(object, objectValue) publish] connect];
+		[object rac_signalForSelector:@selector(lifeIsGood:)];
+		expect(object.class).to.beIdenticalTo(originalClass);
+	});
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/NSStringRACKeyPathUtilitiesSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/NSStringRACKeyPathUtilitiesSpec.m
new file mode 100644
index 0000000..72e743a
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/NSStringRACKeyPathUtilitiesSpec.m
@@ -0,0 +1,51 @@
+//
+//  NSStringRACKeyPathUtilitiesSpec.m
+//  ReactiveCocoa
+//
+//  Created by Uri Baghin on 05/05/2013.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "NSString+RACKeyPathUtilities.h"
+
+SpecBegin(NSStringRACKeyPathUtilities)
+
+describe(@"-keyPathComponents", ^{
+	it(@"should return components in the key path", ^{
+		expect(@"self.test.key.path".rac_keyPathComponents).to.equal((@[@"self", @"test", @"key", @"path"]));
+	});
+	
+	it(@"should return nil if given an empty string", ^{
+		expect(@"".rac_keyPathComponents).to.beNil();
+	});
+});
+
+describe(@"-keyPathByDeletingLastKeyPathComponent", ^{
+	it(@"should return the parent key path", ^{
+		expect(@"grandparent.parent.child".rac_keyPathByDeletingLastKeyPathComponent).to.equal(@"grandparent.parent");
+	});
+	
+	it(@"should return nil if given an empty string", ^{
+		expect(@"".rac_keyPathByDeletingLastKeyPathComponent).to.beNil();
+	});
+	
+	it(@"should return nil if given a key path with only one component", ^{
+		expect(@"self".rac_keyPathByDeletingLastKeyPathComponent).to.beNil();
+	});
+});
+
+describe(@"-keyPathByDeletingFirstKeyPathComponent", ^{
+	it(@"should return the remaining key path", ^{
+		expect(@"first.second.third".rac_keyPathByDeletingFirstKeyPathComponent).to.equal(@"second.third");
+	});
+	
+	it(@"should return nil if given an empty string", ^{
+		expect(@"".rac_keyPathByDeletingFirstKeyPathComponent).to.beNil();
+	});
+	
+	it(@"should return nil if given a key path with only one component", ^{
+		expect(@"self".rac_keyPathByDeletingFirstKeyPathComponent).to.beNil();
+	});
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/NSTextRACSupportSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/NSTextRACSupportSpec.m
new file mode 100644
index 0000000..364d0e4
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/NSTextRACSupportSpec.m
@@ -0,0 +1,33 @@
+//
+//  NSTextRACSupportSpec.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-03-08.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "NSText+RACSignalSupport.h"
+#import "RACSignal.h"
+
+SpecBegin(NSTextRACSupport)
+
+it(@"NSTextView should send changes on rac_textSignal", ^{
+	NSTextView *textView = [[NSTextView alloc] initWithFrame:NSZeroRect];
+	expect(textView).notTo.beNil();
+
+	NSMutableArray *strings = [NSMutableArray array];
+	[textView.rac_textSignal subscribeNext:^(NSString *str) {
+		[strings addObject:str];
+	}];
+
+	expect(strings).to.equal(@[ @"" ]);
+
+	[textView insertText:@"f"];
+	[textView insertText:@"o"];
+	[textView insertText:@"b"];
+
+	NSArray *expected = @[ @"", @"f", @"fo", @"fob" ];
+	expect(strings).to.equal(expected);
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/NSURLConnectionRACSupportSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/NSURLConnectionRACSupportSpec.m
new file mode 100644
index 0000000..e7bc8de
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/NSURLConnectionRACSupportSpec.m
@@ -0,0 +1,36 @@
+//
+//  NSURLConnectionRACSupportSpec.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-10-01.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "NSURLConnection+RACSupport.h"
+#import "RACSignal+Operations.h"
+#import "RACTuple.h"
+
+SpecBegin(NSURLConnectionRACSupport)
+
+it(@"should fetch a JSON file", ^{
+	NSURL *fileURL = [[NSBundle bundleForClass:self.class] URLForResource:@"test-data" withExtension:@"json"];
+	expect(fileURL).notTo.beNil();
+
+	NSURLRequest *request = [NSURLRequest requestWithURL:fileURL];
+
+	BOOL success = NO;
+	NSError *error = nil;
+	RACTuple *result = [[NSURLConnection rac_sendAsynchronousRequest:request] firstOrDefault:nil success:&success error:&error];
+	expect(success).to.beTruthy();
+	expect(error).to.beNil();
+	expect(result).to.beKindOf(RACTuple.class);
+
+	NSURLResponse *response = result.first;
+	expect(response).to.beKindOf(NSURLResponse.class);
+
+	NSData *data = result.second;
+	expect(data).to.beKindOf(NSData.class);
+	expect(data).to.equal([NSData dataWithContentsOfURL:fileURL]);
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/NSUserDefaultsRACSupportSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/NSUserDefaultsRACSupportSpec.m
new file mode 100644
index 0000000..3f0866c
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/NSUserDefaultsRACSupportSpec.m
@@ -0,0 +1,133 @@
+//
+//  NSUserDefaultsRACSupportSpec.m
+//  ReactiveCocoa
+//
+//  Created by Matt Diephouse on 12/19/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "NSUserDefaults+RACSupport.h"
+
+#import "RACCompoundDisposable.h"
+#import "RACDisposable.h"
+#import "RACKVOChannel.h"
+#import "NSObject+RACDeallocating.h"
+#import "RACSignal+Operations.h"
+
+static NSString * const NSUserDefaultsRACSupportSpecStringDefault = @"NSUserDefaultsRACSupportSpecStringDefault";
+static NSString * const NSUserDefaultsRACSupportSpecBoolDefault = @"NSUserDefaultsRACSupportSpecBoolDefault";
+
+@interface TestObserver : NSObject
+
+@property (copy, atomic) NSString *string1;
+@property (copy, atomic) NSString *string2;
+
+@property (assign, atomic) BOOL bool1;
+
+@end
+
+@implementation TestObserver
+
+@end
+
+SpecBegin(NSUserDefaultsRACSupportSpec)
+
+__block NSUserDefaults *defaults = nil;
+__block TestObserver *observer = nil;
+
+beforeEach(^{
+	defaults = NSUserDefaults.standardUserDefaults;
+	[defaults removeObjectForKey:NSUserDefaultsRACSupportSpecStringDefault];
+	[defaults removeObjectForKey:NSUserDefaultsRACSupportSpecBoolDefault];
+	
+	observer = [TestObserver new];
+});
+
+afterEach(^{
+	observer = nil;
+});
+
+it(@"should set defaults", ^{
+	RACChannelTo(observer, string1) = [defaults rac_channelTerminalForKey:NSUserDefaultsRACSupportSpecStringDefault];
+	RACChannelTo(observer, bool1, @NO) = [defaults rac_channelTerminalForKey:NSUserDefaultsRACSupportSpecBoolDefault];
+	
+	observer.string1 = @"A string";
+	observer.bool1 = YES;
+	
+	expect([defaults objectForKey:NSUserDefaultsRACSupportSpecStringDefault]).will.equal(@"A string");
+	expect([defaults objectForKey:NSUserDefaultsRACSupportSpecBoolDefault]).will.equal(@YES);
+});
+
+it(@"should read defaults", ^{
+	RACChannelTo(observer, string1) = [defaults rac_channelTerminalForKey:NSUserDefaultsRACSupportSpecStringDefault];
+	RACChannelTo(observer, bool1, @NO) = [defaults rac_channelTerminalForKey:NSUserDefaultsRACSupportSpecBoolDefault];
+	
+	expect(observer.string1).to.beNil();
+	expect(observer.bool1).to.equal(NO);
+	
+	[defaults setObject:@"Another string" forKey:NSUserDefaultsRACSupportSpecStringDefault];
+	[defaults setBool:YES forKey:NSUserDefaultsRACSupportSpecBoolDefault];
+	
+	expect(observer.string1).to.equal(@"Another string");
+	expect(observer.bool1).to.equal(YES);
+});
+
+it(@"should be okay to create 2 terminals", ^{
+	RACChannelTo(observer, string1) = [defaults rac_channelTerminalForKey:NSUserDefaultsRACSupportSpecStringDefault];
+	RACChannelTo(observer, string2) = [defaults rac_channelTerminalForKey:NSUserDefaultsRACSupportSpecStringDefault];
+	
+	[defaults setObject:@"String 3" forKey:NSUserDefaultsRACSupportSpecStringDefault];
+	
+	expect(observer.string1).to.equal(@"String 3");
+	expect(observer.string2).to.equal(@"String 3");
+});
+
+it(@"should handle removed defaults", ^{
+	observer.string1 = @"Some string";
+	observer.bool1 = YES;
+	
+	RACChannelTo(observer, string1) = [defaults rac_channelTerminalForKey:NSUserDefaultsRACSupportSpecStringDefault];
+	RACChannelTo(observer, bool1, @NO) = [defaults rac_channelTerminalForKey:NSUserDefaultsRACSupportSpecBoolDefault];
+	
+	[defaults removeObjectForKey:NSUserDefaultsRACSupportSpecStringDefault];
+	[defaults removeObjectForKey:NSUserDefaultsRACSupportSpecBoolDefault];
+	
+	expect(observer.string1).to.beNil();
+	expect(observer.bool1).to.equal(NO);
+});
+
+it(@"shouldn't resend values", ^{
+	RACChannelTerminal *terminal = [defaults rac_channelTerminalForKey:NSUserDefaultsRACSupportSpecStringDefault];
+	
+	RACChannelTo(observer, string1) = terminal;
+	
+	RACSignal *sentValue = [terminal replayLast];
+	observer.string1 = @"Test value";
+	id value = [sentValue asynchronousFirstOrDefault:nil success:NULL error:NULL];
+	expect(value).to.beNil();
+});
+
+it(@"should complete when the NSUserDefaults deallocates", ^{
+	__block RACChannelTerminal *terminal;
+	__block BOOL deallocated = NO;
+	
+	@autoreleasepool {
+		NSUserDefaults *customDefaults __attribute__((objc_precise_lifetime)) = [NSUserDefaults new];
+		[customDefaults.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+			deallocated = YES;
+		}]];
+		
+		terminal = [customDefaults rac_channelTerminalForKey:NSUserDefaultsRACSupportSpecStringDefault];
+	}
+	
+	expect(deallocated).to.beTruthy();
+	expect([terminal asynchronouslyWaitUntilCompleted:NULL]).to.beTruthy();
+});
+
+it(@"should send an initial value", ^{
+	[defaults setObject:@"Initial" forKey:NSUserDefaultsRACSupportSpecStringDefault];
+	RACChannelTerminal *terminal = [defaults rac_channelTerminalForKey:NSUserDefaultsRACSupportSpecStringDefault];
+	expect([terminal asynchronousFirstOrDefault:nil success:NULL error:NULL]).to.equal(@"Initial");
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACBacktraceSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACBacktraceSpec.m
new file mode 100644
index 0000000..9ad4c3b
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACBacktraceSpec.m
@@ -0,0 +1,148 @@
+//
+//  RACBacktraceSpec.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-12-24.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACBacktrace.h"
+
+#import "NSArray+RACSequenceAdditions.h"
+#import "RACReplaySubject.h"
+#import "RACScheduler.h"
+#import "RACSequence.h"
+#import "RACSignal+Operations.h"
+
+#ifdef DEBUG
+
+static RACBacktrace *previousBacktrace;
+
+static void capturePreviousBacktrace(void *context) {
+	previousBacktrace = [RACBacktrace backtrace].previousThreadBacktrace;
+}
+
+typedef struct {
+	dispatch_queue_t queue;
+	NSUInteger i;
+	__unsafe_unretained RACSubject *doneSubject;
+} RACDeepRecursionContext;
+
+static void recurseDeeply(void *ptr) {
+	RACDeepRecursionContext *context = ptr;
+
+	if (context->i++ < 10000) {
+		rac_dispatch_async_f(context->queue, context, recurseDeeply);
+	} else {
+		[context->doneSubject sendCompleted];
+	}
+}
+
+SpecBegin(RACBacktrace)
+
+__block dispatch_block_t block;
+
+beforeEach(^{
+	expect([RACBacktrace backtrace].previousThreadBacktrace).to.beNil();
+	previousBacktrace = nil;
+
+	block = ^{
+		capturePreviousBacktrace(NULL);
+	};
+});
+
+it(@"should capture the current backtrace", ^{
+	RACBacktrace *backtrace = [RACBacktrace backtrace];
+	expect(backtrace).notTo.beNil();
+});
+
+describe(@"with a GCD queue", ^{
+	__block dispatch_queue_t queue;
+
+	beforeEach(^{
+		queue = dispatch_queue_create("com.github.ReactiveCocoa.RACBacktraceSpec", DISPATCH_QUEUE_SERIAL);
+	});
+
+	afterEach(^{
+		dispatch_barrier_sync(queue, ^{});
+		dispatch_release(queue);
+	});
+
+	it(@"should trace across dispatch_async", ^{
+		rac_dispatch_async(queue, block);
+		expect(previousBacktrace).willNot.beNil();
+	});
+
+	it(@"should trace across dispatch_async to the main thread", ^{
+		rac_dispatch_async(queue, ^{
+			rac_dispatch_async(dispatch_get_main_queue(), block);
+		});
+
+		expect(previousBacktrace).willNot.beNil();
+	});
+
+	it(@"should trace across dispatch_async_f", ^{
+		rac_dispatch_async_f(queue, NULL, &capturePreviousBacktrace);
+		expect(previousBacktrace).willNot.beNil();
+	});
+
+	it(@"should trace across dispatch_barrier_async", ^{
+		rac_dispatch_barrier_async(queue, block);
+		expect(previousBacktrace).willNot.beNil();
+	});
+
+	it(@"should trace across dispatch_barrier_async_f", ^{
+		rac_dispatch_barrier_async_f(queue, NULL, &capturePreviousBacktrace);
+		expect(previousBacktrace).willNot.beNil();
+	});
+
+	it(@"should trace across dispatch_after", ^{
+		rac_dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 1), queue, block);
+		expect(previousBacktrace).willNot.beNil();
+	});
+
+	it(@"should trace across dispatch_after_f", ^{
+		rac_dispatch_after_f(dispatch_time(DISPATCH_TIME_NOW, 1), queue, NULL, &capturePreviousBacktrace);
+		expect(previousBacktrace).willNot.beNil();
+	});
+
+	it(@"shouldn't overflow the stack when deallocating a huge backtrace list", ^{
+		RACSubject *doneSubject = [RACReplaySubject subject];
+		RACDeepRecursionContext context = {
+			.queue = queue,
+			.i = 0,
+			.doneSubject = doneSubject
+		};
+
+		rac_dispatch_async_f(queue, &context, &recurseDeeply);
+		[doneSubject waitUntilCompleted:NULL];
+	});
+});
+
+it(@"should trace across a RACScheduler", ^{
+	[[RACScheduler scheduler] schedule:block];
+	expect(previousBacktrace).willNot.beNil();
+});
+
+it(@"shouldn't go bonkers with RACScheduler", ^{
+	NSMutableArray *a = [NSMutableArray array];
+	for (NSUInteger i = 0; i < 5000; i++) {
+		[a addObject:@(i)];
+	}
+
+	[[a.rac_sequence signalWithScheduler:[RACScheduler scheduler]] subscribeCompleted:^{}];
+});
+
+// Tracing across NSOperationQueue only works on OS X because it depends on
+// interposing through dynamic linking
+#ifndef __IPHONE_OS_VERSION_MIN_REQUIRED
+	it(@"should trace across an NSOperationQueue", ^{
+		NSOperationQueue *queue = [[NSOperationQueue alloc] init];
+		[queue addOperationWithBlock:block];
+		expect(previousBacktrace).willNot.beNil();
+	});
+#endif
+
+SpecEnd
+
+#endif
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACBlockTrampolineSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACBlockTrampolineSpec.m
new file mode 100644
index 0000000..72570fe
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACBlockTrampolineSpec.m
@@ -0,0 +1,48 @@
+//
+//  RACBlockTrampolineSpec.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 10/28/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACBlockTrampoline.h"
+#import "RACTuple.h"
+
+SpecBegin(RACBlockTrampoline)
+
+it(@"should invoke the block with the given arguments", ^{
+	__block NSString *stringArg;
+	__block NSNumber *numberArg;
+	id (^block)(NSString *, NSNumber *) = ^ id (NSString *string, NSNumber *number) {
+		stringArg = string;
+		numberArg = number;
+		return nil;
+	};
+
+	[RACBlockTrampoline invokeBlock:block withArguments:RACTuplePack(@"hi", @1)];
+	expect(stringArg).to.equal(@"hi");
+	expect(numberArg).to.equal(@1);
+});
+
+it(@"should return the result of the block invocation", ^{
+	NSString * (^block)(NSString *) = ^(NSString *string) {
+		return string.uppercaseString;
+	};
+
+	NSString *result = [RACBlockTrampoline invokeBlock:block withArguments:RACTuplePack(@"hi")];
+	expect(result).to.equal(@"HI");
+});
+
+it(@"should pass RACTupleNils as nil", ^{
+	__block id arg;
+	id (^block)(id) = ^ id (id obj) {
+		arg = obj;
+		return nil;
+	};
+
+	[RACBlockTrampoline invokeBlock:block withArguments:RACTuplePack(nil)];
+	expect(arg).to.beNil();
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACChannelExamples.h b/ReactiveCocoaFramework/ReactiveCocoaTests/RACChannelExamples.h
new file mode 100644
index 0000000..0952fed
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACChannelExamples.h
@@ -0,0 +1,34 @@
+//
+//  RACChannelExamples.h
+//  ReactiveCocoa
+//
+//  Created by Uri Baghin on 30/12/2012.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+// The name of the shared examples for RACChannel and its subclasses.
+extern NSString * const RACChannelExamples;
+
+// A block of type `RACChannel * (^)(void)`, which should return a new
+// RACChannel.
+extern NSString * const RACChannelExampleCreateBlock;
+
+// The name of the shared examples for any RACChannel class that gets and sets
+// a property.
+extern NSString * const RACViewChannelExamples;
+
+// A block of type `NSObject * (^)(void)`, which should create a new test view
+// and return it.
+extern NSString * const RACViewChannelExampleCreateViewBlock;
+
+// A block of type `RACChannelTerminal * (^)(NSObject *view)`, which should
+// create a new RACChannel to the given test view and return an terminal.
+extern NSString * const RACViewChannelExampleCreateTerminalBlock;
+
+// The key path that will be read/written in RACViewChannelExamples. This
+// must lead to an NSNumber or numeric primitive property.
+extern NSString * const RACViewChannelExampleKeyPath;
+
+// A block of type `void (^)(NSObject *view, NSNumber *value)`, which should
+// change the given test view's value to the given one.
+extern NSString * const RACViewChannelExampleSetViewValueBlock;
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACChannelExamples.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACChannelExamples.m
new file mode 100644
index 0000000..9fc77fc
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACChannelExamples.m
@@ -0,0 +1,298 @@
+//
+//  RACChannelExamples.m
+//  ReactiveCocoa
+//
+//  Created by Uri Baghin on 30/12/2012.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACChannelExamples.h"
+
+#import "NSObject+RACDeallocating.h"
+#import "NSObject+RACPropertySubscribing.h"
+#import "RACChannel.h"
+#import "RACCompoundDisposable.h"
+#import "RACDisposable.h"
+#import "RACSignal+Operations.h"
+
+NSString * const RACChannelExamples = @"RACChannelExamples";
+NSString * const RACChannelExampleCreateBlock = @"RACChannelExampleCreateBlock";
+
+NSString * const RACViewChannelExamples = @"RACViewChannelExamples";
+NSString * const RACViewChannelExampleCreateViewBlock = @"RACViewChannelExampleCreateViewBlock";
+NSString * const RACViewChannelExampleCreateTerminalBlock = @"RACViewChannelExampleCreateTerminalBlock";
+NSString * const RACViewChannelExampleKeyPath = @"RACViewChannelExampleKeyPath";
+NSString * const RACViewChannelExampleSetViewValueBlock = @"RACViewChannelExampleSetViewValueBlock";
+
+SharedExampleGroupsBegin(RACChannelExamples)
+
+sharedExamplesFor(RACChannelExamples, ^(NSDictionary *data) {
+	__block RACChannel * (^getChannel)(void);
+	__block RACChannel *channel;
+
+	id value1 = @"test value 1";
+	id value2 = @"test value 2";
+	id value3 = @"test value 3";
+	NSArray *values = @[ value1, value2, value3 ];
+	
+	before(^{
+		getChannel = data[RACChannelExampleCreateBlock];
+		channel = getChannel();
+	});
+	
+	it(@"should not send any leadingTerminal value on subscription", ^{
+		__block id receivedValue = nil;
+
+		[channel.followingTerminal sendNext:value1];
+		[channel.leadingTerminal subscribeNext:^(id x) {
+			receivedValue = x;
+		}];
+
+		expect(receivedValue).to.beNil();
+		
+		[channel.followingTerminal sendNext:value2];
+		expect(receivedValue).to.equal(value2);
+	});
+	
+	it(@"should send the latest followingTerminal value on subscription", ^{
+		__block id receivedValue = nil;
+
+		[channel.leadingTerminal sendNext:value1];
+		[[channel.followingTerminal take:1] subscribeNext:^(id x) {
+			receivedValue = x;
+		}];
+
+		expect(receivedValue).to.equal(value1);
+		
+		[channel.leadingTerminal sendNext:value2];
+		[[channel.followingTerminal take:1] subscribeNext:^(id x) {
+			receivedValue = x;
+		}];
+
+		expect(receivedValue).to.equal(value2);
+	});
+	
+	it(@"should send leadingTerminal values as they change", ^{
+		NSMutableArray *receivedValues = [NSMutableArray array];
+		[channel.leadingTerminal subscribeNext:^(id x) {
+			[receivedValues addObject:x];
+		}];
+
+		[channel.followingTerminal sendNext:value1];
+		[channel.followingTerminal sendNext:value2];
+		[channel.followingTerminal sendNext:value3];
+		expect(receivedValues).to.equal(values);
+	});
+	
+	it(@"should send followingTerminal values as they change", ^{
+		[channel.leadingTerminal sendNext:value1];
+
+		NSMutableArray *receivedValues = [NSMutableArray array];
+		[channel.followingTerminal subscribeNext:^(id x) {
+			[receivedValues addObject:x];
+		}];
+
+		[channel.leadingTerminal sendNext:value2];
+		[channel.leadingTerminal sendNext:value3];
+		expect(receivedValues).to.equal(values);
+	});
+
+	it(@"should complete both signals when the leadingTerminal is completed", ^{
+		__block BOOL completedLeft = NO;
+		[channel.leadingTerminal subscribeCompleted:^{
+			completedLeft = YES;
+		}];
+
+		__block BOOL completedRight = NO;
+		[channel.followingTerminal subscribeCompleted:^{
+			completedRight = YES;
+		}];
+
+		[channel.leadingTerminal sendCompleted];
+		expect(completedLeft).to.beTruthy();
+		expect(completedRight).to.beTruthy();
+	});
+
+	it(@"should complete both signals when the followingTerminal is completed", ^{
+		__block BOOL completedLeft = NO;
+		[channel.leadingTerminal subscribeCompleted:^{
+			completedLeft = YES;
+		}];
+
+		__block BOOL completedRight = NO;
+		[channel.followingTerminal subscribeCompleted:^{
+			completedRight = YES;
+		}];
+
+		[channel.followingTerminal sendCompleted];
+		expect(completedLeft).to.beTruthy();
+		expect(completedRight).to.beTruthy();
+	});
+
+	it(@"should replay completion to new subscribers", ^{
+		[channel.leadingTerminal sendCompleted];
+
+		__block BOOL completedLeft = NO;
+		[channel.leadingTerminal subscribeCompleted:^{
+			completedLeft = YES;
+		}];
+
+		__block BOOL completedRight = NO;
+		[channel.followingTerminal subscribeCompleted:^{
+			completedRight = YES;
+		}];
+
+		expect(completedLeft).to.beTruthy();
+		expect(completedRight).to.beTruthy();
+	});
+});
+
+SharedExampleGroupsEnd
+
+SharedExampleGroupsBegin(RACViewChannelExamples)
+
+sharedExamplesFor(RACViewChannelExamples, ^(NSDictionary *data) {
+	__block NSString *keyPath;
+	__block NSObject * (^getView)(void);
+	__block RACChannelTerminal * (^getTerminal)(NSObject *);
+	__block void (^setViewValue)(NSObject *view, NSNumber *value);
+
+	__block NSObject *testView;
+	__block RACChannelTerminal *endpoint;
+
+	beforeEach(^{
+		keyPath = data[RACViewChannelExampleKeyPath];
+		getTerminal = data[RACViewChannelExampleCreateTerminalBlock];
+		getView = data[RACViewChannelExampleCreateViewBlock];
+		setViewValue = data[RACViewChannelExampleSetViewValueBlock];
+
+		testView = getView();
+		endpoint = getTerminal(testView);
+	});
+
+	it(@"should not send changes made by the channel itself", ^{
+		__block BOOL receivedNext = NO;
+		[endpoint subscribeNext:^(id x) {
+			receivedNext = YES;
+		}];
+
+		expect(receivedNext).to.beFalsy();
+
+		[endpoint sendNext:@0.1];
+		expect(receivedNext).to.beFalsy();
+
+		[endpoint sendNext:@0.2];
+		expect(receivedNext).to.beFalsy();
+
+		[endpoint sendCompleted];
+		expect(receivedNext).to.beFalsy();
+	});
+
+	it(@"should not send progammatic changes made to the view", ^{
+		__block BOOL receivedNext = NO;
+		[endpoint subscribeNext:^(id x) {
+			receivedNext = YES;
+		}];
+
+		expect(receivedNext).to.beFalsy();
+
+		[testView setValue:@0.1 forKeyPath:keyPath];
+		expect(receivedNext).to.beFalsy();
+
+		[testView setValue:@0.2 forKeyPath:keyPath];
+		expect(receivedNext).to.beFalsy();
+	});
+
+	it(@"should not have a starting value", ^{
+		__block BOOL receivedNext = NO;
+		[endpoint subscribeNext:^(id x) {
+			receivedNext = YES;
+		}];
+
+		expect(receivedNext).to.beFalsy();
+	});
+
+	it(@"should send view changes", ^{
+		__block NSString *received;
+		[endpoint subscribeNext:^(id x) {
+			received = x;
+		}];
+
+		setViewValue(testView, @0.1);
+		expect(received).to.equal(@0.1);
+
+		setViewValue(testView, @0.2);
+		expect(received).to.equal(@0.2);
+	});
+
+	it(@"should set values on the view", ^{
+		[endpoint sendNext:@0.1];
+		expect([testView valueForKeyPath:keyPath]).to.equal(@0.1);
+
+		[endpoint sendNext:@0.2];
+		expect([testView valueForKeyPath:keyPath]).to.equal(@0.2);
+	});
+
+	it(@"should not echo changes back to the channel", ^{
+		__block NSUInteger receivedCount = 0;
+		[endpoint subscribeNext:^(id _) {
+			receivedCount++;
+		}];
+
+		expect(receivedCount).to.equal(0);
+
+		[endpoint sendNext:@0.1];
+		expect(receivedCount).to.equal(0);
+
+		setViewValue(testView, @0.2);
+		expect(receivedCount).to.equal(1);
+	});
+
+	it(@"should complete when the view deallocates", ^{
+		__block BOOL deallocated = NO;
+		__block BOOL completed = NO;
+
+		@autoreleasepool {
+			NSObject *view __attribute__((objc_precise_lifetime)) = getView();
+			[view.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				deallocated = YES;
+			}]];
+
+			RACChannelTerminal *terminal = getTerminal(view);
+			[terminal subscribeCompleted:^{
+				completed = YES;
+			}];
+
+			expect(deallocated).to.beFalsy();
+			expect(completed).to.beFalsy();
+		}
+
+		expect(deallocated).to.beTruthy();
+		expect(completed).to.beTruthy();
+	});
+
+	it(@"should deallocate after the view deallocates", ^{
+		__block BOOL viewDeallocated = NO;
+		__block BOOL terminalDeallocated = NO;
+
+		@autoreleasepool {
+			NSObject *view __attribute__((objc_precise_lifetime)) = getView();
+			[view.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				viewDeallocated = YES;
+			}]];
+
+			RACChannelTerminal *terminal = getTerminal(view);
+			[terminal.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				terminalDeallocated = YES;
+			}]];
+
+			expect(viewDeallocated).to.beFalsy();
+			expect(terminalDeallocated).to.beFalsy();
+		}
+
+		expect(viewDeallocated).to.beTruthy();
+		expect(terminalDeallocated).will.beTruthy();
+	});
+});
+
+SharedExampleGroupsEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACChannelSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACChannelSpec.m
new file mode 100644
index 0000000..7bfe6af
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACChannelSpec.m
@@ -0,0 +1,71 @@
+//
+//  RACChannelSpec.m
+//  ReactiveCocoa
+//
+//  Created by Uri Baghin on 30/12/2012.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACChannelExamples.h"
+
+#import "NSObject+RACDeallocating.h"
+#import "RACChannel.h"
+#import "RACCompoundDisposable.h"
+#import "RACDisposable.h"
+#import "RACSignal.h"
+
+SpecBegin(RACChannel)
+
+describe(@"RACChannel", ^{
+	itShouldBehaveLike(RACChannelExamples, @{
+		RACChannelExampleCreateBlock: [^{
+			return [[RACChannel alloc] init];
+		} copy]
+	});
+	
+	describe(@"memory management", ^{
+		it(@"should dealloc when its subscribers are disposed", ^{
+			RACDisposable *leadingDisposable = nil;
+			RACDisposable *followingDisposable = nil;
+
+			__block BOOL deallocated = NO;
+
+			@autoreleasepool {
+				RACChannel *channel __attribute__((objc_precise_lifetime)) = [[RACChannel alloc] init];
+				[channel.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+					deallocated = YES;
+				}]];
+
+				leadingDisposable = [channel.leadingTerminal subscribeCompleted:^{}];
+				followingDisposable = [channel.followingTerminal subscribeCompleted:^{}];
+			}
+
+			[leadingDisposable dispose];
+			[followingDisposable dispose];
+			expect(deallocated).will.beTruthy();
+		});
+		
+		it(@"should dealloc when its subscriptions are disposed", ^{
+			RACDisposable *leadingDisposable = nil;
+			RACDisposable *followingDisposable = nil;
+
+			__block BOOL deallocated = NO;
+
+			@autoreleasepool {
+				RACChannel *channel __attribute__((objc_precise_lifetime)) = [[RACChannel alloc] init];
+				[channel.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+					deallocated = YES;
+				}]];
+
+				leadingDisposable = [[RACSignal never] subscribe:channel.leadingTerminal];
+				followingDisposable = [[RACSignal never] subscribe:channel.followingTerminal];
+			}
+
+			[leadingDisposable dispose];
+			[followingDisposable dispose];
+			expect(deallocated).will.beTruthy();
+		});
+	});
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACCommandSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACCommandSpec.m
new file mode 100644
index 0000000..b0c810b
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACCommandSpec.m
@@ -0,0 +1,526 @@
+//
+//  RACCommandSpec.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 8/31/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "NSArray+RACSequenceAdditions.h"
+#import "NSObject+RACDeallocating.h"
+#import "NSObject+RACPropertySubscribing.h"
+#import "RACCommand.h"
+#import "RACCompoundDisposable.h"
+#import "RACDisposable.h"
+#import "RACEvent.h"
+#import "RACScheduler.h"
+#import "RACSequence.h"
+#import "RACSignal+Operations.h"
+#import "RACSubject.h"
+#import "RACUnit.h"
+
+SpecBegin(RACCommand)
+
+RACSignal * (^emptySignalBlock)(id) = ^(id _) {
+	return [RACSignal empty];
+};
+
+describe(@"with a simple signal block", ^{
+	__block RACCommand *command;
+
+	beforeEach(^{
+		command = [[RACCommand alloc] initWithSignalBlock:^(id value) {
+			return [RACSignal return:value];
+		}];
+
+		expect(command).notTo.beNil();
+		expect(command.allowsConcurrentExecution).to.beFalsy();
+	});
+
+	it(@"should be enabled by default", ^{
+		expect([command.enabled first]).to.equal(@YES);
+	});
+
+	it(@"should not be executing by default", ^{
+		expect([command.executing first]).to.equal(@NO);
+	});
+
+	it(@"should create an execution signal", ^{
+		__block NSUInteger signalsReceived = 0;
+		__block BOOL completed = NO;
+
+		id value = NSNull.null;
+		[command.executionSignals subscribeNext:^(RACSignal *signal) {
+			signalsReceived++;
+
+			[signal subscribeNext:^(id x) {
+				expect(x).to.equal(value);
+			} completed:^{
+				completed = YES;
+			}];
+		}];
+
+		expect(signalsReceived).to.equal(0);
+		
+		[command execute:value];
+		expect(signalsReceived).will.equal(1);
+		expect(completed).to.beTruthy();
+	});
+
+	it(@"should return the execution signal from -execute:", ^{
+		__block BOOL completed = NO;
+
+		id value = NSNull.null;
+		[[command
+			execute:value]
+			subscribeNext:^(id x) {
+				expect(x).to.equal(value);
+			} completed:^{
+				completed = YES;
+			}];
+
+		expect(completed).will.beTruthy();
+	});
+
+	it(@"should always send executionSignals on the main thread", ^{
+		__block RACScheduler *receivedScheduler = nil;
+		[command.executionSignals subscribeNext:^(id _) {
+			receivedScheduler = RACScheduler.currentScheduler;
+		}];
+
+		[[RACScheduler scheduler] schedule:^{
+			expect([[command execute:nil] waitUntilCompleted:NULL]).to.beTruthy();
+		}];
+
+		expect(receivedScheduler).to.beNil();
+		expect(receivedScheduler).will.equal(RACScheduler.mainThreadScheduler);
+	});
+
+	it(@"should not send anything on 'errors' by default", ^{
+		__block BOOL receivedError = NO;
+		[command.errors subscribeNext:^(id _) {
+			receivedError = YES;
+		}];
+		
+		expect([[command execute:nil] asynchronouslyWaitUntilCompleted:NULL]).to.beTruthy();
+		expect(receivedError).to.beFalsy();
+	});
+
+	it(@"should be executing while an execution signal is running", ^{
+		[command.executionSignals subscribeNext:^(RACSignal *signal) {
+			[signal subscribeNext:^(id x) {
+				expect([command.executing first]).to.equal(@YES);
+			}];
+		}];
+
+		expect([[command execute:nil] asynchronouslyWaitUntilCompleted:NULL]).to.beTruthy();
+		expect([command.executing first]).to.equal(@NO);
+	});
+
+	it(@"should always update executing on the main thread", ^{
+		__block RACScheduler *updatedScheduler = nil;
+		[[command.executing skip:1] subscribeNext:^(NSNumber *executing) {
+			if (!executing.boolValue) return;
+
+			updatedScheduler = RACScheduler.currentScheduler;
+		}];
+
+		[[RACScheduler scheduler] schedule:^{
+			expect([[command execute:nil] waitUntilCompleted:NULL]).to.beTruthy();
+		}];
+
+		expect([command.executing first]).to.equal(@NO);
+		expect(updatedScheduler).will.equal(RACScheduler.mainThreadScheduler);
+	});
+
+	it(@"should dealloc without subscribers", ^{
+		__block BOOL disposed = NO;
+
+		@autoreleasepool {
+			RACCommand *command __attribute__((objc_precise_lifetime)) = [[RACCommand alloc] initWithSignalBlock:emptySignalBlock];
+			[command.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				disposed = YES;
+			}]];
+		}
+
+		expect(disposed).will.beTruthy();
+	});
+
+	it(@"should complete signals on the main thread when deallocated", ^{
+		__block RACScheduler *executionSignalsScheduler = nil;
+		__block RACScheduler *executingScheduler = nil;
+		__block RACScheduler *enabledScheduler = nil;
+		__block RACScheduler *errorsScheduler = nil;
+
+		[[RACScheduler scheduler] schedule:^{
+			@autoreleasepool {
+				RACCommand *command __attribute__((objc_precise_lifetime)) = [[RACCommand alloc] initWithSignalBlock:emptySignalBlock];
+
+				[command.executionSignals subscribeCompleted:^{
+					executionSignalsScheduler = RACScheduler.currentScheduler;
+				}];
+
+				[command.executing subscribeCompleted:^{
+					executingScheduler = RACScheduler.currentScheduler;
+				}];
+
+				[command.enabled subscribeCompleted:^{
+					enabledScheduler = RACScheduler.currentScheduler;
+				}];
+
+				[command.errors subscribeCompleted:^{
+					errorsScheduler = RACScheduler.currentScheduler;
+				}];
+			}
+		}];
+
+		expect(executionSignalsScheduler).will.equal(RACScheduler.mainThreadScheduler);
+		expect(executingScheduler).will.equal(RACScheduler.mainThreadScheduler);
+		expect(enabledScheduler).will.equal(RACScheduler.mainThreadScheduler);
+		expect(errorsScheduler).will.equal(RACScheduler.mainThreadScheduler);
+	});
+});
+
+it(@"should invoke the signalBlock once per execution", ^{
+	NSMutableArray *valuesReceived = [NSMutableArray array];
+	RACCommand *command = [[RACCommand alloc] initWithSignalBlock:^(id x) {
+		[valuesReceived addObject:x];
+		return [RACSignal empty];
+	}];
+
+	expect([[command execute:@"foo"] asynchronouslyWaitUntilCompleted:NULL]).to.beTruthy();
+	expect(valuesReceived).to.equal((@[ @"foo" ]));
+
+	expect([[command execute:@"bar"] asynchronouslyWaitUntilCompleted:NULL]).to.beTruthy();
+	expect(valuesReceived).to.equal((@[ @"foo", @"bar" ]));
+});
+
+it(@"should send on executionSignals in order of execution", ^{
+	RACCommand *command = [[RACCommand alloc] initWithSignalBlock:^(RACSequence *seq) {
+		return [seq signalWithScheduler:RACScheduler.immediateScheduler];
+	}];
+
+	NSMutableArray *valuesReceived = [NSMutableArray array];
+	[[command.executionSignals
+		concat]
+		subscribeNext:^(id x) {
+			[valuesReceived addObject:x];
+		}];
+
+	RACSequence *first = @[ @"foo", @"bar" ].rac_sequence;
+	expect([[command execute:first] asynchronouslyWaitUntilCompleted:NULL]).to.beTruthy();
+
+	RACSequence *second = @[ @"buzz", @"baz" ].rac_sequence;
+	expect([[command execute:second] asynchronouslyWaitUntilCompleted:NULL]).will.beTruthy();
+
+	NSArray *expectedValues = @[ @"foo", @"bar", @"buzz", @"baz" ];
+	expect(valuesReceived).to.equal(expectedValues);
+});
+
+it(@"should wait for all signals to complete or error before executing sends NO", ^{
+	RACCommand *command = [[RACCommand alloc] initWithSignalBlock:^(RACSignal *signal) {
+		return signal;
+	}];
+
+	command.allowsConcurrentExecution = YES;
+	
+	RACSubject *firstSubject = [RACSubject subject];
+	expect([command execute:firstSubject]).notTo.beNil();
+
+	RACSubject *secondSubject = [RACSubject subject];
+	expect([command execute:secondSubject]).notTo.beNil();
+
+	expect([command.executing first]).will.equal(@YES);
+
+	[firstSubject sendError:nil];
+	expect([command.executing first]).to.equal(@YES);
+
+	[secondSubject sendNext:nil];
+	expect([command.executing first]).to.equal(@YES);
+
+	[secondSubject sendCompleted];
+	expect([command.executing first]).will.equal(@NO);
+});
+
+it(@"should not deliver errors from executionSignals", ^{
+	RACSubject *subject = [RACSubject subject];
+	NSMutableArray *receivedEvents = [NSMutableArray array];
+
+	RACCommand *command = [[RACCommand alloc] initWithSignalBlock:^(id _) {
+		return subject;
+	}];
+
+	[[[command.executionSignals
+		flatten]
+		materialize]
+		subscribeNext:^(RACEvent *event) {
+			[receivedEvents addObject:event];
+		}];
+
+	expect([command execute:nil]).notTo.beNil();
+	expect([command.executing first]).will.equal(@YES);
+
+	[subject sendNext:RACUnit.defaultUnit];
+
+	NSArray *expectedEvents = @[ [RACEvent eventWithValue:RACUnit.defaultUnit] ];
+	expect(receivedEvents).will.equal(expectedEvents);
+	expect([command.executing first]).to.equal(@YES);
+
+	[subject sendNext:@"foo"];
+
+	expectedEvents = @[ [RACEvent eventWithValue:RACUnit.defaultUnit], [RACEvent eventWithValue:@"foo"] ];
+	expect(receivedEvents).will.equal(expectedEvents);
+	expect([command.executing first]).to.equal(@YES);
+
+	NSError *error = [NSError errorWithDomain:@"" code:1 userInfo:nil];
+	[subject sendError:error];
+
+	expect([command.executing first]).will.equal(@NO);
+	expect(receivedEvents).to.equal(expectedEvents);
+});
+
+it(@"should deliver errors from -execute:", ^{
+	RACSubject *subject = [RACSubject subject];
+	NSMutableArray *receivedEvents = [NSMutableArray array];
+
+	RACCommand *command = [[RACCommand alloc] initWithSignalBlock:^(id _) {
+		return subject;
+	}];
+
+	[[[command
+		execute:nil]
+		materialize]
+		subscribeNext:^(RACEvent *event) {
+			[receivedEvents addObject:event];
+		}];
+
+	expect([command.executing first]).will.equal(@YES);
+
+	[subject sendNext:RACUnit.defaultUnit];
+
+	NSArray *expectedEvents = @[ [RACEvent eventWithValue:RACUnit.defaultUnit] ];
+	expect(receivedEvents).will.equal(expectedEvents);
+	expect([command.executing first]).to.equal(@YES);
+
+	[subject sendNext:@"foo"];
+
+	expectedEvents = @[ [RACEvent eventWithValue:RACUnit.defaultUnit], [RACEvent eventWithValue:@"foo"] ];
+	expect(receivedEvents).will.equal(expectedEvents);
+	expect([command.executing first]).to.equal(@YES);
+
+	NSError *error = [NSError errorWithDomain:@"" code:1 userInfo:nil];
+	[subject sendError:error];
+
+	expectedEvents = @[ [RACEvent eventWithValue:RACUnit.defaultUnit], [RACEvent eventWithValue:@"foo"], [RACEvent eventWithError:error] ];
+	expect(receivedEvents).will.equal(expectedEvents);
+	expect([command.executing first]).will.equal(@NO);
+});
+
+it(@"should deliver errors onto 'errors'", ^{
+	RACCommand *command = [[RACCommand alloc] initWithSignalBlock:^(RACSignal *signal) {
+		return signal;
+	}];
+
+	command.allowsConcurrentExecution = YES;
+	
+	RACSubject *firstSubject = [RACSubject subject];
+	expect([command execute:firstSubject]).notTo.beNil();
+
+	RACSubject *secondSubject = [RACSubject subject];
+	expect([command execute:secondSubject]).notTo.beNil();
+
+	NSError *firstError = [NSError errorWithDomain:@"" code:1 userInfo:nil];
+	NSError *secondError = [NSError errorWithDomain:@"" code:2 userInfo:nil];
+	
+	// We should receive errors from our previously-started executions.
+	NSMutableArray *receivedErrors = [NSMutableArray array];
+	[command.errors subscribeNext:^(NSError *error) {
+		[receivedErrors addObject:error];
+	}];
+
+	expect([command.executing first]).will.equal(@YES);
+
+	[firstSubject sendError:firstError];
+	expect([command.executing first]).will.equal(@YES);
+
+	NSArray *expected = @[ firstError ];
+	expect(receivedErrors).will.equal(expected);
+
+	[secondSubject sendError:secondError];
+	expect([command.executing first]).will.equal(@NO);
+
+	expected = @[ firstError, secondError ];
+	expect(receivedErrors).will.equal(expected);
+});
+
+it(@"should not deliver non-error events onto 'errors'", ^{
+	RACSubject *subject = [RACSubject subject];
+	RACCommand *command = [[RACCommand alloc] initWithSignalBlock:^(id _) {
+		return subject;
+	}];
+
+	__block BOOL receivedEvent = NO;
+	[command.errors subscribeNext:^(id _) {
+		receivedEvent = YES;
+	}];
+
+	expect([command execute:nil]).notTo.beNil();
+	expect([command.executing first]).will.equal(@YES);
+
+	[subject sendNext:RACUnit.defaultUnit];
+	[subject sendCompleted];
+
+	expect([command.executing first]).will.equal(@NO);
+	expect(receivedEvent).to.beFalsy();
+});
+
+it(@"should send errors on the main thread", ^{
+	RACCommand *command = [[RACCommand alloc] initWithSignalBlock:^(RACSignal *signal) {
+		return signal;
+	}];
+
+	NSError *error = [NSError errorWithDomain:@"" code:1 userInfo:nil];
+
+	__block RACScheduler *receivedScheduler = nil;
+	[command.errors subscribeNext:^(NSError *e) {
+		expect(e).to.equal(error);
+		receivedScheduler = RACScheduler.currentScheduler;
+	}];
+
+	RACSignal *errorSignal = [RACSignal error:error];
+
+	[[RACScheduler scheduler] schedule:^{
+		expect([[command execute:errorSignal] waitUntilCompleted:NULL]).to.beTruthy();
+	}];
+
+	expect(receivedScheduler).to.beNil();
+	expect(receivedScheduler).will.equal(RACScheduler.mainThreadScheduler);
+});
+
+describe(@"enabled signal", ^{
+	__block RACSubject *enabledSubject;
+	__block RACCommand *command;
+
+	beforeEach(^{
+		enabledSubject = [RACSubject subject];
+		command = [[RACCommand alloc] initWithEnabled:enabledSubject signalBlock:^(id _) {
+			return [RACSignal return:RACUnit.defaultUnit];
+		}];
+	});
+
+	it(@"should send YES by default", ^{
+		expect([command.enabled first]).to.equal(@YES);
+	});
+
+	it(@"should send whatever the enabledSignal has sent most recently", ^{
+		[enabledSubject sendNext:@NO];
+		expect([command.enabled first]).will.equal(@NO);
+
+		[enabledSubject sendNext:@YES];
+		expect([command.enabled first]).will.equal(@YES);
+
+		[enabledSubject sendNext:@NO];
+		expect([command.enabled first]).will.equal(@NO);
+	});
+	
+	it(@"should sample enabledSignal synchronously at initialization time", ^{
+		RACCommand *command = [[RACCommand alloc] initWithEnabled:[RACSignal return:@NO] signalBlock:^(id _) {
+			return [RACSignal empty];
+		}];
+		expect([command.enabled first]).to.equal(@NO);
+	});
+
+	it(@"should send NO while executing is YES and allowsConcurrentExecution is NO", ^{
+		[[command.executionSignals flatten] subscribeNext:^(id _) {
+			expect([command.executing first]).to.equal(@YES);
+			expect([command.enabled first]).to.equal(@NO);
+		}];
+
+		expect([command.enabled first]).to.equal(@YES);
+		expect([[command execute:nil] asynchronouslyWaitUntilCompleted:NULL]).to.beTruthy();
+		expect([command.enabled first]).to.equal(@YES);
+	});
+
+	it(@"should send YES while executing is YES and allowsConcurrentExecution is YES", ^{
+		command.allowsConcurrentExecution = YES;
+
+		__block BOOL outerExecuted = NO;
+		__block BOOL innerExecuted = NO;
+
+		// Prevent infinite recursion by only responding to the first value.
+		[[[command.executionSignals
+			take:1]
+			flatten]
+			subscribeNext:^(id _) {
+				outerExecuted = YES;
+
+				expect([command.executing first]).to.equal(@YES);
+				expect([command.enabled first]).to.equal(@YES);
+
+				[[command execute:nil] subscribeCompleted:^{
+					innerExecuted = YES;
+				}];
+			}];
+
+		expect([command.enabled first]).to.equal(@YES);
+
+		expect([command execute:nil]).notTo.beNil();
+		expect(outerExecuted).will.beTruthy();
+		expect(innerExecuted).will.beTruthy();
+
+		expect([command.enabled first]).to.equal(@YES);
+	});
+
+	it(@"should send an error from -execute: when NO", ^{
+		[enabledSubject sendNext:@NO];
+
+		RACSignal *signal = [command execute:nil];
+		expect(signal).notTo.beNil();
+		
+		__block BOOL success = NO;
+		__block NSError *error = nil;
+		expect([signal firstOrDefault:nil success:&success error:&error]).to.beNil();
+		expect(success).to.beFalsy();
+
+		expect(error).notTo.beNil();
+		expect(error.domain).to.equal(RACCommandErrorDomain);
+		expect(error.code).to.equal(RACCommandErrorNotEnabled);
+		expect(error.userInfo[RACUnderlyingCommandErrorKey]).to.beIdenticalTo(command);
+	});
+
+	it(@"should always update on the main thread", ^{
+		__block RACScheduler *updatedScheduler = nil;
+		[[command.enabled skip:1] subscribeNext:^(id _) {
+			updatedScheduler = RACScheduler.currentScheduler;
+		}];
+
+		[[RACScheduler scheduler] schedule:^{
+			[enabledSubject sendNext:@NO];
+		}];
+
+		expect([command.enabled first]).to.equal(@YES);
+		expect([command.enabled first]).will.equal(@NO);
+		expect(updatedScheduler).to.equal(RACScheduler.mainThreadScheduler);
+	});
+
+	it(@"should complete when the command is deallocated even if the input signal hasn't", ^{
+		__block BOOL deallocated = NO;
+		__block BOOL completed = NO;
+
+		@autoreleasepool {
+			RACCommand *command __attribute__((objc_precise_lifetime)) = [[RACCommand alloc] initWithEnabled:enabledSubject signalBlock:emptySignalBlock];
+			[command.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				deallocated = YES;
+			}]];
+
+			[command.enabled subscribeCompleted:^{
+				completed = YES;
+			}];
+		}
+
+		expect(deallocated).will.beTruthy();
+		expect(completed).will.beTruthy();
+	});
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACCompoundDisposableSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACCompoundDisposableSpec.m
new file mode 100644
index 0000000..faad3bb
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACCompoundDisposableSpec.m
@@ -0,0 +1,109 @@
+//
+//  RACCompoundDisposableSpec.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 11/30/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACCompoundDisposable.h"
+
+SpecBegin(RACCompoundDisposable)
+
+it(@"should dispose of all its contained disposables", ^{
+	__block BOOL d1Disposed = NO;
+	RACDisposable *d1 = [RACDisposable disposableWithBlock:^{
+		d1Disposed = YES;
+	}];
+
+	__block BOOL d2Disposed = NO;
+	RACDisposable *d2 = [RACDisposable disposableWithBlock:^{
+		d2Disposed = YES;
+	}];
+
+	__block BOOL d3Disposed = NO;
+	RACDisposable *d3 = [RACDisposable disposableWithBlock:^{
+		d3Disposed = YES;
+	}];
+
+	__block BOOL d4Disposed = NO;
+	RACDisposable *d4 = [RACDisposable disposableWithBlock:^{
+		d4Disposed = YES;
+	}];
+
+	RACCompoundDisposable *disposable = [RACCompoundDisposable compoundDisposableWithDisposables:@[ d1, d2, d3 ]];
+	[disposable addDisposable:d4];
+
+	expect(d1Disposed).to.beFalsy();
+	expect(d2Disposed).to.beFalsy();
+	expect(d3Disposed).to.beFalsy();
+	expect(d4Disposed).to.beFalsy();
+	expect(disposable.disposed).to.beFalsy();
+
+	[disposable dispose];
+
+	expect(d1Disposed).to.beTruthy();
+	expect(d2Disposed).to.beTruthy();
+	expect(d3Disposed).to.beTruthy();
+	expect(d4Disposed).to.beTruthy();
+	expect(disposable.disposed).to.beTruthy();
+});
+
+it(@"should dispose of any added disposables immediately if it's already been disposed", ^{
+	RACCompoundDisposable *disposable = [RACCompoundDisposable compoundDisposable];
+	[disposable dispose];
+
+	RACDisposable *d = [[RACDisposable alloc] init];
+
+	expect(d.disposed).to.beFalsy();
+	[disposable addDisposable:d];
+	expect(d.disposed).to.beTruthy();
+});
+
+it(@"should work when initialized with -init", ^{
+	RACCompoundDisposable *disposable = [[RACCompoundDisposable alloc] init];
+
+	__block BOOL disposed = NO;
+	RACDisposable *d = [RACDisposable disposableWithBlock:^{
+		disposed = YES;
+	}];
+
+	[disposable addDisposable:d];
+	expect(disposed).to.beFalsy();
+
+	[disposable dispose];
+	expect(disposed).to.beTruthy();
+});
+
+it(@"should work when initialized with +disposableWithBlock:", ^{
+	__block BOOL compoundDisposed = NO;
+	RACCompoundDisposable *disposable = [RACCompoundDisposable disposableWithBlock:^{
+		compoundDisposed = YES;
+	}];
+
+	__block BOOL disposed = NO;
+	RACDisposable *d = [RACDisposable disposableWithBlock:^{
+		disposed = YES;
+	}];
+
+	[disposable addDisposable:d];
+	expect(disposed).to.beFalsy();
+	expect(compoundDisposed).to.beFalsy();
+
+	[disposable dispose];
+	expect(disposed).to.beTruthy();
+	expect(compoundDisposed).to.beTruthy();
+});
+
+it(@"should allow disposables to be removed", ^{
+	RACCompoundDisposable *disposable = [[RACCompoundDisposable alloc] init];
+	RACDisposable *d = [[RACDisposable alloc] init];
+
+	[disposable addDisposable:d];
+	[disposable removeDisposable:d];
+
+	[disposable dispose];
+	expect(d.disposed).to.beFalsy();
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACControlCommandExamples.h b/ReactiveCocoaFramework/ReactiveCocoaTests/RACControlCommandExamples.h
new file mode 100644
index 0000000..3fbaa34
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACControlCommandExamples.h
@@ -0,0 +1,18 @@
+//
+//  RACControlCommandExamples.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-08-15.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+// The name of the shared examples for any control class that has
+// `rac_command` and `isEnabled` properties.
+extern NSString * const RACControlCommandExamples;
+
+// The control to test.
+extern NSString * const RACControlCommandExampleControl;
+
+// A block of type `void (^)(id control)` which should activate the
+// `rac_command` of the `control` by manipulating the control itself.
+extern NSString * const RACControlCommandExampleActivateBlock;
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACControlCommandExamples.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACControlCommandExamples.m
new file mode 100644
index 0000000..034cc81
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACControlCommandExamples.m
@@ -0,0 +1,81 @@
+//
+//  RACControlCommandExamples.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-08-15.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACControlCommandExamples.h"
+
+#import "RACCommand.h"
+#import "RACSubject.h"
+#import "RACUnit.h"
+
+NSString * const RACControlCommandExamples = @"RACControlCommandExamples";
+NSString * const RACControlCommandExampleControl = @"RACControlCommandExampleControl";
+NSString * const RACControlCommandExampleActivateBlock = @"RACControlCommandExampleActivateBlock";
+
+// Methods used by the unit test that would otherwise require platform-specific
+// imports.
+@interface NSObject (RACControlCommandExamples)
+
+@property (nonatomic, strong) RACCommand *rac_command;
+
+- (BOOL)isEnabled;
+
+@end
+
+SharedExampleGroupsBegin(RACControlCommandExamples)
+
+sharedExamplesFor(RACControlCommandExamples, ^(NSDictionary *data) {
+	__block id control;
+	__block void (^activate)(id);
+
+	__block RACSubject *enabledSubject;
+	__block RACCommand *command;
+
+	beforeEach(^{
+		control = data[RACControlCommandExampleControl];
+		activate = [data[RACControlCommandExampleActivateBlock] copy];
+
+		enabledSubject = [RACSubject subject];
+		command = [[RACCommand alloc] initWithEnabled:enabledSubject signalBlock:^(id sender) {
+			return [RACSignal return:sender];
+		}];
+
+		[control setRac_command:command];
+	});
+
+	it(@"should bind the control's enabledness to the command", ^{
+		expect([control isEnabled]).will.beTruthy();
+
+		[enabledSubject sendNext:@NO];
+		expect([control isEnabled]).will.beFalsy();
+		
+		[enabledSubject sendNext:@YES];
+		expect([control isEnabled]).will.beTruthy();
+	});
+
+	it(@"should execute the control's command when activated", ^{
+		__block BOOL executed = NO;
+		[[command.executionSignals flatten] subscribeNext:^(id sender) {
+			expect(sender).to.equal(control);
+			executed = YES;
+		}];
+		
+		activate(control);
+		expect(executed).will.beTruthy();
+	});
+	
+	it(@"should overwrite an existing command when setting a new one", ^{
+		RACCommand *secondCommand = [[RACCommand alloc] initWithSignalBlock:^(id _) {
+			return [RACSignal return:RACUnit.defaultUnit];
+		}];
+		
+		[control setRac_command:secondCommand];
+		expect([control rac_command]).to.beIdenticalTo(secondCommand);
+	});
+});
+
+SharedExampleGroupsEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACDelegateProxySpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACDelegateProxySpec.m
new file mode 100644
index 0000000..831c3a3
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACDelegateProxySpec.m
@@ -0,0 +1,89 @@
+//
+//  RACDelegateProxySpec.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-06-22.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "NSObject+RACSelectorSignal.h"
+#import "RACDelegateProxy.h"
+#import "RACSignal.h"
+#import "RACTuple.h"
+#import "RACCompoundDisposable.h"
+#import "NSObject+RACDeallocating.h"
+
+@protocol TestDelegateProtocol
+- (NSUInteger)lengthOfString:(NSString *)str;
+@end
+
+@interface TestDelegate : NSObject <TestDelegateProtocol>
+@property (nonatomic, assign) BOOL lengthOfStringInvoked;
+@end
+
+SpecBegin(RACDelegateProxy)
+
+__block id proxy;
+__block TestDelegate *delegate;
+__block Protocol *protocol;
+
+beforeEach(^{
+	protocol = @protocol(TestDelegateProtocol);
+	expect(protocol).notTo.beNil();
+
+	proxy = [[RACDelegateProxy alloc] initWithProtocol:protocol];
+	expect(proxy).notTo.beNil();
+	expect([proxy rac_proxiedDelegate]).to.beNil();
+
+	delegate = [[TestDelegate alloc] init];
+	expect(delegate).notTo.beNil();
+});
+
+it(@"should not respond to selectors at first", ^{
+	expect([proxy respondsToSelector:@selector(lengthOfString:)]).to.beFalsy();
+});
+
+it(@"should send on a signal for a protocol method", ^{
+	__block RACTuple *tuple;
+	[[proxy signalForSelector:@selector(lengthOfString:)] subscribeNext:^(RACTuple *t) {
+		tuple = t;
+	}];
+
+	expect([proxy respondsToSelector:@selector(lengthOfString:)]).to.beTruthy();
+	expect([proxy lengthOfString:@"foo"]).to.equal(0);
+	expect(tuple).to.equal(RACTuplePack(@"foo"));
+});
+
+it(@"should forward to the proxied delegate", ^{
+	[proxy setRac_proxiedDelegate:delegate];
+
+	expect([proxy respondsToSelector:@selector(lengthOfString:)]).to.beTruthy();
+	expect([proxy lengthOfString:@"foo"]).to.equal(3);
+	expect(delegate.lengthOfStringInvoked).to.beTruthy();
+});
+
+it(@"should not send to the delegate when signals are applied", ^{
+	[proxy setRac_proxiedDelegate:delegate];
+
+	__block RACTuple *tuple;
+	[[proxy signalForSelector:@selector(lengthOfString:)] subscribeNext:^(RACTuple *t) {
+		tuple = t;
+	}];
+
+	expect([proxy respondsToSelector:@selector(lengthOfString:)]).to.beTruthy();
+	expect([proxy lengthOfString:@"foo"]).to.equal(0);
+
+	expect(tuple).to.equal(RACTuplePack(@"foo"));
+	expect(delegate.lengthOfStringInvoked).to.beFalsy();
+});
+
+SpecEnd
+
+@implementation TestDelegate
+
+- (NSUInteger)lengthOfString:(NSString *)str {
+	self.lengthOfStringInvoked = YES;
+	return str.length;
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACDisposableSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACDisposableSpec.m
new file mode 100644
index 0000000..8cde917
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACDisposableSpec.m
@@ -0,0 +1,73 @@
+//
+//  RACDisposableSpec.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-06-13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACDisposable.h"
+#import "RACScopedDisposable.h"
+
+SpecBegin(RACDisposable)
+
+it(@"should initialize without a block", ^{
+	RACDisposable *disposable = [[RACDisposable alloc] init];
+	expect(disposable).notTo.beNil();
+	expect(disposable.disposed).to.beFalsy();
+
+	[disposable dispose];
+	expect(disposable.disposed).to.beTruthy();
+});
+
+it(@"should execute a block upon disposal", ^{
+	__block BOOL disposed = NO;
+	RACDisposable *disposable = [RACDisposable disposableWithBlock:^{
+		disposed = YES;
+	}];
+
+	expect(disposable).notTo.beNil();
+	expect(disposed).to.beFalsy();
+	expect(disposable.disposed).to.beFalsy();
+
+	[disposable dispose];
+	expect(disposed).to.beTruthy();
+	expect(disposable.disposed).to.beTruthy();
+});
+
+it(@"should not dispose upon deallocation", ^{
+	__block BOOL disposed = NO;
+	__weak RACDisposable *weakDisposable = nil;
+
+	@autoreleasepool {
+		RACDisposable *disposable = [RACDisposable disposableWithBlock:^{
+			disposed = YES;
+		}];
+
+		weakDisposable = disposable;
+		expect(weakDisposable).notTo.beNil();
+	}
+
+	expect(weakDisposable).to.beNil();
+	expect(disposed).to.beFalsy();
+});
+
+it(@"should create a scoped disposable", ^{
+	__block BOOL disposed = NO;
+	__weak RACScopedDisposable *weakDisposable = nil;
+
+	@autoreleasepool {
+		RACScopedDisposable *disposable __attribute__((objc_precise_lifetime)) = [RACScopedDisposable disposableWithBlock:^{
+			disposed = YES;
+		}];
+
+		weakDisposable = disposable;
+		expect(weakDisposable).notTo.beNil();
+		expect(disposed).to.beFalsy();
+	}
+
+	expect(weakDisposable).to.beNil();
+	expect(disposed).to.beTruthy();
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACEventSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACEventSpec.m
new file mode 100644
index 0000000..9545fb6
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACEventSpec.m
@@ -0,0 +1,80 @@
+//
+//  RACEventSpec.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-01-07.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACEvent.h"
+
+SpecBegin(RACEvent)
+
+it(@"should return the singleton completed event", ^{
+	RACEvent *event = RACEvent.completedEvent;
+	expect(event).notTo.beNil();
+
+	expect(event).to.beIdenticalTo(RACEvent.completedEvent);
+	expect([event copy]).to.beIdenticalTo(event);
+
+	expect(event.eventType).to.equal(RACEventTypeCompleted);
+	expect(event.finished).to.beTruthy();
+	expect(event.error).to.beNil();
+	expect(event.value).to.beNil();
+});
+
+it(@"should return an error event", ^{
+	NSError *error = [NSError errorWithDomain:@"foo" code:1 userInfo:nil];
+	RACEvent *event = [RACEvent eventWithError:error];
+	expect(event).notTo.beNil();
+
+	expect(event).to.equal([RACEvent eventWithError:error]);
+	expect([event copy]).to.equal(event);
+
+	expect(event.eventType).to.equal(RACEventTypeError);
+	expect(event.finished).to.beTruthy();
+	expect(event.error).to.equal(error);
+	expect(event.value).to.beNil();
+});
+
+it(@"should return an error event with a nil error", ^{
+	RACEvent *event = [RACEvent eventWithError:nil];
+	expect(event).notTo.beNil();
+
+	expect(event).to.equal([RACEvent eventWithError:nil]);
+	expect([event copy]).to.equal(event);
+
+	expect(event.eventType).to.equal(RACEventTypeError);
+	expect(event.finished).to.beTruthy();
+	expect(event.error).to.beNil();
+	expect(event.value).to.beNil();
+});
+
+it(@"should return a next event", ^{
+	NSString *value = @"foo";
+	RACEvent *event = [RACEvent eventWithValue:value];
+	expect(event).notTo.beNil();
+
+	expect(event).to.equal([RACEvent eventWithValue:value]);
+	expect([event copy]).to.equal(event);
+
+	expect(event.eventType).to.equal(RACEventTypeNext);
+	expect(event.finished).to.beFalsy();
+	expect(event.error).to.beNil();
+	expect(event.value).to.equal(value);
+});
+
+it(@"should return a next event with a nil value", ^{
+	RACEvent *event = [RACEvent eventWithValue:nil];
+	expect(event).notTo.beNil();
+
+	expect(event).to.equal([RACEvent eventWithValue:nil]);
+	expect([event copy]).to.equal(event);
+
+	expect(event.eventType).to.equal(RACEventTypeNext);
+	expect(event.finished).to.beFalsy();
+	expect(event.error).to.beNil();
+	expect(event.value).to.beNil();
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACKVOChannelSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACKVOChannelSpec.m
new file mode 100644
index 0000000..8007511
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACKVOChannelSpec.m
@@ -0,0 +1,389 @@
+//
+//  RACKVOChannelSpec.m
+//  ReactiveCocoa
+//
+//  Created by Uri Baghin on 16/12/2012.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACTestObject.h"
+#import "RACChannelExamples.h"
+#import "RACPropertySignalExamples.h"
+
+#import "NSObject+RACDeallocating.h"
+#import "NSObject+RACKVOWrapper.h"
+#import "RACCompoundDisposable.h"
+#import "RACDisposable.h"
+#import "RACKVOChannel.h"
+#import "RACSignal+Operations.h"
+
+SpecBegin(RACKVOChannel)
+
+describe(@"RACKVOChannel", ^{
+	__block RACTestObject *object;
+	__block RACKVOChannel *channel;
+	id value1 = @"test value 1";
+	id value2 = @"test value 2";
+	id value3 = @"test value 3";
+	NSArray *values = @[ value1, value2, value3 ];
+	
+	before(^{
+		object = [[RACTestObject alloc] init];
+		channel = [[RACKVOChannel alloc] initWithTarget:object keyPath:@keypath(object.stringValue) nilValue:nil];
+	});
+	
+	id setupBlock = ^(RACTestObject *testObject, NSString *keyPath, id nilValue, RACSignal *signal) {
+		RACKVOChannel *channel = [[RACKVOChannel alloc] initWithTarget:testObject keyPath:keyPath nilValue:nilValue];
+		[signal subscribe:channel.followingTerminal];
+	};
+	
+	itShouldBehaveLike(RACPropertySignalExamples, ^{
+		return @{ RACPropertySignalExamplesSetupBlock: setupBlock };
+	});
+	
+	itShouldBehaveLike(RACChannelExamples, @{
+		RACChannelExampleCreateBlock: [^{
+			return [[RACKVOChannel alloc] initWithTarget:object keyPath:@keypath(object.stringValue) nilValue:nil];
+		} copy]
+	});
+	
+	it(@"should send the object's current value when subscribed to followingTerminal", ^{
+		__block id receivedValue = @"received value should not be this";
+		[[channel.followingTerminal take:1] subscribeNext:^(id x) {
+			receivedValue = x;
+		}];
+
+		expect(receivedValue).to.beNil();
+		
+		object.stringValue = value1;
+		[[channel.followingTerminal take:1] subscribeNext:^(id x) {
+			receivedValue = x;
+		}];
+
+		expect(receivedValue).to.equal(value1);
+	});
+	
+	it(@"should send the object's new value on followingTerminal when it's changed", ^{
+		object.stringValue = value1;
+
+		NSMutableArray *receivedValues = [NSMutableArray array];
+		[channel.followingTerminal subscribeNext:^(id x) {
+			[receivedValues addObject:x];
+		}];
+
+		object.stringValue = value2;
+		object.stringValue = value3;
+		expect(receivedValues).to.equal(values);
+	});
+	
+	it(@"should set the object's value using values sent to the followingTerminal", ^{
+		expect(object.stringValue).to.beNil();
+
+		[channel.followingTerminal sendNext:value1];
+		expect(object.stringValue).to.equal(value1);
+
+		[channel.followingTerminal sendNext:value2];
+		expect(object.stringValue).to.equal(value2);
+	});
+	
+	it(@"should be able to subscribe to signals", ^{
+		NSMutableArray *receivedValues = [NSMutableArray array];
+		[object rac_observeKeyPath:@keypath(object.stringValue) options:0 observer:self block:^(id value, NSDictionary *change) {
+			[receivedValues addObject:value];
+		}];
+
+		RACSignal *signal = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) {
+			[subscriber sendNext:value1];
+			[subscriber sendNext:value2];
+			[subscriber sendNext:value3];
+			return nil;
+		}];
+
+		[signal subscribe:channel.followingTerminal];
+		expect(receivedValues).to.equal(values);
+	});
+
+	it(@"should complete both terminals when the target deallocates", ^{
+		__block BOOL leadingCompleted = NO;
+		__block BOOL followingCompleted = NO;
+		__block BOOL deallocated = NO;
+
+		@autoreleasepool {
+			RACTestObject *object __attribute__((objc_precise_lifetime)) = [[RACTestObject alloc] init];
+			[object.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				deallocated = YES;
+			}]];
+
+			RACKVOChannel *channel = [[RACKVOChannel alloc] initWithTarget:object keyPath:@keypath(object.stringValue) nilValue:nil];
+			[channel.leadingTerminal subscribeCompleted:^{
+				leadingCompleted = YES;
+			}];
+
+			[channel.followingTerminal subscribeCompleted:^{
+				followingCompleted = YES;
+			}];
+
+			expect(deallocated).to.beFalsy();
+			expect(leadingCompleted).to.beFalsy();
+			expect(followingCompleted).to.beFalsy();
+		}
+
+		expect(deallocated).to.beTruthy();
+		expect(leadingCompleted).to.beTruthy();
+		expect(followingCompleted).to.beTruthy();
+	});
+
+	it(@"should deallocate when the target deallocates", ^{
+		__block BOOL targetDeallocated = NO;
+		__block BOOL channelDeallocated = NO;
+
+		@autoreleasepool {
+			RACTestObject *object __attribute__((objc_precise_lifetime)) = [[RACTestObject alloc] init];
+			[object.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				targetDeallocated = YES;
+			}]];
+
+			RACKVOChannel *channel = [[RACKVOChannel alloc] initWithTarget:object keyPath:@keypath(object.stringValue) nilValue:nil];
+			[channel.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				channelDeallocated = YES;
+			}]];
+
+			expect(targetDeallocated).to.beFalsy();
+			expect(channelDeallocated).to.beFalsy();
+		}
+
+		expect(targetDeallocated).to.beTruthy();
+		expect(channelDeallocated).to.beTruthy();
+	});
+});
+
+describe(@"RACChannelTo", ^{
+	__block RACTestObject *a;
+	__block RACTestObject *b;
+	__block RACTestObject *c;
+	__block NSString *testName1;
+	__block NSString *testName2;
+	__block NSString *testName3;
+	
+	before(^{
+		a = [[RACTestObject alloc] init];
+		b = [[RACTestObject alloc] init];
+		c = [[RACTestObject alloc] init];
+		testName1 = @"sync it!";
+		testName2 = @"sync it again!";
+		testName3 = @"sync it once more!";
+	});
+	
+	it(@"should keep objects' properties in sync", ^{
+		RACChannelTo(a, stringValue) = RACChannelTo(b, stringValue);
+		expect(a.stringValue).to.beNil();
+		expect(b.stringValue).to.beNil();
+		
+		a.stringValue = testName1;
+		expect(a.stringValue).to.equal(testName1);
+		expect(b.stringValue).to.equal(testName1);
+		
+		b.stringValue = testName2;
+		expect(a.stringValue).to.equal(testName2);
+		expect(b.stringValue).to.equal(testName2);
+		
+		a.stringValue = nil;
+		expect(a.stringValue).to.beNil();
+		expect(b.stringValue).to.beNil();
+	});
+	
+	it(@"should keep properties identified by keypaths in sync", ^{
+		RACChannelTo(a, strongTestObjectValue.stringValue) = RACChannelTo(b, strongTestObjectValue.stringValue);
+		a.strongTestObjectValue = [[RACTestObject alloc] init];
+		b.strongTestObjectValue = [[RACTestObject alloc] init];
+		
+		a.strongTestObjectValue.stringValue = testName1;
+		expect(a.strongTestObjectValue.stringValue).to.equal(testName1);
+		expect(b.strongTestObjectValue.stringValue).to.equal(testName1);
+		expect(a.strongTestObjectValue).notTo.equal(b.strongTestObjectValue);
+		
+		b.strongTestObjectValue = nil;
+		expect(a.strongTestObjectValue.stringValue).to.beNil();
+		
+		c.stringValue = testName2;
+		b.strongTestObjectValue = c;
+		expect(a.strongTestObjectValue.stringValue).to.equal(testName2);
+		expect(b.strongTestObjectValue.stringValue).to.equal(testName2);
+		expect(a.strongTestObjectValue).notTo.equal(b.strongTestObjectValue);
+	});
+	
+	it(@"should update properties identified by keypaths when the intermediate values change", ^{
+		RACChannelTo(a, strongTestObjectValue.stringValue) = RACChannelTo(b, strongTestObjectValue.stringValue);
+		a.strongTestObjectValue = [[RACTestObject alloc] init];
+		b.strongTestObjectValue = [[RACTestObject alloc] init];
+		c.stringValue = testName1;
+		b.strongTestObjectValue = c;
+		
+		expect(a.strongTestObjectValue.stringValue).to.equal(testName1);
+		expect(a.strongTestObjectValue).notTo.equal(b.strongTestObjectValue);
+	});
+	
+	it(@"should update properties identified by keypaths when the channel was created when one of the two objects had an intermediate nil value", ^{
+		RACChannelTo(a, strongTestObjectValue.stringValue) = RACChannelTo(b, strongTestObjectValue.stringValue);
+		b.strongTestObjectValue = [[RACTestObject alloc] init];
+		c.stringValue = testName1;
+		a.strongTestObjectValue = c;
+		
+		expect(a.strongTestObjectValue.stringValue).to.equal(testName1);
+		expect(b.strongTestObjectValue.stringValue).to.equal(testName1);
+		expect(a.strongTestObjectValue).notTo.equal(b.strongTestObjectValue);
+	});
+	
+	it(@"should take the value of the object being bound to at the start", ^{
+		a.stringValue = testName1;
+		b.stringValue = testName2;
+
+		RACChannelTo(a, stringValue) = RACChannelTo(b, stringValue);
+		expect(a.stringValue).to.equal(testName2);
+		expect(b.stringValue).to.equal(testName2);
+	});
+	
+	it(@"should update the value even if it's the same value the object had before it was bound", ^{
+		a.stringValue = testName1;
+		b.stringValue = testName2;
+
+		RACChannelTo(a, stringValue) = RACChannelTo(b, stringValue);
+		expect(a.stringValue).to.equal(testName2);
+		expect(b.stringValue).to.equal(testName2);
+		
+		b.stringValue = testName1;
+		expect(a.stringValue).to.equal(testName1);
+		expect(b.stringValue).to.equal(testName1);
+	});
+	
+	it(@"should bind transitively", ^{
+		a.stringValue = testName1;
+		b.stringValue = testName2;
+		c.stringValue = testName3;
+
+		RACChannelTo(a, stringValue) = RACChannelTo(b, stringValue);
+		RACChannelTo(b, stringValue) = RACChannelTo(c, stringValue);
+		expect(a.stringValue).to.equal(testName3);
+		expect(b.stringValue).to.equal(testName3);
+		expect(c.stringValue).to.equal(testName3);
+		
+		c.stringValue = testName1;
+		expect(a.stringValue).to.equal(testName1);
+		expect(b.stringValue).to.equal(testName1);
+		expect(c.stringValue).to.equal(testName1);
+		
+		b.stringValue = testName2;
+		expect(a.stringValue).to.equal(testName2);
+		expect(b.stringValue).to.equal(testName2);
+		expect(c.stringValue).to.equal(testName2);
+		
+		a.stringValue = testName3;
+		expect(a.stringValue).to.equal(testName3);
+		expect(b.stringValue).to.equal(testName3);
+		expect(c.stringValue).to.equal(testName3);
+	});
+	
+	it(@"should bind changes made by KVC on arrays", ^{
+		b.arrayValue = @[];
+		RACChannelTo(a, arrayValue) = RACChannelTo(b, arrayValue);
+
+		[[b mutableArrayValueForKeyPath:@keypath(b.arrayValue)] addObject:@1];
+		expect(a.arrayValue).to.equal(b.arrayValue);
+	});
+	
+	it(@"should bind changes made by KVC on sets", ^{
+		b.setValue = [NSSet set];
+		RACChannelTo(a, setValue) = RACChannelTo(b, setValue);
+
+		[[b mutableSetValueForKeyPath:@keypath(b.setValue)] addObject:@1];
+		expect(a.setValue).to.equal(b.setValue);
+	});
+	
+	it(@"should bind changes made by KVC on ordered sets", ^{
+		b.orderedSetValue = [NSOrderedSet orderedSet];
+		RACChannelTo(a, orderedSetValue) = RACChannelTo(b, orderedSetValue);
+
+		[[b mutableOrderedSetValueForKeyPath:@keypath(b.orderedSetValue)] addObject:@1];
+		expect(a.orderedSetValue).to.equal(b.orderedSetValue);
+	});
+	
+	it(@"should handle deallocation of intermediate objects correctly even without support from KVO", ^{
+		__block BOOL wasDisposed = NO;
+
+		RACChannelTo(a, weakTestObjectValue.stringValue) = RACChannelTo(b, strongTestObjectValue.stringValue);
+		b.strongTestObjectValue = [[RACTestObject alloc] init];
+
+		@autoreleasepool {
+			RACTestObject *object = [[RACTestObject alloc] init];
+			[object.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				wasDisposed = YES;
+			}]];
+			
+			a.weakTestObjectValue = object;
+			object.stringValue = testName1;
+			
+			expect(wasDisposed).to.beFalsy();
+			expect(b.strongTestObjectValue.stringValue).to.equal(testName1);
+		}
+		
+		expect(wasDisposed).will.beTruthy();
+		expect(b.strongTestObjectValue.stringValue).to.beNil();
+	});
+	
+	it(@"should stop binding when disposed", ^{
+		RACChannelTerminal *aTerminal = RACChannelTo(a, stringValue);
+		RACChannelTerminal *bTerminal = RACChannelTo(b, stringValue);
+
+		a.stringValue = testName1;
+		RACDisposable *disposable = [aTerminal subscribe:bTerminal];
+
+		expect(a.stringValue).to.equal(testName1);
+		expect(b.stringValue).to.equal(testName1);
+
+		a.stringValue = testName2;
+		expect(a.stringValue).to.equal(testName2);
+		expect(b.stringValue).to.equal(testName2);
+
+		[disposable dispose];
+
+		a.stringValue = testName3;
+		expect(a.stringValue).to.equal(testName3);
+		expect(b.stringValue).to.equal(testName2);
+	});
+	
+	it(@"should use the nilValue when sent nil", ^{
+		RACChannelTerminal *terminal = RACChannelTo(a, integerValue, @5);
+		expect(a.integerValue).to.equal(0);
+
+		[terminal sendNext:@2];
+		expect(a.integerValue).to.equal(2);
+
+		[terminal sendNext:nil];
+		expect(a.integerValue).to.equal(5);
+	});
+
+	it(@"should use the nilValue when an intermediate object is nil", ^{
+		__block BOOL wasDisposed = NO;
+
+		RACChannelTo(a, weakTestObjectValue.integerValue, @5) = RACChannelTo(b, strongTestObjectValue.integerValue, @5);
+		b.strongTestObjectValue = [[RACTestObject alloc] init];
+
+		@autoreleasepool {
+			RACTestObject *object = [[RACTestObject alloc] init];
+			[object.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				wasDisposed = YES;
+			}]];
+			
+			a.weakTestObjectValue = object;
+			object.integerValue = 2;
+
+			expect(wasDisposed).to.beFalsy();
+			expect(b.strongTestObjectValue.integerValue).to.equal(2);
+		}
+		
+		expect(wasDisposed).will.beTruthy();
+		expect(b.strongTestObjectValue.integerValue).to.equal(5);
+	});
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACKVOWrapperSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACKVOWrapperSpec.m
new file mode 100644
index 0000000..dc207ef
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACKVOWrapperSpec.m
@@ -0,0 +1,656 @@
+//
+//  RACKVOWrapperSpec.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-08-07.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "NSObject+RACKVOWrapper.h"
+
+#import "EXTKeyPathCoding.h"
+#import "NSObject+RACDeallocating.h"
+#import "RACCompoundDisposable.h"
+#import "RACDisposable.h"
+#import "RACKVOTrampoline.h"
+#import "RACTestObject.h"
+
+@interface RACTestOperation : NSOperation
+@end
+
+// The name of the examples.
+static NSString * const RACKVOWrapperExamples = @"RACKVOWrapperExamples";
+
+// A block that returns an object to observe in the examples.
+static NSString * const RACKVOWrapperExamplesTargetBlock = @"RACKVOWrapperExamplesTargetBlock";
+
+// The key path to observe in the examples.
+//
+// The key path must have at least one weak property in it.
+static NSString * const RACKVOWrapperExamplesKeyPath = @"RACKVOWrapperExamplesKeyPath";
+
+// A block that changes the value of a weak property in the observed key path.
+// The block is passed the object the example is observing and the new value the
+// weak property should be changed to.
+static NSString * const RACKVOWrapperExamplesChangeBlock = @"RACKVOWrapperExamplesChangeBlock";
+
+// A block that returns a valid value for the weak property changed by
+// RACKVOWrapperExamplesChangeBlock. The value must deallocate
+// normally.
+static NSString * const RACKVOWrapperExamplesValueBlock = @"RACKVOWrapperExamplesValueBlock";
+
+// Whether RACKVOWrapperExamplesChangeBlock changes the value
+// of the last key path component in the key path directly.
+static NSString * const RACKVOWrapperExamplesChangesValueDirectly = @"RACKVOWrapperExamplesChangesValueDirectly";
+
+// The name of the examples.
+static NSString * const RACKVOWrapperCollectionExamples = @"RACKVOWrapperCollectionExamples";
+
+// A block that returns an object to observe in the examples.
+static NSString * const RACKVOWrapperCollectionExamplesTargetBlock = @"RACKVOWrapperCollectionExamplesTargetBlock";
+
+// The key path to observe in the examples.
+//
+// Must identify a property of type NSOrderedSet.
+static NSString * const RACKVOWrapperCollectionExamplesKeyPath = @"RACKVOWrapperCollectionExamplesKeyPath";
+
+SharedExampleGroupsBegin(RACKVOWrapperExamples)
+
+sharedExamplesFor(RACKVOWrapperExamples, ^(NSDictionary *data) {
+	__block NSObject *target = nil;
+	__block NSString *keyPath = nil;
+	__block void (^changeBlock)(NSObject *, id) = nil;
+	__block id (^valueBlock)(void) = nil;
+	__block BOOL changesValueDirectly = NO;
+
+	__block NSUInteger priorCallCount = 0;
+	__block NSUInteger posteriorCallCount = 0;
+	__block BOOL priorTriggeredByLastKeyPathComponent = NO;
+	__block BOOL posteriorTriggeredByLastKeyPathComponent = NO;
+	__block BOOL posteriorTriggeredByDeallocation = NO;
+	__block void (^callbackBlock)(id, NSDictionary *) = nil;
+
+	beforeEach(^{
+		NSObject * (^targetBlock)(void) = data[RACKVOWrapperExamplesTargetBlock];
+		target = targetBlock();
+		keyPath = data[RACKVOWrapperExamplesKeyPath];
+		changeBlock = data[RACKVOWrapperExamplesChangeBlock];
+		valueBlock = data[RACKVOWrapperExamplesValueBlock];
+		changesValueDirectly = [data[RACKVOWrapperExamplesChangesValueDirectly] boolValue];
+
+		priorCallCount = 0;
+		posteriorCallCount = 0;
+
+		callbackBlock = [^(id value, NSDictionary *change) {
+			if ([change[NSKeyValueChangeNotificationIsPriorKey] boolValue]) {
+				priorTriggeredByLastKeyPathComponent = [change[RACKeyValueChangeAffectedOnlyLastComponentKey] boolValue];
+				++priorCallCount;
+				return;
+			}
+			posteriorTriggeredByLastKeyPathComponent = [change[RACKeyValueChangeAffectedOnlyLastComponentKey] boolValue];
+			posteriorTriggeredByDeallocation = [change[RACKeyValueChangeCausedByDeallocationKey] boolValue];
+			++posteriorCallCount;
+		} copy];
+	});
+
+	afterEach(^{
+		target = nil;
+		keyPath = nil;
+		changeBlock = nil;
+		valueBlock = nil;
+		changesValueDirectly = NO;
+
+		callbackBlock = nil;
+	});
+
+	it(@"should not call the callback block on add if called without NSKeyValueObservingOptionInitial", ^{
+		[target rac_observeKeyPath:keyPath options:NSKeyValueObservingOptionPrior observer:nil block:callbackBlock];
+		expect(priorCallCount).to.equal(0);
+		expect(posteriorCallCount).to.equal(0);
+	});
+
+	it(@"should call the callback block on add if called with NSKeyValueObservingOptionInitial", ^{
+		[target rac_observeKeyPath:keyPath options:NSKeyValueObservingOptionPrior | NSKeyValueObservingOptionInitial observer:nil block:callbackBlock];
+		expect(priorCallCount).to.equal(0);
+		expect(posteriorCallCount).to.equal(1);
+	});
+
+	it(@"should call the callback block twice per change, once prior and once posterior", ^{
+		[target rac_observeKeyPath:keyPath options:NSKeyValueObservingOptionPrior observer:nil block:callbackBlock];
+		priorCallCount = 0;
+		posteriorCallCount = 0;
+
+		id value1 = valueBlock();
+		changeBlock(target, value1);
+		expect(priorCallCount).to.equal(1);
+		expect(posteriorCallCount).to.equal(1);
+		expect(priorTriggeredByLastKeyPathComponent).to.equal(changesValueDirectly);
+		expect(posteriorTriggeredByLastKeyPathComponent).to.equal(changesValueDirectly);
+		expect(posteriorTriggeredByDeallocation).to.beFalsy();
+
+		id value2 = valueBlock();
+		changeBlock(target, value2);
+		expect(priorCallCount).to.equal(2);
+		expect(posteriorCallCount).to.equal(2);
+		expect(priorTriggeredByLastKeyPathComponent).to.equal(changesValueDirectly);
+		expect(posteriorTriggeredByLastKeyPathComponent).to.equal(changesValueDirectly);
+		expect(posteriorTriggeredByDeallocation).to.beFalsy();
+	});
+
+	it(@"should call the callback block with NSKeyValueChangeNotificationIsPriorKey set before the value is changed, and not set after the value is changed", ^{
+		__block BOOL priorCalled = NO;
+		__block BOOL posteriorCalled = NO;
+		__block id priorValue = nil;
+		__block id posteriorValue = nil;
+
+		id value1 = valueBlock();
+		changeBlock(target, value1);
+		id oldValue = [target valueForKeyPath:keyPath];
+
+		[target rac_observeKeyPath:keyPath options:NSKeyValueObservingOptionPrior observer:nil block:^(id value, NSDictionary *change) {
+			if ([change[NSKeyValueChangeNotificationIsPriorKey] boolValue]) {
+				priorCalled = YES;
+				priorValue = value;
+				expect(posteriorCalled).to.beFalsy();
+				return;
+			}
+			posteriorCalled = YES;
+			posteriorValue = value;
+			expect(priorCalled).to.beTruthy();
+		}];
+
+		id value2 = valueBlock();
+		changeBlock(target, value2);
+		id newValue = [target valueForKeyPath:keyPath];
+		expect(priorCalled).to.beTruthy();
+		expect(priorValue).to.equal(oldValue);
+		expect(posteriorCalled).to.beTruthy();
+		expect(posteriorValue).to.equal(newValue);
+	});
+
+	it(@"should not call the callback block after it's been disposed", ^{
+		RACDisposable *disposable = [target rac_observeKeyPath:keyPath options:NSKeyValueObservingOptionPrior observer:nil block:callbackBlock];
+		priorCallCount = 0;
+		posteriorCallCount = 0;
+
+		[disposable dispose];
+		expect(priorCallCount).to.equal(0);
+		expect(posteriorCallCount).to.equal(0);
+
+		id value = valueBlock();
+		changeBlock(target, value);
+		expect(priorCallCount).to.equal(0);
+		expect(posteriorCallCount).to.equal(0);
+	});
+
+	it(@"should call the callback block only once with NSKeyValueChangeNotificationIsPriorKey not set when the value is deallocated", ^{
+		__block BOOL valueDidDealloc = NO;
+
+		[target rac_observeKeyPath:keyPath options:NSKeyValueObservingOptionPrior observer:nil block:callbackBlock];
+
+		@autoreleasepool {
+			NSObject *value __attribute__((objc_precise_lifetime)) = valueBlock();
+			[value.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				valueDidDealloc = YES;
+			}]];
+
+			changeBlock(target, value);
+			priorCallCount = 0;
+			posteriorCallCount = 0;
+		}
+
+		expect(valueDidDealloc).to.beTruthy();
+		expect(priorCallCount).to.equal(0);
+		expect(posteriorCallCount).to.equal(1);
+		expect(posteriorTriggeredByDeallocation).to.beTruthy();
+	});
+});
+
+sharedExamplesFor(RACKVOWrapperCollectionExamples, ^(NSDictionary *data) {
+	__block NSObject *target = nil;
+	__block NSString *keyPath = nil;
+	__block NSMutableOrderedSet *mutableKeyPathProxy = nil;
+	__block void (^callbackBlock)(id, NSDictionary *) = nil;
+
+	__block id priorValue = nil;
+	__block id posteriorValue = nil;
+	__block NSDictionary *priorChange = nil;
+	__block NSDictionary *posteriorChange = nil;
+
+	beforeEach(^{
+		NSObject * (^targetBlock)(void) = data[RACKVOWrapperCollectionExamplesTargetBlock];
+		target = targetBlock();
+		keyPath = data[RACKVOWrapperCollectionExamplesKeyPath];
+
+		callbackBlock = [^(id value, NSDictionary *change) {
+			if ([change[NSKeyValueChangeNotificationIsPriorKey] boolValue]) {
+				priorValue = value;
+				priorChange = change;
+				return;
+			}
+			posteriorValue = value;
+			posteriorChange = change;
+		} copy];
+
+		[target setValue:[NSOrderedSet orderedSetWithObject:@0] forKeyPath:keyPath];
+		[target rac_observeKeyPath:keyPath options:NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld | NSKeyValueObservingOptionPrior observer:nil block:callbackBlock];
+		mutableKeyPathProxy = [target mutableOrderedSetValueForKeyPath:keyPath];
+	});
+
+	afterEach(^{
+		target = nil;
+		keyPath = nil;
+		callbackBlock = nil;
+
+		priorValue = nil;
+		priorChange = nil;
+		posteriorValue = nil;
+		posteriorChange = nil;
+	});
+
+	it(@"should support inserting elements into ordered collections", ^{
+		[mutableKeyPathProxy insertObject:@1 atIndex:0];
+
+		expect(priorValue).to.equal([NSOrderedSet orderedSetWithArray:@[ @0 ]]);
+		expect(posteriorValue).to.equal([NSOrderedSet orderedSetWithArray:(@[ @1, @0 ])]);
+		expect(priorChange[NSKeyValueChangeKindKey]).to.equal(NSKeyValueChangeInsertion);
+		expect(posteriorChange[NSKeyValueChangeKindKey]).to.equal(NSKeyValueChangeInsertion);
+		expect(priorChange[NSKeyValueChangeOldKey]).to.beNil();
+		expect(posteriorChange[NSKeyValueChangeNewKey]).to.equal(@[ @1 ]);
+		expect(priorChange[NSKeyValueChangeIndexesKey]).to.equal([NSIndexSet indexSetWithIndex:0]);
+		expect(posteriorChange[NSKeyValueChangeIndexesKey]).to.equal([NSIndexSet indexSetWithIndex:0]);
+	});
+
+	it(@"should support removing elements from ordered collections", ^{
+		[mutableKeyPathProxy removeObjectAtIndex:0];
+
+		expect(priorValue).to.equal([NSOrderedSet orderedSetWithArray:@[ @0 ]]);
+		expect(posteriorValue).to.equal([NSOrderedSet orderedSetWithArray:@[]]);
+		expect(priorChange[NSKeyValueChangeKindKey]).to.equal(NSKeyValueChangeRemoval);
+		expect(posteriorChange[NSKeyValueChangeKindKey]).to.equal(NSKeyValueChangeRemoval);
+		expect(priorChange[NSKeyValueChangeOldKey]).to.equal(@[ @0 ]);
+		expect(posteriorChange[NSKeyValueChangeNewKey]).to.beNil();
+		expect(priorChange[NSKeyValueChangeIndexesKey]).to.equal([NSIndexSet indexSetWithIndex:0]);
+		expect(posteriorChange[NSKeyValueChangeIndexesKey]).to.equal([NSIndexSet indexSetWithIndex:0]);
+	});
+
+	it(@"should support replacing elements in ordered collections", ^{
+		[mutableKeyPathProxy replaceObjectAtIndex:0 withObject:@1];
+
+		expect(priorValue).to.equal([NSOrderedSet orderedSetWithArray:@[ @0 ]]);
+		expect(posteriorValue).to.equal([NSOrderedSet orderedSetWithArray:@[ @1 ]]);
+		expect(priorChange[NSKeyValueChangeKindKey]).to.equal(NSKeyValueChangeReplacement);
+		expect(posteriorChange[NSKeyValueChangeKindKey]).to.equal(NSKeyValueChangeReplacement);
+		expect(priorChange[NSKeyValueChangeOldKey]).to.equal(@[ @0 ]);
+		expect(posteriorChange[NSKeyValueChangeNewKey]).to.equal(@[ @1 ]);
+		expect(priorChange[NSKeyValueChangeIndexesKey]).to.equal([NSIndexSet indexSetWithIndex:0]);
+		expect(posteriorChange[NSKeyValueChangeIndexesKey]).to.equal([NSIndexSet indexSetWithIndex:0]);
+	});
+
+	it(@"should support adding elements to unordered collections", ^{
+		[mutableKeyPathProxy unionOrderedSet:[NSOrderedSet orderedSetWithObject:@1]];
+
+		expect(priorValue).to.equal([NSOrderedSet orderedSetWithArray:@[ @0 ]]);
+		expect(posteriorValue).to.equal([NSOrderedSet orderedSetWithArray:(@[ @0, @1 ])]);
+		expect(priorChange[NSKeyValueChangeKindKey]).to.equal(NSKeyValueChangeInsertion);
+		expect(posteriorChange[NSKeyValueChangeKindKey]).to.equal(NSKeyValueChangeInsertion);
+		expect(priorChange[NSKeyValueChangeOldKey]).to.beNil();
+		expect(posteriorChange[NSKeyValueChangeNewKey]).to.equal(@[ @1 ]);
+	});
+
+	it(@"should support removing elements from unordered collections", ^{
+		[mutableKeyPathProxy minusOrderedSet:[NSOrderedSet orderedSetWithObject:@0]];
+
+		expect(priorValue).to.equal([NSOrderedSet orderedSetWithArray:@[ @0 ]]);
+		expect(posteriorValue).to.equal([NSOrderedSet orderedSetWithArray:@[]]);
+		expect(priorChange[NSKeyValueChangeKindKey]).to.equal(NSKeyValueChangeRemoval);
+		expect(posteriorChange[NSKeyValueChangeKindKey]).to.equal(NSKeyValueChangeRemoval);
+		expect(priorChange[NSKeyValueChangeOldKey]).to.equal(@[ @0 ]);
+		expect(posteriorChange[NSKeyValueChangeNewKey]).to.beNil();
+	});
+});
+
+SharedExampleGroupsEnd
+
+SpecBegin(RACKVOWrapper)
+
+describe(@"-rac_observeKeyPath:options:observer:block:", ^{
+	describe(@"on simple keys", ^{
+		NSObject * (^targetBlock)(void) = ^{
+			return [[RACTestObject alloc] init];
+		};
+
+		void (^changeBlock)(RACTestObject *, id) = ^(RACTestObject *target, id value) {
+			target.weakTestObjectValue = value;
+		};
+
+		id (^valueBlock)(void) = ^{
+			return [[RACTestObject alloc] init];
+		};
+
+		itShouldBehaveLike(RACKVOWrapperExamples, @{
+			RACKVOWrapperExamplesTargetBlock: targetBlock,
+			RACKVOWrapperExamplesKeyPath: @keypath(RACTestObject.new, weakTestObjectValue),
+			RACKVOWrapperExamplesChangeBlock: changeBlock,
+			RACKVOWrapperExamplesValueBlock: valueBlock,
+			RACKVOWrapperExamplesChangesValueDirectly: @YES
+		});
+
+		itShouldBehaveLike(RACKVOWrapperCollectionExamples, @{
+			RACKVOWrapperCollectionExamplesTargetBlock: targetBlock,
+			RACKVOWrapperCollectionExamplesKeyPath: @keypath(RACTestObject.new, orderedSetValue)
+		});
+	});
+
+	describe(@"on composite key paths'", ^{
+		describe(@"last key path components", ^{
+			NSObject *(^targetBlock)(void) = ^{
+				RACTestObject *object = [[RACTestObject alloc] init];
+				object.strongTestObjectValue = [[RACTestObject alloc] init];
+				return object;
+			};
+
+			void (^changeBlock)(RACTestObject *, id) = ^(RACTestObject *target, id value) {
+				target.strongTestObjectValue.weakTestObjectValue = value;
+			};
+
+			id (^valueBlock)(void) = ^{
+				return [[RACTestObject alloc] init];
+			};
+
+			itShouldBehaveLike(RACKVOWrapperExamples, @{
+				RACKVOWrapperExamplesTargetBlock: targetBlock,
+				RACKVOWrapperExamplesKeyPath: @keypath(RACTestObject.new, strongTestObjectValue.weakTestObjectValue),
+				RACKVOWrapperExamplesChangeBlock: changeBlock,
+				RACKVOWrapperExamplesValueBlock: valueBlock,
+				RACKVOWrapperExamplesChangesValueDirectly: @YES
+			});
+
+			itShouldBehaveLike(RACKVOWrapperCollectionExamples, @{
+				RACKVOWrapperCollectionExamplesTargetBlock: targetBlock,
+				RACKVOWrapperCollectionExamplesKeyPath: @keypath(RACTestObject.new, strongTestObjectValue.orderedSetValue)
+			});
+		});
+
+		describe(@"intermediate key path components", ^{
+			NSObject *(^targetBlock)(void) = ^{
+				return [[RACTestObject alloc] init];
+			};
+
+			void (^changeBlock)(RACTestObject *, id) = ^(RACTestObject *target, id value) {
+				target.weakTestObjectValue = value;
+			};
+
+			id (^valueBlock)(void) = ^{
+				RACTestObject *object = [[RACTestObject alloc] init];
+				object.strongTestObjectValue = [[RACTestObject alloc] init];
+				return object;
+			};
+
+			itShouldBehaveLike(RACKVOWrapperExamples, @{
+				RACKVOWrapperExamplesTargetBlock: targetBlock,
+				RACKVOWrapperExamplesKeyPath: @keypath([[RACTestObject alloc] init], weakTestObjectValue.strongTestObjectValue),
+				RACKVOWrapperExamplesChangeBlock: changeBlock,
+				RACKVOWrapperExamplesValueBlock: valueBlock,
+				RACKVOWrapperExamplesChangesValueDirectly: @NO
+			});
+		});
+
+		it(@"should not notice deallocation of the object returned by a dynamic final property", ^{
+			RACTestObject *object = [[RACTestObject alloc] init];
+
+			__block id lastValue = nil;
+			@autoreleasepool {
+				[object rac_observeKeyPath:@keypath(object.dynamicObjectProperty) options:NSKeyValueObservingOptionInitial observer:nil block:^(id value, NSDictionary *change) {
+					lastValue = value;
+				}];
+
+				expect(lastValue).to.beKindOf(RACTestObject.class);
+			}
+
+			expect(lastValue).to.beKindOf(RACTestObject.class);
+		});
+
+		it(@"should not notice deallocation of the object returned by a dynamic intermediate property", ^{
+			RACTestObject *object = [[RACTestObject alloc] init];
+
+			__block id lastValue = nil;
+			@autoreleasepool {
+				[object rac_observeKeyPath:@keypath(object.dynamicObjectProperty.integerValue) options:NSKeyValueObservingOptionInitial observer:nil block:^(id value, NSDictionary *change) {
+					lastValue = value;
+				}];
+
+				expect(lastValue).to.equal(@42);
+			}
+
+			expect(lastValue).to.equal(@42);
+		});
+
+		it(@"should not notice deallocation of the object returned by a dynamic method", ^{
+			RACTestObject *object = [[RACTestObject alloc] init];
+
+			__block id lastValue = nil;
+			@autoreleasepool {
+				[object rac_observeKeyPath:@keypath(object.dynamicObjectMethod) options:NSKeyValueObservingOptionInitial observer:nil block:^(id value, NSDictionary *change) {
+					lastValue = value;
+				}];
+
+				expect(lastValue).to.beKindOf(RACTestObject.class);
+			}
+
+			expect(lastValue).to.beKindOf(RACTestObject.class);
+		});
+	});
+
+	it(@"should not call the callback block when the value is the observer", ^{
+		__block BOOL observerDisposed = NO;
+		__block BOOL observerDeallocationTriggeredChange = NO;
+		__block BOOL targetDisposed = NO;
+		__block BOOL targetDeallocationTriggeredChange = NO;
+
+		@autoreleasepool {
+			RACTestObject *observer __attribute__((objc_precise_lifetime)) = [RACTestObject new];
+			[observer.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				observerDisposed = YES;
+			}]];
+
+			RACTestObject *target __attribute__((objc_precise_lifetime)) = [RACTestObject new];
+			[target.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				targetDisposed = YES;
+			}]];
+
+			observer.weakTestObjectValue = observer;
+			target.weakTestObjectValue = target;
+
+			// These observations can only result in dealloc triggered callbacks.
+			[observer rac_observeKeyPath:@keypath(target.weakTestObjectValue) options:0 observer:observer block:^(id _, NSDictionary *__) {
+				observerDeallocationTriggeredChange = YES;
+			}];
+
+			[target rac_observeKeyPath:@keypath(target.weakTestObjectValue) options:0 observer:observer block:^(id _, NSDictionary *__) {
+				targetDeallocationTriggeredChange = YES;
+			}];
+		}
+
+		expect(observerDisposed).to.beTruthy();
+		expect(observerDeallocationTriggeredChange).to.beFalsy();
+
+		expect(targetDisposed).to.beTruthy();
+		expect(targetDeallocationTriggeredChange).to.beTruthy();
+	});
+
+	it(@"should call the callback block for deallocation of the initial value of a single-key key path", ^{
+		RACTestObject *target = [RACTestObject new];
+		__block BOOL objectDisposed = NO;
+		__block BOOL objectDeallocationTriggeredChange = NO;
+
+		@autoreleasepool {
+			RACTestObject *object __attribute__((objc_precise_lifetime)) = [RACTestObject new];
+			target.weakTestObjectValue = object;
+			[object.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				objectDisposed = YES;
+			}]];
+
+			[target rac_observeKeyPath:@keypath(target.weakTestObjectValue) options:0 observer:target block:^(id _, NSDictionary *__) {
+				objectDeallocationTriggeredChange = YES;
+			}];
+		}
+
+		expect(objectDisposed).to.beTruthy();
+		expect(objectDeallocationTriggeredChange).to.beTruthy();
+	});
+
+	it(@"should call the callback block for deallocation of an object conforming to protocol property", ^{
+		RACTestObject *target = [RACTestObject new];
+		__block BOOL objectDisposed = NO;
+		__block BOOL objectDeallocationTriggeredChange = NO;
+
+		@autoreleasepool {
+			RACTestObject *object __attribute__((objc_precise_lifetime)) = [RACTestObject new];
+			target.weakObjectWithProtocol = object;
+			[object.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				objectDisposed = YES;
+			}]];
+
+			[target rac_observeKeyPath:@keypath(target.weakObjectWithProtocol) options:0 observer:target block:^(id _, NSDictionary *__) {
+				objectDeallocationTriggeredChange = YES;
+			}];
+		}
+
+		expect(objectDisposed).to.beTruthy();
+		expect(objectDeallocationTriggeredChange).to.beTruthy();
+    });
+});
+
+describe(@"rac_addObserver:forKeyPath:options:block:", ^{
+	it(@"should add and remove an observer", ^{
+		NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{}];
+		expect(operation).notTo.beNil();
+
+		__block BOOL notified = NO;
+		RACDisposable *disposable = [operation rac_observeKeyPath:@"isFinished" options:NSKeyValueObservingOptionNew observer:self block:^(id value, NSDictionary *change) {
+			expect([change objectForKey:NSKeyValueChangeNewKey]).to.equal(@YES);
+
+			expect(notified).to.beFalsy();
+			notified = YES;
+		}];
+
+		expect(disposable).notTo.beNil();
+
+		[operation start];
+		[operation waitUntilFinished];
+
+		expect(notified).will.beTruthy();
+	});
+
+	it(@"should accept a nil observer", ^{
+		NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{}];
+		RACDisposable *disposable = [operation rac_observeKeyPath:@"isFinished" options:NSKeyValueObservingOptionNew observer:nil block:^(id value, NSDictionary *change) {}];
+
+		expect(disposable).notTo.beNil();
+	});
+
+	it(@"automatically stops KVO on subclasses when the target deallocates", ^{
+		void (^testKVOOnSubclass)(Class targetClass, id observer) = ^(Class targetClass, id observer) {
+			__weak id weakTarget = nil;
+			__weak id identifier = nil;
+
+			@autoreleasepool {
+				// Create an observable target that we control the memory management of.
+				CFTypeRef target = CFBridgingRetain([[targetClass alloc] init]);
+				expect(target).notTo.beNil();
+
+				weakTarget = (__bridge id)target;
+				expect(weakTarget).notTo.beNil();
+
+				identifier = [(__bridge id)target rac_observeKeyPath:@"isFinished" options:0 observer:observer block:^(id value, NSDictionary *change) {}];
+				expect(identifier).notTo.beNil();
+
+				CFRelease(target);
+			}
+
+			expect(weakTarget).to.beNil();
+			expect(identifier).to.beNil();
+		};
+
+		it (@"stops KVO on NSObject subclasses", ^{
+			testKVOOnSubclass(NSOperation.class, self);
+		});
+
+		it(@"stops KVO on subclasses of already-swizzled classes", ^{
+			testKVOOnSubclass(RACTestOperation.class, self);
+		});
+
+		it (@"stops KVO on NSObject subclasses even with a nil observer", ^{
+			testKVOOnSubclass(NSOperation.class, nil);
+		});
+
+		it(@"stops KVO on subclasses of already-swizzled classes even with a nil observer", ^{
+			testKVOOnSubclass(RACTestOperation.class, nil);
+		});
+	});
+
+	it(@"should automatically stop KVO when the observer deallocates", ^{
+		__weak id weakObserver = nil;
+		__weak id identifier = nil;
+
+		NSOperation *operation = [[NSOperation alloc] init];
+
+		@autoreleasepool {
+			// Create an observer that we control the memory management of.
+			CFTypeRef observer = CFBridgingRetain([[NSOperation alloc] init]);
+			expect(observer).notTo.beNil();
+
+			weakObserver = (__bridge id)observer;
+			expect(weakObserver).notTo.beNil();
+
+			identifier = [operation rac_observeKeyPath:@"isFinished" options:0 observer:(__bridge id)observer block:^(id value, NSDictionary *change) {}];
+			expect(identifier).notTo.beNil();
+
+			CFRelease(observer);
+		}
+
+		expect(weakObserver).to.beNil();
+	});
+
+	it(@"should stop KVO when the observer is disposed", ^{
+		NSOperationQueue *queue = [[NSOperationQueue alloc] init];
+		__block NSString *name = nil;
+
+		RACDisposable *disposable = [queue rac_observeKeyPath:@"name" options:0 observer:self block:^(id value, NSDictionary *change) {
+			name = queue.name;
+		}];
+
+		queue.name = @"1";
+		expect(name).to.equal(@"1");
+		[disposable dispose];
+		queue.name = @"2";
+		expect(name).to.equal(@"1");
+	});
+
+	it(@"should distinguish between observers being disposed", ^{
+		NSOperationQueue *queue = [[NSOperationQueue alloc] init];
+		__block NSString *name1 = nil;
+		__block NSString *name2 = nil;
+
+		RACDisposable *disposable = [queue rac_observeKeyPath:@"name" options:0 observer:self block:^(id value, NSDictionary *change) {
+			name1 = queue.name;
+		}];
+		[queue rac_observeKeyPath:@"name" options:0 observer:self block:^(id value, NSDictionary *change) {
+			name2 = queue.name;
+		}];
+
+		queue.name = @"1";
+		expect(name1).to.equal(@"1");
+		expect(name2).to.equal(@"1");
+		[disposable dispose];
+		queue.name = @"2";
+		expect(name1).to.equal(@"1");
+		expect(name2).to.equal(@"2");
+	});
+});
+
+SpecEnd
+
+@implementation RACTestOperation
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACMulticastConnectionSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACMulticastConnectionSpec.m
new file mode 100644
index 0000000..b043beb
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACMulticastConnectionSpec.m
@@ -0,0 +1,142 @@
+//
+//  RACMulticastConnectionSpec.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 10/8/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACMulticastConnection.h"
+#import "RACDisposable.h"
+#import "RACSignal+Operations.h"
+#import "RACSubscriber.h"
+#import "RACReplaySubject.h"
+#import "RACScheduler.h"
+#import <libkern/OSAtomic.h>
+
+SpecBegin(RACMulticastConnection)
+
+__block NSUInteger subscriptionCount = 0;
+__block RACMulticastConnection *connection;
+__block BOOL disposed = NO;
+
+beforeEach(^{
+	subscriptionCount = 0;
+	disposed = NO;
+	connection = [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+		subscriptionCount++;
+		return [RACDisposable disposableWithBlock:^{
+			disposed = YES;
+		}];
+	}] publish];
+	expect(subscriptionCount).to.equal(0);
+});
+
+describe(@"-connect", ^{
+	it(@"should subscribe to the underlying signal", ^{
+		[connection connect];
+		expect(subscriptionCount).to.equal(1);
+	});
+
+	it(@"should return the same disposable for each invocation", ^{
+		RACDisposable *d1 = [connection connect];
+		RACDisposable *d2 = [connection connect];
+		expect(d1).to.equal(d2);
+		expect(subscriptionCount).to.equal(1);
+	});
+
+	it(@"shouldn't reconnect after disposal", ^{
+		RACDisposable *disposable1 = [connection connect];
+		expect(subscriptionCount).to.equal(1);
+
+		[disposable1 dispose];
+		
+		RACDisposable *disposable2 = [connection connect];
+		expect(subscriptionCount).to.equal(1);
+		expect(disposable1).to.equal(disposable2);
+	});
+
+	it(@"shouldn't race when connecting", ^{
+		dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
+
+		RACMulticastConnection *connection = [[RACSignal
+			defer:^ id {
+				dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
+				return nil;
+			}]
+			publish];
+
+		__block RACDisposable *disposable;
+		[RACScheduler.scheduler schedule:^{
+			disposable = [connection connect];
+			dispatch_semaphore_signal(semaphore);
+		}];
+
+		expect([connection connect]).notTo.beNil();
+		dispatch_semaphore_signal(semaphore);
+
+		expect(disposable).willNot.beNil();
+
+		dispatch_release(semaphore);
+	});
+});
+
+describe(@"-autoconnect", ^{
+	__block RACSignal *autoconnectedSignal;
+	
+	beforeEach(^{
+		autoconnectedSignal = [connection autoconnect];
+	});
+
+	it(@"should subscribe to the multicasted signal on the first subscription", ^{
+		expect(subscriptionCount).to.equal(0);
+		
+		[autoconnectedSignal subscribeNext:^(id x) {}];
+		expect(subscriptionCount).to.equal(1);
+
+		[autoconnectedSignal subscribeNext:^(id x) {}];
+		expect(subscriptionCount).to.equal(1);
+	});
+
+	it(@"should dispose of the multicasted subscription when the signal has no subscribers", ^{
+		RACDisposable *disposable = [autoconnectedSignal subscribeNext:^(id x) {}];
+
+		expect(disposed).to.beFalsy();
+		[disposable dispose];
+		expect(disposed).to.beTruthy();
+	});
+
+	it(@"shouldn't reconnect after disposal", ^{
+		RACDisposable *disposable = [autoconnectedSignal subscribeNext:^(id x) {}];
+		expect(subscriptionCount).to.equal(1);
+		[disposable dispose];
+
+		disposable = [autoconnectedSignal subscribeNext:^(id x) {}];
+		expect(subscriptionCount).to.equal(1);
+		[disposable dispose];
+	});
+
+	it(@"should replay values after disposal when multicasted to a replay subject", ^{
+		RACSubject *subject = [RACSubject subject];
+		RACSignal *signal = [[subject multicast:[RACReplaySubject subject]] autoconnect];
+
+		NSMutableArray *results1 = [NSMutableArray array];
+		RACDisposable *disposable = [signal subscribeNext:^(id x) {
+			[results1 addObject:x];
+		}];
+
+		[subject sendNext:@1];
+		[subject sendNext:@2];
+		
+		expect(results1).to.equal((@[ @1, @2 ]));
+		[disposable dispose];
+
+		NSMutableArray *results2 = [NSMutableArray array];
+		[signal subscribeNext:^(id x) {
+			[results2 addObject:x];
+		}];
+		expect(results2).will.equal((@[ @1, @2 ]));
+	});
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACPropertySignalExamples.h b/ReactiveCocoaFramework/ReactiveCocoaTests/RACPropertySignalExamples.h
new file mode 100644
index 0000000..59a2b43
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACPropertySignalExamples.h
@@ -0,0 +1,18 @@
+//
+//  RACPropertySignalExamples.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 9/28/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+// The name of the shared examples for a signal-driven property.
+extern NSString * const RACPropertySignalExamples;
+
+// The block should have the signature:
+//
+//   void (^)(RACTestObject *testObject, NSString *keyPath, id nilValue, RACSignal *signal)
+//
+// and should tie the value of the key path on testObject to signal. `nilValue`
+// will be used when the signal sends a `nil` value.
+extern NSString * const RACPropertySignalExamplesSetupBlock;
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACPropertySignalExamples.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACPropertySignalExamples.m
new file mode 100644
index 0000000..627d634
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACPropertySignalExamples.m
@@ -0,0 +1,180 @@
+//
+//  RACPropertySignalExamples.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 9/28/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACTestObject.h"
+
+#import "EXTKeyPathCoding.h"
+#import "NSObject+RACDeallocating.h"
+#import "NSObject+RACPropertySubscribing.h"
+#import "NSObject+RACSelectorSignal.h"
+#import "RACCompoundDisposable.h"
+#import "RACDisposable.h"
+#import "RACSubject.h"
+
+NSString * const RACPropertySignalExamples = @"RACPropertySignalExamples";
+NSString * const RACPropertySignalExamplesSetupBlock = @"RACPropertySignalExamplesSetupBlock";
+
+SharedExampleGroupsBegin(RACPropertySignalExamples)
+
+sharedExamplesFor(RACPropertySignalExamples, ^(NSDictionary *data) {
+	__block RACTestObject *testObject = nil;
+	__block void (^setupBlock)(RACTestObject *, NSString *keyPath, id nilValue, RACSignal *);
+
+	beforeEach(^{
+		setupBlock = data[RACPropertySignalExamplesSetupBlock];
+		testObject = [[RACTestObject alloc] init];
+	});
+
+	it(@"should set the value of the property with the latest value from the signal", ^{
+		RACSubject *subject = [RACSubject subject];
+		setupBlock(testObject, @keypath(testObject.objectValue), nil, subject);
+		expect(testObject.objectValue).to.beNil();
+
+		[subject sendNext:@1];
+		expect(testObject.objectValue).to.equal(@1);
+
+		[subject sendNext:@2];
+		expect(testObject.objectValue).to.equal(@2);
+
+		[subject sendNext:nil];
+		expect(testObject.objectValue).to.beNil();
+	});
+
+	it(@"should set the given nilValue for an object property", ^{
+		RACSubject *subject = [RACSubject subject];
+		setupBlock(testObject, @keypath(testObject.objectValue), @"foo", subject);
+		expect(testObject.objectValue).to.beNil();
+
+		[subject sendNext:@1];
+		expect(testObject.objectValue).to.equal(@1);
+
+		[subject sendNext:@2];
+		expect(testObject.objectValue).to.equal(@2);
+
+		[subject sendNext:nil];
+		expect(testObject.objectValue).to.equal(@"foo");
+	});
+
+	it(@"should leave the value of the property alone after the signal completes", ^{
+		RACSubject *subject = [RACSubject subject];
+		setupBlock(testObject, @keypath(testObject.objectValue), nil, subject);
+		expect(testObject.objectValue).to.beNil();
+
+		[subject sendNext:@1];
+		expect(testObject.objectValue).to.equal(@1);
+
+		[subject sendCompleted];
+		expect(testObject.objectValue).to.equal(@1);
+	});
+
+	it(@"should set the value of a non-object property with the latest value from the signal", ^{
+		RACSubject *subject = [RACSubject subject];
+		setupBlock(testObject, @keypath(testObject.integerValue), nil, subject);
+		expect(testObject.integerValue).to.equal(0);
+
+		[subject sendNext:@1];
+		expect(testObject.integerValue).to.equal(1);
+
+		[subject sendNext:@2];
+		expect(testObject.integerValue).to.equal(2);
+
+		[subject sendNext:@0];
+		expect(testObject.integerValue).to.equal(0);
+	});
+
+	it(@"should set the given nilValue for a non-object property", ^{
+		RACSubject *subject = [RACSubject subject];
+		setupBlock(testObject, @keypath(testObject.integerValue), @42, subject);
+		expect(testObject.integerValue).to.equal(0);
+
+		[subject sendNext:@1];
+		expect(testObject.integerValue).to.equal(@1);
+
+		[subject sendNext:@2];
+		expect(testObject.integerValue).to.equal(@2);
+
+		[subject sendNext:nil];
+		expect(testObject.integerValue).to.equal(@42);
+	});
+
+	it(@"should not invoke -setNilValueForKey: with a nilValue", ^{
+		RACSubject *subject = [RACSubject subject];
+		setupBlock(testObject, @keypath(testObject.integerValue), @42, subject);
+
+		__block BOOL setNilValueForKeyInvoked = NO;
+		[[testObject rac_signalForSelector:@selector(setNilValueForKey:)] subscribeNext:^(NSString *key) {
+			setNilValueForKeyInvoked = YES;
+		}];
+
+		[subject sendNext:nil];
+		expect(testObject.integerValue).to.equal(@42);
+		expect(setNilValueForKeyInvoked).to.beFalsy();
+	});
+
+	it(@"should invoke -setNilValueForKey: without a nilValue", ^{
+		RACSubject *subject = [RACSubject subject];
+		setupBlock(testObject, @keypath(testObject.integerValue), nil, subject);
+
+		[subject sendNext:@1];
+		expect(testObject.integerValue).to.equal(@1);
+
+		testObject.catchSetNilValueForKey = YES;
+
+		__block BOOL setNilValueForKeyInvoked = NO;
+		[[testObject rac_signalForSelector:@selector(setNilValueForKey:)] subscribeNext:^(NSString *key) {
+			setNilValueForKeyInvoked = YES;
+		}];
+
+		[subject sendNext:nil];
+		expect(testObject.integerValue).to.equal(@1);
+		expect(setNilValueForKeyInvoked).to.beTruthy();
+	});
+
+	it(@"should retain intermediate signals when binding", ^{
+		RACSubject *subject = [RACSubject subject];
+		expect(subject).notTo.beNil();
+
+		__block BOOL deallocd = NO;
+
+		@autoreleasepool {
+			@autoreleasepool {
+				RACSignal *intermediateSignal = [subject map:^(NSNumber *num) {
+					return @(num.integerValue + 1);
+				}];
+
+				expect(intermediateSignal).notTo.beNil();
+
+				[intermediateSignal.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+					deallocd = YES;
+				}]];
+
+				setupBlock(testObject, @keypath(testObject.integerValue), nil, intermediateSignal);
+			}
+
+			// Spin the run loop to account for RAC magic that retains the
+			// signal for a single iteration.
+			[NSRunLoop.mainRunLoop runMode:NSDefaultRunLoopMode beforeDate:[NSDate date]];
+		}
+
+		expect(deallocd).to.beFalsy();
+
+		[subject sendNext:@5];
+		expect(testObject.integerValue).to.equal(6);
+
+		[subject sendNext:@6];
+		expect(testObject.integerValue).to.equal(7);
+
+		expect(deallocd).to.beFalsy();
+		[subject sendCompleted];
+
+		// Can't test deallocd again, because it's legal for the chain to be
+		// retained until the object or the original signal is destroyed.
+	});
+});
+
+SharedExampleGroupsEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACSchedulerSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSchedulerSpec.m
new file mode 100644
index 0000000..738eff8
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSchedulerSpec.m
@@ -0,0 +1,424 @@
+//
+//  RACSchedulerSpec.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 11/29/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACScheduler.h"
+#import "RACScheduler+Private.h"
+#import "RACQueueScheduler+Subclass.h"
+#import "RACDisposable.h"
+#import "EXTScope.h"
+#import "RACTestExampleScheduler.h"
+#import <libkern/OSAtomic.h>
+
+// This shouldn't be used directly. Use the `expectCurrentSchedulers` block
+// below instead.
+static void expectCurrentSchedulersInner(NSArray *schedulers, NSMutableArray *currentSchedulerArray) {
+	if (schedulers.count > 0) {
+		RACScheduler *topScheduler = schedulers[0];
+		[topScheduler schedule:^{
+			RACScheduler *currentScheduler = RACScheduler.currentScheduler;
+			if (currentScheduler != nil) [currentSchedulerArray addObject:currentScheduler];
+			expectCurrentSchedulersInner([schedulers subarrayWithRange:NSMakeRange(1, schedulers.count - 1)], currentSchedulerArray);
+		}];
+	}
+}
+
+SpecBegin(RACScheduler)
+
+it(@"should know its current scheduler", ^{
+	// Recursively schedules a block in each of the given schedulers and records
+	// the +currentScheduler at each step. It then expects the array of
+	// +currentSchedulers and the expected array to be equal.
+	//
+	// schedulers                - The array of schedulers to recursively schedule.
+	// expectedCurrentSchedulers - The array of +currentSchedulers to expect.
+	void (^expectCurrentSchedulers)(NSArray *, NSArray *) = ^(NSArray *schedulers, NSArray *expectedCurrentSchedulers) {
+		NSMutableArray *currentSchedulerArray = [NSMutableArray array];
+		expectCurrentSchedulersInner(schedulers, currentSchedulerArray);
+		expect(currentSchedulerArray).will.equal(expectedCurrentSchedulers);
+	};
+
+	RACScheduler *backgroundScheduler = [RACScheduler scheduler];
+
+	expectCurrentSchedulers(@[ backgroundScheduler, RACScheduler.immediateScheduler ], @[ backgroundScheduler, backgroundScheduler ]);
+	expectCurrentSchedulers(@[ backgroundScheduler, RACScheduler.subscriptionScheduler ], @[ backgroundScheduler, backgroundScheduler ]);
+
+	NSArray *mainThreadJumper = @[ RACScheduler.mainThreadScheduler, backgroundScheduler, RACScheduler.mainThreadScheduler ];
+	expectCurrentSchedulers(mainThreadJumper, mainThreadJumper);
+
+	NSArray *backgroundJumper = @[ backgroundScheduler, RACScheduler.mainThreadScheduler, backgroundScheduler ];
+	expectCurrentSchedulers(backgroundJumper, backgroundJumper);
+});
+
+describe(@"+mainThreadScheduler", ^{
+	it(@"should cancel scheduled blocks when disposed", ^{
+		__block BOOL firstBlockRan = NO;
+		__block BOOL secondBlockRan = NO;
+
+		RACDisposable *disposable = [RACScheduler.mainThreadScheduler schedule:^{
+			firstBlockRan = YES;
+		}];
+
+		expect(disposable).notTo.beNil();
+
+		[RACScheduler.mainThreadScheduler schedule:^{
+			secondBlockRan = YES;
+		}];
+
+		[disposable dispose];
+
+		expect(secondBlockRan).to.beFalsy();
+		expect(secondBlockRan).will.beTruthy();
+		expect(firstBlockRan).to.beFalsy();
+	});
+
+	it(@"should schedule future blocks", ^{
+		__block BOOL done = NO;
+
+		[RACScheduler.mainThreadScheduler after:[NSDate date] schedule:^{
+			done = YES;
+		}];
+
+		expect(done).to.beFalsy();
+		expect(done).will.beTruthy();
+	});
+
+	it(@"should cancel future blocks when disposed", ^{
+		__block BOOL firstBlockRan = NO;
+		__block BOOL secondBlockRan = NO;
+
+		RACDisposable *disposable = [RACScheduler.mainThreadScheduler after:[NSDate date] schedule:^{
+			firstBlockRan = YES;
+		}];
+
+		expect(disposable).notTo.beNil();
+
+		[RACScheduler.mainThreadScheduler after:[NSDate date] schedule:^{
+			secondBlockRan = YES;
+		}];
+
+		[disposable dispose];
+
+		expect(secondBlockRan).to.beFalsy();
+		expect(secondBlockRan).will.beTruthy();
+		expect(firstBlockRan).to.beFalsy();
+	});
+
+	it(@"should schedule recurring blocks", ^{
+		__block NSUInteger count = 0;
+
+		RACDisposable *disposable = [RACScheduler.mainThreadScheduler after:[NSDate date] repeatingEvery:0.05 withLeeway:0 schedule:^{
+			count++;
+		}];
+
+		expect(count).to.equal(0);
+		expect(count).will.equal(1);
+		expect(count).will.equal(2);
+		expect(count).will.equal(3);
+
+		[disposable dispose];
+		[NSRunLoop.mainRunLoop runUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.1]];
+
+		expect(count).to.equal(3);
+	});
+});
+
+describe(@"+scheduler", ^{
+	__block RACScheduler *scheduler;
+	__block NSDate * (^futureDate)(void);
+
+	beforeEach(^{
+		scheduler = [RACScheduler scheduler];
+
+		futureDate = ^{
+			return [NSDate dateWithTimeIntervalSinceNow:0.01];
+		};
+	});
+
+	it(@"should cancel scheduled blocks when disposed", ^{
+		__block BOOL firstBlockRan = NO;
+		__block BOOL secondBlockRan = NO;
+
+		// Start off on the scheduler so the enqueued blocks won't run until we
+		// return.
+		[scheduler schedule:^{
+			RACDisposable *disposable = [scheduler schedule:^{
+				firstBlockRan = YES;
+			}];
+
+			expect(disposable).notTo.beNil();
+
+			[scheduler schedule:^{
+				secondBlockRan = YES;
+			}];
+
+			[disposable dispose];
+		}];
+
+		expect(secondBlockRan).will.beTruthy();
+		expect(firstBlockRan).to.beFalsy();
+	});
+
+	it(@"should schedule future blocks", ^{
+		__block BOOL done = NO;
+
+		[scheduler after:futureDate() schedule:^{
+			done = YES;
+		}];
+
+		expect(done).to.beFalsy();
+		expect(done).will.beTruthy();
+	});
+
+	it(@"should cancel future blocks when disposed", ^{
+		__block BOOL firstBlockRan = NO;
+		__block BOOL secondBlockRan = NO;
+
+		NSDate *date = futureDate();
+		RACDisposable *disposable = [scheduler after:date schedule:^{
+			firstBlockRan = YES;
+		}];
+
+		expect(disposable).notTo.beNil();
+		[disposable dispose];
+
+		[scheduler after:date schedule:^{
+			secondBlockRan = YES;
+		}];
+
+		expect(secondBlockRan).to.beFalsy();
+		expect(secondBlockRan).will.beTruthy();
+		expect(firstBlockRan).to.beFalsy();
+	});
+
+	it(@"should schedule recurring blocks", ^{
+		__block NSUInteger count = 0;
+
+		RACDisposable *disposable = [scheduler after:[NSDate date] repeatingEvery:0.05 withLeeway:0 schedule:^{
+			count++;
+		}];
+
+		expect(count).to.equal(0);
+		expect(count).will.equal(1);
+		expect(count).will.equal(2);
+		expect(count).will.equal(3);
+
+		[disposable dispose];
+		[NSThread sleepForTimeInterval:0.1];
+
+		expect(count).to.equal(3);
+	});
+});
+
+describe(@"+subscriptionScheduler", ^{
+	describe(@"setting +currentScheduler", ^{
+		__block RACScheduler *currentScheduler;
+
+		beforeEach(^{
+			currentScheduler = nil;
+		});
+
+		it(@"should be the +mainThreadScheduler when scheduled from the main queue", ^{
+			dispatch_async(dispatch_get_main_queue(), ^{
+				[RACScheduler.subscriptionScheduler schedule:^{
+					currentScheduler = RACScheduler.currentScheduler;
+				}];
+			});
+
+			expect(currentScheduler).will.equal(RACScheduler.mainThreadScheduler);
+		});
+
+		it(@"should be a +scheduler when scheduled from an unknown queue", ^{
+			dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+				[RACScheduler.subscriptionScheduler schedule:^{
+					currentScheduler = RACScheduler.currentScheduler;
+				}];
+			});
+
+			expect(currentScheduler).willNot.beNil();
+			expect(currentScheduler).notTo.equal(RACScheduler.mainThreadScheduler);
+		});
+
+		it(@"should equal the background scheduler from which the block was scheduled", ^{
+			RACScheduler *backgroundScheduler = [RACScheduler scheduler];
+			[backgroundScheduler schedule:^{
+				[RACScheduler.subscriptionScheduler schedule:^{
+					currentScheduler = RACScheduler.currentScheduler;
+				}];
+			}];
+
+			expect(currentScheduler).will.equal(backgroundScheduler);
+		});
+	});
+
+	it(@"should execute scheduled blocks immediately if it's in a scheduler already", ^{
+		__block BOOL done = NO;
+		__block BOOL executedImmediately = NO;
+
+		[[RACScheduler scheduler] schedule:^{
+			[RACScheduler.subscriptionScheduler schedule:^{
+				executedImmediately = YES;
+			}];
+
+			done = YES;
+		}];
+
+		expect(done).will.beTruthy();
+		expect(executedImmediately).to.beTruthy();
+	});
+});
+
+describe(@"+immediateScheduler", ^{
+	it(@"should immediately execute scheduled blocks", ^{
+		__block BOOL executed = NO;
+		RACDisposable *disposable = [RACScheduler.immediateScheduler schedule:^{
+			executed = YES;
+		}];
+
+		expect(disposable).to.beNil();
+		expect(executed).to.beTruthy();
+	});
+
+	it(@"should block for future scheduled blocks", ^{
+		__block BOOL executed = NO;
+		RACDisposable *disposable = [RACScheduler.immediateScheduler after:[NSDate dateWithTimeIntervalSinceNow:0.01] schedule:^{
+			executed = YES;
+		}];
+
+		expect(executed).to.beTruthy();
+		expect(disposable).to.beNil();
+	});
+});
+
+describe(@"-scheduleRecursiveBlock:", ^{
+	describe(@"with a synchronous scheduler", ^{
+		it(@"should behave like a normal block when it doesn't invoke itself", ^{
+			__block BOOL executed = NO;
+			[RACScheduler.immediateScheduler scheduleRecursiveBlock:^(void (^recurse)(void)) {
+				expect(executed).to.beFalsy();
+				executed = YES;
+			}];
+
+			expect(executed).to.beTruthy();
+		});
+
+		it(@"should reschedule itself after the caller completes", ^{
+			__block NSUInteger count = 0;
+			[RACScheduler.immediateScheduler scheduleRecursiveBlock:^(void (^recurse)(void)) {
+				NSUInteger thisCount = ++count;
+				if (thisCount < 3) {
+					recurse();
+
+					// The block shouldn't have been invoked again yet, only
+					// scheduled.
+					expect(count).to.equal(thisCount);
+				}
+			}];
+
+			expect(count).to.equal(3);
+		});
+	});
+
+	describe(@"with an asynchronous scheduler", ^{
+		it(@"should behave like a normal block when it doesn't invoke itself", ^{
+			__block BOOL executed = NO;
+			[RACScheduler.mainThreadScheduler scheduleRecursiveBlock:^(void (^recurse)(void)) {
+				expect(executed).to.beFalsy();
+				executed = YES;
+			}];
+
+			expect(executed).will.beTruthy();
+		});
+
+		it(@"should reschedule itself after the caller completes", ^{
+			__block NSUInteger count = 0;
+			[RACScheduler.mainThreadScheduler scheduleRecursiveBlock:^(void (^recurse)(void)) {
+				NSUInteger thisCount = ++count;
+				if (thisCount < 3) {
+					recurse();
+
+					// The block shouldn't have been invoked again yet, only
+					// scheduled.
+					expect(count).to.equal(thisCount);
+				}
+			}];
+
+			expect(count).will.equal(3);
+		});
+
+		it(@"should reschedule when invoked asynchronously", ^{
+			__block NSUInteger count = 0;
+
+			RACScheduler *asynchronousScheduler = [RACScheduler scheduler];
+			[RACScheduler.immediateScheduler scheduleRecursiveBlock:^(void (^recurse)(void)) {
+				[asynchronousScheduler after:[NSDate dateWithTimeIntervalSinceNow:0.01] schedule:^{
+					NSUInteger thisCount = ++count;
+					if (thisCount < 3) {
+						recurse();
+
+						// The block shouldn't have been invoked again yet, only
+						// scheduled.
+						expect(count).to.equal(thisCount);
+					}
+				}];
+			}];
+
+			expect(count).will.equal(3);
+		});
+
+		it(@"shouldn't reschedule itself when disposed", ^{
+			__block NSUInteger count = 0;
+			__block RACDisposable *disposable = [RACScheduler.mainThreadScheduler scheduleRecursiveBlock:^(void (^recurse)(void)) {
+				++count;
+
+				expect(disposable).notTo.beNil();
+				[disposable dispose];
+
+				recurse();
+			}];
+
+			expect(count).will.equal(1);
+		});
+	});
+});
+
+describe(@"subclassing", ^{
+	__block RACTestExampleScheduler *scheduler;
+
+	beforeEach(^{
+		scheduler = [[RACTestExampleScheduler alloc] initWithQueue:dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)];
+	});
+
+	it(@"should invoke blocks scheduled with -schedule:", ^{
+		__block BOOL invoked = NO;
+		[scheduler schedule:^{
+			invoked = YES;
+		}];
+
+		expect(invoked).will.beTruthy();
+	});
+
+	it(@"should invoke blocks scheduled with -after:schedule:", ^{
+		__block BOOL invoked = NO;
+		[scheduler after:[NSDate dateWithTimeIntervalSinceNow:0.01] schedule:^{
+			invoked = YES;
+		}];
+		
+		expect(invoked).will.beTruthy();
+	});
+
+	it(@"should set a valid current scheduler", ^{
+		__block RACScheduler *currentScheduler;
+		[scheduler schedule:^{
+			currentScheduler = RACScheduler.currentScheduler;
+		}];
+
+		expect(currentScheduler).will.equal(scheduler);
+	});
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACSequenceAdditionsSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSequenceAdditionsSpec.m
new file mode 100644
index 0000000..e5b5834
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSequenceAdditionsSpec.m
@@ -0,0 +1,338 @@
+//
+//  RACSequenceAdditionsSpec.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-11-01.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSequenceExamples.h"
+
+#import "NSArray+RACSequenceAdditions.h"
+#import "NSDictionary+RACSequenceAdditions.h"
+#import "NSOrderedSet+RACSequenceAdditions.h"
+#import "NSSet+RACSequenceAdditions.h"
+#import "NSString+RACSequenceAdditions.h"
+#import "NSIndexSet+RACSequenceAdditions.h"
+#import "RACSequence.h"
+#import "RACTuple.h"
+
+SpecBegin(RACSequenceAdditions)
+
+__block NSArray *numbers;
+
+beforeEach(^{
+	NSMutableArray *mutableNumbers = [NSMutableArray array];
+	for (NSUInteger i = 0; i < 100; i++) {
+		[mutableNumbers addObject:@(i)];
+	}
+
+	numbers = [mutableNumbers copy];
+});
+
+describe(@"NSArray sequences", ^{
+	__block NSMutableArray *values;
+	__block RACSequence *sequence;
+	
+	beforeEach(^{
+		values = [numbers mutableCopy];
+		sequence = values.rac_sequence;
+		expect(sequence).notTo.beNil();
+	});
+
+	itShouldBehaveLike(RACSequenceExamples, ^{
+		return @{
+			RACSequenceExampleSequence: sequence,
+			RACSequenceExampleExpectedValues: values
+		};
+	});
+
+	describe(@"should be immutable", ^{
+		__block NSArray *unchangedValues;
+		
+		beforeEach(^{
+			unchangedValues = [values copy];
+			[values addObject:@6];
+		});
+
+		itShouldBehaveLike(RACSequenceExamples, ^{
+			return @{
+				RACSequenceExampleSequence: sequence,
+				RACSequenceExampleExpectedValues: unchangedValues
+			};
+		});
+	});
+
+	it(@"should fast enumerate after zipping", ^{
+		// This certain list of values causes issues, for some reason.
+		NSArray *values = @[ @0, @0, @0, @0, @0, @0, @0, @0, @0, @0, @0, @0, @0, @0, @0, @0 ];
+		RACSequence *zippedSequence = [RACSequence zip:@[ values.rac_sequence, values.rac_sequence ] reduce:^(id obj1, id obj2) {
+			return obj1;
+		}];
+
+		NSMutableArray *collectedValues = [NSMutableArray array];
+		for (id value in zippedSequence) {
+			[collectedValues addObject:value];
+		}
+
+		expect(collectedValues).to.equal(values);
+	});
+});
+
+describe(@"NSDictionary sequences", ^{
+	__block NSMutableDictionary *dict;
+
+	__block NSMutableArray *tuples;
+	__block RACSequence *tupleSequence;
+
+	__block NSArray *keys;
+	__block RACSequence *keySequence;
+
+	__block NSArray *values;
+	__block RACSequence *valueSequence;
+
+	beforeEach(^{
+		dict = [@{
+			@"foo": @"bar",
+			@"baz": @"buzz",
+			@5: NSNull.null
+		} mutableCopy];
+
+		tuples = [NSMutableArray array];
+		for (id key in dict) {
+			RACTuple *tuple = [RACTuple tupleWithObjects:key, dict[key], nil];
+			[tuples addObject:tuple];
+		}
+
+		tupleSequence = dict.rac_sequence;
+		expect(tupleSequence).notTo.beNil();
+
+		keys = [dict.allKeys copy];
+		keySequence = dict.rac_keySequence;
+		expect(keySequence).notTo.beNil();
+
+		values = [dict.allValues copy];
+		valueSequence = dict.rac_valueSequence;
+		expect(valueSequence).notTo.beNil();
+	});
+
+	itShouldBehaveLike(RACSequenceExamples, ^{
+		return @{
+			RACSequenceExampleSequence: tupleSequence,
+			RACSequenceExampleExpectedValues: tuples
+		};
+	});
+
+	itShouldBehaveLike(RACSequenceExamples, ^{
+		return @{
+			RACSequenceExampleSequence: keySequence,
+			RACSequenceExampleExpectedValues: keys
+		};
+	});
+
+	itShouldBehaveLike(RACSequenceExamples, ^{
+		return @{
+			RACSequenceExampleSequence: valueSequence,
+			RACSequenceExampleExpectedValues: values
+		};
+	});
+
+	describe(@"should be immutable", ^{
+		beforeEach(^{
+			dict[@"foo"] = @"rab";
+			dict[@6] = @7;
+		});
+
+		itShouldBehaveLike(RACSequenceExamples, ^{
+			return @{
+				RACSequenceExampleSequence: tupleSequence,
+				RACSequenceExampleExpectedValues: tuples
+			};
+		});
+
+		itShouldBehaveLike(RACSequenceExamples, ^{
+			return @{
+				RACSequenceExampleSequence: keySequence,
+				RACSequenceExampleExpectedValues: keys
+			};
+		});
+
+		itShouldBehaveLike(RACSequenceExamples, ^{
+			return @{
+				RACSequenceExampleSequence: valueSequence,
+				RACSequenceExampleExpectedValues: values
+			};
+		});
+	});
+});
+
+describe(@"NSOrderedSet sequences", ^{
+	__block NSMutableOrderedSet *values;
+	__block RACSequence *sequence;
+
+	beforeEach(^{
+		values = [NSMutableOrderedSet orderedSetWithArray:numbers];
+		sequence = values.rac_sequence;
+		expect(sequence).notTo.beNil();
+	});
+
+	itShouldBehaveLike(RACSequenceExamples, ^{
+		return @{
+			RACSequenceExampleSequence: sequence,
+			RACSequenceExampleExpectedValues: values.array
+		};
+	});
+
+	describe(@"should be immutable", ^{
+		__block NSArray *unchangedValues;
+		
+		beforeEach(^{
+			unchangedValues = [values.array copy];
+			[values addObject:@6];
+		});
+
+		itShouldBehaveLike(RACSequenceExamples, ^{
+			return @{
+				RACSequenceExampleSequence: sequence,
+				RACSequenceExampleExpectedValues: unchangedValues
+			};
+		});
+	});
+});
+
+describe(@"NSSet sequences", ^{
+	__block NSMutableSet *values;
+	__block RACSequence *sequence;
+
+	beforeEach(^{
+		values = [NSMutableSet setWithArray:numbers];
+		sequence = values.rac_sequence;
+		expect(sequence).notTo.beNil();
+	});
+
+	itShouldBehaveLike(RACSequenceExamples, ^{
+		return @{
+			RACSequenceExampleSequence: sequence,
+			RACSequenceExampleExpectedValues: values.allObjects
+		};
+	});
+
+	describe(@"should be immutable", ^{
+		__block NSArray *unchangedValues;
+		
+		beforeEach(^{
+			unchangedValues = [values.allObjects copy];
+			[values addObject:@6];
+		});
+
+		itShouldBehaveLike(RACSequenceExamples, ^{
+			return @{
+				RACSequenceExampleSequence: sequence,
+				RACSequenceExampleExpectedValues: unchangedValues
+			};
+		});
+	});
+});
+
+describe(@"NSString sequences", ^{
+	__block NSMutableString *string;
+	__block NSArray *values;
+	__block RACSequence *sequence;
+
+	beforeEach(^{
+		string = [@"foobar" mutableCopy];
+		values = @[ @"f", @"o", @"o", @"b", @"a", @"r" ];
+		sequence = string.rac_sequence;
+		expect(sequence).notTo.beNil();
+	});
+
+	itShouldBehaveLike(RACSequenceExamples, ^{
+		return @{
+			RACSequenceExampleSequence: sequence,
+			RACSequenceExampleExpectedValues: values
+		};
+	});
+
+	describe(@"should be immutable", ^{
+		beforeEach(^{
+			[string appendString:@"buzz"];
+		});
+
+		itShouldBehaveLike(RACSequenceExamples, ^{
+			return @{
+				RACSequenceExampleSequence: sequence,
+				RACSequenceExampleExpectedValues: values
+			};
+		});
+	});
+
+	it(@"should work with composed characters", ^{
+		NSString  *string = @"\u2665\uFE0F\u2666\uFE0F";
+		NSArray *expectedSequence = @[ @"\u2665\uFE0F", @"\u2666\uFE0F" ];
+		expect(string.rac_sequence.array).to.equal(expectedSequence);
+	});
+});
+
+describe(@"RACTuple sequences", ^{
+	__block RACTuple *tuple;
+	__block RACSequence *sequence;
+	
+	beforeEach(^{
+		tuple = RACTuplePack(@"foo", nil, @"bar", NSNull.null, RACTupleNil.tupleNil);
+
+		sequence = tuple.rac_sequence;
+		expect(sequence).notTo.beNil();
+	});
+
+	itShouldBehaveLike(RACSequenceExamples, ^{
+		return @{
+			RACSequenceExampleSequence: sequence,
+			RACSequenceExampleExpectedValues: @[ @"foo", NSNull.null, @"bar", NSNull.null, NSNull.null ]
+		};
+	});
+});
+
+describe(@"NSIndexSet sequences", ^{
+	__block NSMutableIndexSet *values;
+	__block RACSequence *sequence;
+	
+	NSArray * (^valuesFromIndexSet)(NSIndexSet *indexSet) =  ^NSArray *(NSIndexSet *indexSet) {
+		NSMutableArray *arr = [NSMutableArray array];
+		[values enumerateIndexesUsingBlock:^(NSUInteger idx, BOOL *stop) {
+			[arr addObject:@(idx)];
+		}];
+
+		return [arr copy];
+	};
+	
+	beforeEach(^{
+		values = [NSMutableIndexSet indexSetWithIndexesInRange:NSMakeRange(0, 10)];
+		sequence = values.rac_sequence;
+		expect(sequence).notTo.beNil();
+	});
+	
+	itShouldBehaveLike(RACSequenceExamples, ^{
+		return @{
+			RACSequenceExampleSequence: sequence,
+			RACSequenceExampleExpectedValues: valuesFromIndexSet(values)
+		};
+	});
+	
+	describe(@"should be immutable", ^{
+		__block NSArray *unchangedValues;
+		
+		beforeEach(^{
+			unchangedValues = valuesFromIndexSet(values);
+			[values addIndex:20];
+		});
+		
+		itShouldBehaveLike(RACSequenceExamples, ^{
+			return @{
+				RACSequenceExampleSequence: sequence,
+				RACSequenceExampleExpectedValues: unchangedValues
+			};
+		});
+	});
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACSequenceExamples.h b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSequenceExamples.h
new file mode 100644
index 0000000..922b056
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSequenceExamples.h
@@ -0,0 +1,16 @@
+//
+//  RACSequenceExamples.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-11-01.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+// The name of the shared examples for RACSequence instances.
+extern NSString * const RACSequenceExamples;
+
+// RACSequence *
+extern NSString * const RACSequenceExampleSequence;
+
+// NSArray *
+extern NSString * const RACSequenceExampleExpectedValues;
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACSequenceExamples.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSequenceExamples.m
new file mode 100644
index 0000000..5ca3923
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSequenceExamples.m
@@ -0,0 +1,125 @@
+//
+//  RACSequenceExamples.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-11-01.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSequenceExamples.h"
+
+#import "RACScheduler.h"
+#import "RACSequence.h"
+#import "RACSignal+Operations.h"
+
+NSString * const RACSequenceExamples = @"RACSequenceExamples";
+NSString * const RACSequenceExampleSequence = @"RACSequenceExampleSequence";
+NSString * const RACSequenceExampleExpectedValues = @"RACSequenceExampleExpectedValues";
+
+SharedExampleGroupsBegin(RACSequenceExamples);
+
+sharedExamplesFor(RACSequenceExamples, ^(NSDictionary *data) {
+	__block RACSequence *sequence;
+	__block NSArray *values;
+	
+	beforeEach(^{
+		sequence = data[RACSequenceExampleSequence];
+		values = [data[RACSequenceExampleExpectedValues] copy];
+	});
+
+	it(@"should implement <NSFastEnumeration>", ^{
+		NSMutableArray *collectedValues = [NSMutableArray array];
+		for (id value in sequence) {
+			[collectedValues addObject:value];
+		}
+
+		expect(collectedValues).to.equal(values);
+	});
+
+	it(@"should return an array", ^{
+		expect(sequence.array).to.equal(values);
+	});
+
+	describe(@"-signalWithScheduler:", ^{
+		it(@"should return an immediately scheduled signal", ^{
+			RACSignal *signal = [sequence signalWithScheduler:RACScheduler.immediateScheduler];
+			expect(signal.toArray).to.equal(values);
+		});
+
+		it(@"should return a background scheduled signal", ^{
+			RACSignal *signal = [sequence signalWithScheduler:[RACScheduler scheduler]];
+			expect(signal.toArray).to.equal(values);
+		});
+
+		it(@"should only evaluate one value per scheduling", ^{
+			RACSignal *signal = [sequence signalWithScheduler:RACScheduler.mainThreadScheduler];
+
+			__block BOOL flag = YES;
+			__block BOOL completed = NO;
+			[signal subscribeNext:^(id x) {
+				expect(flag).to.beTruthy();
+				flag = NO;
+
+				[RACScheduler.mainThreadScheduler schedule:^{
+					// This should get executed before the next value (which
+					// verifies that it's YES).
+					flag = YES;
+				}];
+			} completed:^{
+				completed = YES;
+			}];
+
+			expect(completed).will.beTruthy();
+		});
+	});
+
+	it(@"should be equal to itself", ^{
+		expect(sequence).to.equal(sequence);
+	});
+
+	it(@"should be equal to the same sequence of values", ^{
+		RACSequence *newSequence = RACSequence.empty;
+		for (id value in values) {
+			RACSequence *valueSeq = [RACSequence return:value];
+			expect(valueSeq).notTo.beNil();
+
+			newSequence = [newSequence concat:valueSeq];
+		}
+		
+		expect(sequence).to.equal(newSequence);
+		expect(sequence.hash).to.equal(newSequence.hash);
+	});
+
+	it(@"should not be equal to a different sequence of values", ^{
+		RACSequence *anotherSequence = [RACSequence return:@(-1)];
+		expect(sequence).notTo.equal(anotherSequence);
+	});
+
+	it(@"should return an identical object for -copy", ^{
+		expect([sequence copy]).to.beIdenticalTo(sequence);
+	});
+
+	it(@"should archive", ^{
+		NSData *data = [NSKeyedArchiver archivedDataWithRootObject:sequence];
+		expect(data).notTo.beNil();
+
+		RACSequence *unarchived = [NSKeyedUnarchiver unarchiveObjectWithData:data];
+		expect(unarchived).to.equal(sequence);
+	});
+	
+	it(@"should fold right", ^{
+		RACSequence *result = [sequence foldRightWithStart:[RACSequence empty] reduce:^(id first, RACSequence *rest) {
+			return [rest.head startWith:first];
+		}];
+		expect(result.array).to.equal(values);
+	});
+	
+	it(@"should fold left", ^{
+		RACSequence *result = [sequence foldLeftWithStart:[RACSequence empty] reduce:^(RACSequence *first, id rest) {
+			return [first concat:[RACSequence return:rest]];
+		}];
+		expect(result.array).to.equal(values);
+	});
+});
+
+SharedExampleGroupsEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACSequenceSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSequenceSpec.m
new file mode 100644
index 0000000..3bf7dca
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSequenceSpec.m
@@ -0,0 +1,443 @@
+//
+//  RACSequenceSpec.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-11-01.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSequenceExamples.h"
+#import "RACStreamExamples.h"
+
+#import "NSArray+RACSequenceAdditions.h"
+#import "NSObject+RACDeallocating.h"
+#import "NSObject+RACPropertySubscribing.h"
+#import "RACCompoundDisposable.h"
+#import "RACDisposable.h"
+#import "RACSequence.h"
+#import "RACUnit.h"
+
+SpecBegin(RACSequence)
+
+describe(@"RACStream", ^{
+	id verifyValues = ^(RACSequence *sequence, NSArray *expectedValues) {
+		NSMutableArray *collectedValues = [NSMutableArray array];
+		while (sequence.head != nil) {
+			[collectedValues addObject:sequence.head];
+			sequence = sequence.tail;
+		}
+
+		expect(collectedValues).to.equal(expectedValues);
+	};
+
+	__block RACSequence *infiniteSequence = [RACSequence sequenceWithHeadBlock:^{
+		return RACUnit.defaultUnit;
+	} tailBlock:^{
+		return infiniteSequence;
+	}];
+
+	itShouldBehaveLike(RACStreamExamples, ^{
+		return @{
+			RACStreamExamplesClass: RACSequence.class,
+			RACStreamExamplesVerifyValuesBlock: verifyValues,
+			RACStreamExamplesInfiniteStream: infiniteSequence
+		};
+	});
+});
+
+describe(@"+sequenceWithHeadBlock:tailBlock:", ^{
+	__block RACSequence *sequence;
+	__block BOOL headInvoked;
+	__block BOOL tailInvoked;
+
+	before(^{
+		headInvoked = NO;
+		tailInvoked = NO;
+
+		sequence = [RACSequence sequenceWithHeadBlock:^{
+			headInvoked = YES;
+			return @0;
+		} tailBlock:^{
+			tailInvoked = YES;
+			return [RACSequence return:@1];
+		}];
+
+		expect(sequence).notTo.beNil();
+	});
+
+	it(@"should use the values from the head and tail blocks", ^{
+		expect(sequence.head).to.equal(@0);
+		expect(sequence.tail.head).to.equal(@1);
+		expect(sequence.tail.tail).to.beNil();
+	});
+
+	it(@"should lazily invoke head and tail blocks", ^{
+		expect(headInvoked).to.beFalsy();
+		expect(tailInvoked).to.beFalsy();
+
+		expect(sequence.head).to.equal(@0);
+		expect(headInvoked).to.beTruthy();
+		expect(tailInvoked).to.beFalsy();
+
+		expect(sequence.tail).notTo.beNil();
+		expect(tailInvoked).to.beTruthy();
+	});
+
+	after(^{
+		itShouldBehaveLike(RACSequenceExamples, ^{
+			return @{
+				RACSequenceExampleSequence: sequence,
+				RACSequenceExampleExpectedValues: @[ @0, @1 ]
+			};
+		});
+	});
+});
+
+describe(@"empty sequences", ^{
+	itShouldBehaveLike(RACSequenceExamples, ^{
+		return @{
+			RACSequenceExampleSequence: [RACSequence empty],
+			RACSequenceExampleExpectedValues: @[]
+		};
+	});
+});
+
+describe(@"non-empty sequences", ^{
+	itShouldBehaveLike(RACSequenceExamples, ^{
+		return @{
+			RACSequenceExampleSequence: [[[RACSequence return:@0] concat:[RACSequence return:@1]] concat:[RACSequence return:@2]],
+			RACSequenceExampleExpectedValues: @[ @0, @1, @2 ]
+		};
+	});
+});
+
+describe(@"eager sequences", ^{
+	__block RACSequence *lazySequence;
+	__block BOOL headInvoked;
+	__block BOOL tailInvoked;
+
+	NSArray *values = @[ @0, @1 ];
+	
+	before(^{
+		headInvoked = NO;
+		tailInvoked = NO;
+		
+		lazySequence = [RACSequence sequenceWithHeadBlock:^{
+			headInvoked = YES;
+			return @0;
+		} tailBlock:^{
+			tailInvoked = YES;
+			return [RACSequence return:@1];
+		}];
+		
+		expect(lazySequence).notTo.beNil();
+	});
+	
+	itShouldBehaveLike(RACSequenceExamples, ^{
+		return @{
+			RACSequenceExampleSequence: lazySequence.eagerSequence,
+			RACSequenceExampleExpectedValues: values
+		};
+	});
+	
+	it(@"should evaluate all values immediately", ^{
+		RACSequence *eagerSequence = lazySequence.eagerSequence;
+		expect(headInvoked).to.beTruthy();
+		expect(tailInvoked).to.beTruthy();
+		expect(eagerSequence.array).to.equal(values);
+	});
+});
+
+describe(@"-take:", ^{
+	it(@"should complete take: without needing the head of the second item in the sequence", ^{
+		__block NSUInteger valuesTaken = 0;
+
+		__block RACSequence *sequence = [RACSequence sequenceWithHeadBlock:^{
+			++valuesTaken;
+			return RACUnit.defaultUnit;
+		} tailBlock:^{
+			return sequence;
+		}];
+
+		NSArray *values = [sequence take:1].array;
+		expect(values).to.equal(@[ RACUnit.defaultUnit ]);
+		expect(valuesTaken).to.equal(1);
+	});
+});
+
+describe(@"-bind:", ^{
+	it(@"should only evaluate head when the resulting sequence is evaluated", ^{
+		__block BOOL headInvoked = NO;
+
+		RACSequence *original = [RACSequence sequenceWithHeadBlock:^{
+			headInvoked = YES;
+			return RACUnit.defaultUnit;
+		} tailBlock:^ id {
+			return nil;
+		}];
+
+		RACSequence *bound = [original bind:^{
+			return ^(id value, BOOL *stop) {
+				return [RACSequence return:value];
+			};
+		}];
+
+		expect(bound).notTo.beNil();
+		expect(headInvoked).to.beFalsy();
+
+		expect(bound.head).to.equal(RACUnit.defaultUnit);
+		expect(headInvoked).to.beTruthy();
+	});
+});
+
+describe(@"-objectEnumerator", ^{
+	it(@"should only evaluate head as it's enumerated", ^{
+		__block BOOL firstHeadInvoked = NO;
+		__block BOOL secondHeadInvoked = NO;
+		__block BOOL thirdHeadInvoked = NO;
+		
+		RACSequence *sequence = [RACSequence sequenceWithHeadBlock:^id{
+			firstHeadInvoked = YES;
+			return @1;
+		} tailBlock:^RACSequence *{
+			return [RACSequence sequenceWithHeadBlock:^id{
+				secondHeadInvoked = YES;
+				return @2;
+			} tailBlock:^RACSequence *{
+				return [RACSequence sequenceWithHeadBlock:^id{
+					thirdHeadInvoked = YES;
+					return @3;
+				} tailBlock:^RACSequence *{
+					return RACSequence.empty;
+				}];
+			}];
+		}];
+		NSEnumerator *enumerator = sequence.objectEnumerator;
+		
+		expect(firstHeadInvoked).to.beFalsy();
+		expect(secondHeadInvoked).to.beFalsy();
+		expect(thirdHeadInvoked).to.beFalsy();
+		
+		expect([enumerator nextObject]).to.equal(@1);
+		
+		expect(firstHeadInvoked).to.beTruthy();
+		expect(secondHeadInvoked).to.beFalsy();
+		expect(thirdHeadInvoked).to.beFalsy();
+		
+		expect([enumerator nextObject]).to.equal(@2);
+		
+		expect(secondHeadInvoked).to.beTruthy();
+		expect(thirdHeadInvoked).to.beFalsy();
+		
+		expect([enumerator nextObject]).to.equal(@3);
+		
+		expect(thirdHeadInvoked).to.beTruthy();
+		
+		expect([enumerator nextObject]).to.beNil();
+	});
+	
+	it(@"should let the sequence dealloc as it's enumerated", ^{
+		__block BOOL firstSequenceDeallocd = NO;
+		__block BOOL secondSequenceDeallocd = NO;
+		__block BOOL thirdSequenceDeallocd = NO;
+		
+		NSEnumerator *enumerator = nil;
+		
+		@autoreleasepool {
+			RACSequence *thirdSequence __attribute__((objc_precise_lifetime)) = [RACSequence sequenceWithHeadBlock:^id{
+				return @3;
+			} tailBlock:^RACSequence *{
+				return RACSequence.empty;
+			}];
+			[thirdSequence.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				thirdSequenceDeallocd = YES;
+			}]];
+			
+			RACSequence *secondSequence __attribute__((objc_precise_lifetime)) = [RACSequence sequenceWithHeadBlock:^id{
+				return @2;
+			} tailBlock:^RACSequence *{
+				return thirdSequence;
+			}];
+			[secondSequence.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				secondSequenceDeallocd = YES;
+			}]];
+			
+			RACSequence *firstSequence __attribute__((objc_precise_lifetime)) = [RACSequence sequenceWithHeadBlock:^id{
+				return @1;
+			} tailBlock:^RACSequence *{
+				return secondSequence;
+			}];
+			[firstSequence.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				firstSequenceDeallocd = YES;
+			}]];
+			
+			enumerator = firstSequence.objectEnumerator;
+		}
+		
+		@autoreleasepool {
+			expect([enumerator nextObject]).to.equal(@1);
+		}
+
+		@autoreleasepool {
+			expect([enumerator nextObject]).to.equal(@2);
+		}
+		expect(firstSequenceDeallocd).will.beTruthy();
+		
+		@autoreleasepool {
+			expect([enumerator nextObject]).to.equal(@3);
+		}
+		expect(secondSequenceDeallocd).will.beTruthy();
+		
+		@autoreleasepool {
+			expect([enumerator nextObject]).to.beNil();
+		}
+		expect(thirdSequenceDeallocd).will.beTruthy();
+	});
+});
+
+it(@"shouldn't overflow the stack when deallocated on a background queue", ^{
+	NSUInteger length = 10000;
+	NSMutableArray *values = [NSMutableArray arrayWithCapacity:length];
+	for (NSUInteger i = 0; i < length; ++i) {
+		[values addObject:@(i)];
+	}
+
+	__block BOOL finished = NO;
+	dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+		@autoreleasepool {
+			[[values.rac_sequence map:^(id value) {
+				return value;
+			}] array];
+		}
+
+		finished = YES;
+	});
+
+	NSTimeInterval oldTimeout = Expecta.asynchronousTestTimeout;
+	Expecta.asynchronousTestTimeout = DBL_MAX;
+	expect(finished).will.beTruthy();
+	Expecta.asynchronousTestTimeout = oldTimeout;
+});
+
+describe(@"-foldLeftWithStart:reduce:", ^{
+	it(@"should reduce with start first", ^{
+		RACSequence *sequence = [[[RACSequence return:@0] concat:[RACSequence return:@1]] concat:[RACSequence return:@2]];
+		NSNumber *result = [sequence foldLeftWithStart:@3 reduce:^(NSNumber *first, NSNumber *rest) {
+			return first;
+		}];
+		expect(result).to.equal(@3);
+	});
+
+	it(@"should be left associative", ^{
+		RACSequence *sequence = [[[RACSequence return:@1] concat:[RACSequence return:@2]] concat:[RACSequence return:@3]];
+		NSNumber *result = [sequence foldLeftWithStart:@0 reduce:^(NSNumber *first, NSNumber *rest) {
+			int difference = first.intValue - rest.intValue;
+			return @(difference);
+		}];
+		expect(result).to.equal(@-6);
+	});
+});
+
+describe(@"-foldRightWithStart:reduce:", ^{
+	it(@"should be lazy", ^{
+		__block BOOL headInvoked = NO;
+		__block BOOL tailInvoked = NO;
+		RACSequence *sequence = [RACSequence sequenceWithHeadBlock:^{
+			headInvoked = YES;
+			return @0;
+		} tailBlock:^{
+			tailInvoked = YES;
+			return [RACSequence return:@1];
+		}];
+		
+		NSNumber *result = [sequence foldRightWithStart:@2 reduce:^(NSNumber *first, RACSequence *rest) {
+			return first;
+		}];
+		
+		expect(result).to.equal(@0);
+		expect(headInvoked).to.beTruthy();
+		expect(tailInvoked).to.beFalsy();
+	});
+	
+	it(@"should reduce with start last", ^{
+		RACSequence *sequence = [[[RACSequence return:@0] concat:[RACSequence return:@1]] concat:[RACSequence return:@2]];
+		NSNumber *result = [sequence foldRightWithStart:@3 reduce:^(NSNumber *first, RACSequence *rest) {
+			return rest.head;
+		}];
+		expect(result).to.equal(@3);
+	});
+	
+	it(@"should be right associative", ^{
+		RACSequence *sequence = [[[RACSequence return:@1] concat:[RACSequence return:@2]] concat:[RACSequence return:@3]];
+		NSNumber *result = [sequence foldRightWithStart:@0 reduce:^(NSNumber *first, RACSequence *rest) {
+			int difference = first.intValue - [rest.head intValue];
+			return @(difference);
+		}];
+		expect(result).to.equal(@2);
+	});
+});
+
+describe(@"-any", ^{
+	__block RACSequence *sequence;
+	beforeEach(^{
+		sequence = [[[RACSequence return:@0] concat:[RACSequence return:@1]] concat:[RACSequence return:@2]];
+	});
+	
+	it(@"should return true when at least one exists", ^{
+		BOOL result = [sequence any:^ BOOL (NSNumber *value) {
+			return value.integerValue > 0;
+		}];
+		expect(result).to.beTruthy();
+	});
+	
+	it(@"should return false when no such thing exists", ^{
+		BOOL result = [sequence any:^ BOOL (NSNumber *value) {
+			return value.integerValue == 3;
+		}];
+		expect(result).to.beFalsy();
+	});
+});
+
+describe(@"-all", ^{
+	__block RACSequence *sequence;
+	beforeEach(^{
+		sequence = [[[RACSequence return:@0] concat:[RACSequence return:@1]] concat:[RACSequence return:@2]];
+	});
+	
+	it(@"should return true when all values pass", ^{
+		BOOL result = [sequence all:^ BOOL (NSNumber *value) {
+			return value.integerValue >= 0;
+		}];
+		expect(result).to.beTruthy();
+	});
+	
+	it(@"should return false when at least one value fails", ^{
+		BOOL result = [sequence all:^ BOOL (NSNumber *value) {
+			return value.integerValue < 2;
+		}];
+		expect(result).to.beFalsy();
+	});
+});
+
+describe(@"-objectPassingTest:", ^{
+	__block RACSequence *sequence;
+	beforeEach(^{
+		sequence = [[[RACSequence return:@0] concat:[RACSequence return:@1]] concat:[RACSequence return:@2]];
+	});
+	
+	it(@"should return leftmost object that passes the test", ^{
+		NSNumber *result = [sequence objectPassingTest:^ BOOL (NSNumber *value) {
+			return value.intValue > 0;
+		}];
+		expect(result).to.equal(@1);
+	});
+	
+	it(@"should return nil if no objects pass the test", ^{
+		NSNumber *result = [sequence objectPassingTest:^ BOOL (NSNumber *value) {
+			return value.intValue < 0;
+		}];
+		expect(result).to.beNil();
+	});
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACSerialDisposableSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSerialDisposableSpec.m
new file mode 100644
index 0000000..cdf35f5
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSerialDisposableSpec.m
@@ -0,0 +1,137 @@
+//
+//  RACSerialDisposableSpec.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-07-22.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSerialDisposable.h"
+
+SpecBegin(RACSerialDisposable)
+
+it(@"should initialize with -init", ^{
+	RACSerialDisposable *serial = [[RACSerialDisposable alloc] init];
+	expect(serial).notTo.beNil();
+	expect(serial.disposable).to.beNil();
+});
+
+it(@"should initialize an inner disposable with -initWithBlock:", ^{
+	__block BOOL disposed = NO;
+	RACSerialDisposable *serial = [RACSerialDisposable disposableWithBlock:^{
+		disposed = YES;
+	}];
+
+	expect(serial).notTo.beNil();
+	expect(serial.disposable).notTo.beNil();
+
+	[serial.disposable dispose];
+	expect(serial.disposed).to.beFalsy();
+	expect(disposed).to.beTruthy();
+});
+
+it(@"should initialize with a disposable", ^{
+	RACDisposable *inner = [[RACDisposable alloc] init];
+	RACSerialDisposable *serial = [RACSerialDisposable serialDisposableWithDisposable:inner];
+	expect(serial).notTo.beNil();
+	expect(serial.disposable).to.equal(inner);
+});
+
+it(@"should dispose of the inner disposable", ^{
+	__block BOOL disposed = NO;
+	RACDisposable *inner = [RACDisposable disposableWithBlock:^{
+		disposed = YES;
+	}];
+
+	RACSerialDisposable *serial = [RACSerialDisposable serialDisposableWithDisposable:inner];
+	expect(serial.disposed).to.beFalsy();
+	expect(disposed).to.beFalsy();
+
+	[serial dispose];
+	expect(serial.disposed).to.beTruthy();
+	expect(serial.disposable).to.beNil();
+	expect(disposed).to.beTruthy();
+});
+
+it(@"should dispose of a new inner disposable if it's already been disposed", ^{
+	__block BOOL disposed = NO;
+	RACDisposable *inner = [RACDisposable disposableWithBlock:^{
+		disposed = YES;
+	}];
+
+	RACSerialDisposable *serial = [[RACSerialDisposable alloc] init];
+	expect(serial.disposed).to.beFalsy();
+
+	[serial dispose];
+	expect(serial.disposed).to.beTruthy();
+	expect(disposed).to.beFalsy();
+
+	serial.disposable = inner;
+	expect(disposed).to.beTruthy();
+	expect(serial.disposable).to.beNil();
+});
+
+it(@"should allow the inner disposable to be set to nil", ^{
+	__block BOOL disposed = NO;
+	RACDisposable *inner = [RACDisposable disposableWithBlock:^{
+		disposed = YES;
+	}];
+
+	RACSerialDisposable *serial = [RACSerialDisposable serialDisposableWithDisposable:inner];
+	expect(disposed).to.beFalsy();
+
+	serial.disposable = nil;
+	expect(serial.disposable).to.beNil();
+
+	serial.disposable = inner;
+	expect(serial.disposable).to.equal(inner);
+
+	[serial dispose];
+	expect(disposed).to.beTruthy();
+	expect(serial.disposable).to.beNil();
+});
+
+it(@"should swap inner disposables", ^{
+	__block BOOL firstDisposed = NO;
+	RACDisposable *first = [RACDisposable disposableWithBlock:^{
+		firstDisposed = YES;
+	}];
+
+	__block BOOL secondDisposed = NO;
+	RACDisposable *second = [RACDisposable disposableWithBlock:^{
+		secondDisposed = YES;
+	}];
+
+	RACSerialDisposable *serial = [RACSerialDisposable serialDisposableWithDisposable:first];
+	expect([serial swapInDisposable:second]).to.equal(first);
+
+	expect(serial.disposed).to.beFalsy();
+	expect(firstDisposed).to.beFalsy();
+	expect(secondDisposed).to.beFalsy();
+	
+	[serial dispose];
+	expect(serial.disposed).to.beTruthy();
+	expect(serial.disposable).to.beNil();
+
+	expect(firstDisposed).to.beFalsy();
+	expect(secondDisposed).to.beTruthy();
+});
+
+it(@"should release the inner disposable upon deallocation", ^{
+	__weak RACDisposable *weakInnerDisposable;
+	__weak RACSerialDisposable *weakSerialDisposable;
+
+	@autoreleasepool {
+		RACDisposable *innerDisposable __attribute__((objc_precise_lifetime)) = [[RACDisposable alloc] init];
+		weakInnerDisposable = innerDisposable;
+
+		RACSerialDisposable *serialDisposable __attribute__((objc_precise_lifetime)) = [[RACSerialDisposable alloc] init];
+		serialDisposable.disposable = innerDisposable;
+		weakSerialDisposable = serialDisposable;
+	}
+
+	expect(weakSerialDisposable).to.beNil();
+	expect(weakInnerDisposable).to.beNil();
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACSignalSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSignalSpec.m
new file mode 100644
index 0000000..21b50dd
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSignalSpec.m
@@ -0,0 +1,3877 @@
+//
+//  RACSignalSpec.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 3/2/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACPropertySignalExamples.h"
+#import "RACSequenceExamples.h"
+#import "RACStreamExamples.h"
+#import "RACTestObject.h"
+
+#import "EXTKeyPathCoding.h"
+#import "NSObject+RACDeallocating.h"
+#import "NSObject+RACPropertySubscribing.h"
+#import "RACBehaviorSubject.h"
+#import "RACCommand.h"
+#import "RACCompoundDisposable.h"
+#import "RACDisposable.h"
+#import "RACEvent.h"
+#import "RACGroupedSignal.h"
+#import "RACMulticastConnection.h"
+#import "RACReplaySubject.h"
+#import "RACScheduler.h"
+#import "RACSignal+Operations.h"
+#import "RACSignalStartExamples.h"
+#import "RACSubject.h"
+#import "RACSubscriber+Private.h"
+#import "RACSubscriber.h"
+#import "RACTestScheduler.h"
+#import "RACTuple.h"
+#import "RACUnit.h"
+#import <libkern/OSAtomic.h>
+
+// Set in a beforeAll below.
+static NSError *RACSignalTestError;
+
+static NSString * const RACSignalMergeConcurrentCompletionExampleGroup = @"RACSignalMergeConcurrentCompletionExampleGroup";
+static NSString * const RACSignalMaxConcurrent = @"RACSignalMaxConcurrent";
+SharedExampleGroupsBegin(mergeConcurrentCompletionName);
+
+sharedExamplesFor(RACSignalMergeConcurrentCompletionExampleGroup, ^(NSDictionary *data) {
+	it(@"should complete only after the source and all its signals have completed", ^{
+		RACSubject *subject1 = [RACSubject subject];
+		RACSubject *subject2 = [RACSubject subject];
+		RACSubject *subject3 = [RACSubject subject];
+
+		RACSubject *signalsSubject = [RACSubject subject];
+		__block BOOL completed = NO;
+		[[signalsSubject flatten:[data[RACSignalMaxConcurrent] unsignedIntegerValue]] subscribeCompleted:^{
+			completed = YES;
+		}];
+
+		[signalsSubject sendNext:subject1];
+		[subject1 sendCompleted];
+
+		expect(completed).to.beFalsy();
+
+		[signalsSubject sendNext:subject2];
+		[signalsSubject sendNext:subject3];
+
+		[signalsSubject sendCompleted];
+
+		expect(completed).to.beFalsy();
+
+		[subject2 sendCompleted];
+
+		expect(completed).to.beFalsy();
+
+		[subject3 sendCompleted];
+
+		expect(completed).to.beTruthy();
+	});
+});
+
+SharedExampleGroupsEnd
+
+SpecBegin(RACSignal)
+
+beforeAll(^{
+	// We do this instead of a macro to ensure that to.equal() will work
+	// correctly (by matching identity), even if -[NSError isEqual:] is broken.
+	RACSignalTestError = [NSError errorWithDomain:@"foo" code:100 userInfo:nil];
+});
+
+describe(@"RACStream", ^{
+	id verifyValues = ^(RACSignal *signal, NSArray *expectedValues) {
+		expect(signal).notTo.beNil();
+
+		NSMutableArray *collectedValues = [NSMutableArray array];
+
+		__block BOOL success = NO;
+		__block NSError *error = nil;
+		[signal subscribeNext:^(id value) {
+			[collectedValues addObject:value];
+		} error:^(NSError *receivedError) {
+			error = receivedError;
+		} completed:^{
+			success = YES;
+		}];
+
+		expect(success).will.beTruthy();
+		expect(error).to.beNil();
+		expect(collectedValues).to.equal(expectedValues);
+	};
+
+	RACSignal *infiniteSignal = [RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+		__block volatile int32_t done = 0;
+
+		[RACScheduler.mainThreadScheduler schedule:^{
+			while (!done) {
+				[subscriber sendNext:RACUnit.defaultUnit];
+			}
+		}];
+
+		return [RACDisposable disposableWithBlock:^{
+			OSAtomicIncrement32Barrier(&done);
+		}];
+	}];
+
+	itShouldBehaveLike(RACStreamExamples, ^{
+		return @{
+			RACStreamExamplesClass: RACSignal.class,
+			RACStreamExamplesVerifyValuesBlock: verifyValues,
+			RACStreamExamplesInfiniteStream: infiniteSignal
+		};
+	});
+});
+
+describe(@"-bind:", ^{
+	__block RACSubject *signals;
+	__block BOOL disposed;
+	__block id lastValue;
+	__block RACSubject *values;
+
+	beforeEach(^{
+		// Tests send a (RACSignal, BOOL) pair that are used below in -bind:.
+		signals = [RACSubject subject];
+
+		disposed = NO;
+		RACSignal *source = [RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+			[signals subscribe:subscriber];
+
+			return [RACDisposable disposableWithBlock:^{
+				disposed = YES;
+			}];
+		}];
+
+		RACSignal *bind = [source bind:^{
+			return ^(RACTuple *x, BOOL *stop) {
+				RACTupleUnpack(RACSignal *signal, NSNumber *stopValue) = x;
+				*stop = stopValue.boolValue;
+				return signal;
+			};
+		}];
+
+		lastValue = nil;
+		[bind subscribeNext:^(id x) {
+			lastValue = x;
+		}];
+
+		// Send `bind` an open ended subject to subscribe to. These tests make
+		// use of this in two ways:
+		//   1. Used to test a regression bug where -bind: would not actually
+		//      stop when instructed to. This bug manifested itself only when
+		//      there were subscriptions that lived on past the point at which
+		//      -bind: was stopped. This subject represents such a subscription.
+		//   2. Test that values sent by this subject are received by `bind`'s
+		//      subscriber, even *after* -bind: has been instructed to stop.
+		values = [RACSubject subject];
+		[signals sendNext:RACTuplePack(values, @NO)];
+		expect(disposed).to.beFalsy();
+	});
+
+	it(@"should dispose source signal when stopped with nil signal", ^{
+		// Tell -bind: to stop by sending it a `nil` signal.
+		[signals sendNext:RACTuplePack(nil, @NO)];
+		expect(disposed).to.beTruthy();
+
+		// Should still receive values sent after stopping.
+		expect(lastValue).to.beNil();
+		[values sendNext:RACUnit.defaultUnit];
+		expect(lastValue).to.equal(RACUnit.defaultUnit);
+	});
+
+	it(@"should dispose source signal when stop flag set to YES", ^{
+		// Tell -bind: to stop by setting the stop flag to YES.
+		[signals sendNext:RACTuplePack([RACSignal return:@1], @YES)];
+		expect(disposed).to.beTruthy();
+
+		// Should still recieve last signal sent at the time of setting stop to YES.
+		expect(lastValue).to.equal(@1);
+
+		// Should still receive values sent after stopping.
+		[values sendNext:@2];
+		expect(lastValue).to.equal(@2);
+	});
+});
+
+describe(@"subscribing", ^{
+	__block RACSignal *signal = nil;
+	id nextValueSent = @"1";
+	
+	beforeEach(^{
+		signal = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) {
+			[subscriber sendNext:nextValueSent];
+			[subscriber sendCompleted];
+			return nil;
+		}];
+	});
+	
+	it(@"should get next values", ^{
+		__block id nextValueReceived = nil;
+		[signal subscribeNext:^(id x) {
+			nextValueReceived = x;
+		} error:^(NSError *error) {
+			
+		} completed:^{
+			
+		}];
+		
+		expect(nextValueReceived).to.equal(nextValueSent);
+	});
+	
+	it(@"should get completed", ^{
+		__block BOOL didGetCompleted = NO;
+		[signal subscribeNext:^(id x) {
+			
+		} error:^(NSError *error) {
+			
+		} completed:^{
+			didGetCompleted = YES;
+		}];
+		
+		expect(didGetCompleted).to.beTruthy();
+	});
+	
+	it(@"should not get an error", ^{
+		__block BOOL didGetError = NO;
+		[signal subscribeNext:^(id x) {
+			
+		} error:^(NSError *error) {
+			didGetError = YES;
+		} completed:^{
+			
+		}];
+		
+		expect(didGetError).to.beFalsy();
+	});
+	
+	it(@"shouldn't get anything after dispose", ^{
+		RACTestScheduler *scheduler = [[RACTestScheduler alloc] init];
+		NSMutableArray *receivedValues = [NSMutableArray array];
+
+		RACSignal *signal = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) {
+			[subscriber sendNext:@0];
+
+			[scheduler afterDelay:0 schedule:^{
+				[subscriber sendNext:@1];
+			}];
+
+			return nil;
+		}];
+
+		RACDisposable *disposable = [signal subscribeNext:^(id x) {
+			[receivedValues addObject:x];
+		}];
+
+		NSArray *expectedValues = @[ @0 ];
+		expect(receivedValues).to.equal(expectedValues);
+		
+		[disposable dispose];
+		[scheduler stepAll];
+		
+		expect(receivedValues).to.equal(expectedValues);
+	});
+
+	it(@"should have a current scheduler in didSubscribe block", ^{
+		__block RACScheduler *currentScheduler;
+		RACSignal *signal = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) {
+			currentScheduler = RACScheduler.currentScheduler;
+			[subscriber sendCompleted];
+			return nil;
+		}];
+
+		[signal subscribeNext:^(id x) {}];
+		expect(currentScheduler).notTo.beNil();
+
+		currentScheduler = nil;
+		dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+			[signal subscribeNext:^(id x) {}];
+		});
+		expect(currentScheduler).willNot.beNil();
+	});
+	
+	it(@"should automatically dispose of other subscriptions from +createSignal:", ^{
+		__block BOOL innerDisposed = NO;
+
+		RACSignal *innerSignal = [RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+			return [RACDisposable disposableWithBlock:^{
+				innerDisposed = YES;
+			}];
+		}];
+
+		RACSignal *outerSignal = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) {
+			[innerSignal subscribe:subscriber];
+			return nil;
+		}];
+
+		RACDisposable *disposable = [outerSignal subscribeCompleted:^{}];
+		expect(disposable).notTo.beNil();
+		expect(innerDisposed).to.beFalsy();
+
+		[disposable dispose];
+		expect(innerDisposed).to.beTruthy();
+	});
+});
+
+describe(@"-takeUntil:", ^{
+	it(@"should support value as trigger", ^{
+		__block BOOL shouldBeGettingItems = YES;
+		RACSubject *subject = [RACSubject subject];
+		RACSubject *cutOffSubject = [RACSubject subject];
+		[[subject takeUntil:cutOffSubject] subscribeNext:^(id x) {
+			expect(shouldBeGettingItems).to.beTruthy();
+		}];
+
+		shouldBeGettingItems = YES;
+		[subject sendNext:@"test 1"];
+		[subject sendNext:@"test 2"];
+
+		[cutOffSubject sendNext:[RACUnit defaultUnit]];
+
+		shouldBeGettingItems = NO;
+		[subject sendNext:@"test 3"];
+	});
+    
+	it(@"should support completion as trigger", ^{
+		__block BOOL shouldBeGettingItems = YES;
+		RACSubject *subject = [RACSubject subject];
+		RACSubject *cutOffSubject = [RACSubject subject];
+		[[subject takeUntil:cutOffSubject] subscribeNext:^(id x) {
+			expect(shouldBeGettingItems).to.beTruthy();
+		}];
+        
+		[cutOffSubject sendCompleted];
+        
+		shouldBeGettingItems = NO;
+		[subject sendNext:@"should not go through"];
+	});
+
+	it(@"should squelch any values sent immediately upon subscription", ^{
+		RACSignal *valueSignal = [RACSignal return:RACUnit.defaultUnit];
+		RACSignal *cutOffSignal = [RACSignal empty];
+
+		__block BOOL gotNext = NO;
+		__block BOOL completed = NO;
+
+		[[valueSignal takeUntil:cutOffSignal] subscribeNext:^(id _) {
+			gotNext = YES;
+		} completed:^{
+			completed = YES;
+		}];
+
+		expect(gotNext).to.beFalsy();
+		expect(completed).to.beTruthy();
+	});
+});
+
+describe(@"-takeUntilReplacement:", ^{
+	it(@"should forward values from the receiver until it's replaced", ^{
+		RACSubject *receiver = [RACSubject subject];
+		RACSubject *replacement = [RACSubject subject];
+
+		NSMutableArray *receivedValues = [NSMutableArray array];
+
+		[[receiver takeUntilReplacement:replacement] subscribeNext:^(id x) {
+			[receivedValues addObject:x];
+		}];
+
+		expect(receivedValues).to.equal(@[]);
+
+		[receiver sendNext:@1];
+		expect(receivedValues).to.equal(@[ @1 ]);
+
+		[receiver sendNext:@2];
+		expect(receivedValues).to.equal((@[ @1, @2 ]));
+
+		[replacement sendNext:@3];
+		expect(receivedValues).to.equal((@[ @1, @2, @3 ]));
+
+		[receiver sendNext:@4];
+		expect(receivedValues).to.equal((@[ @1, @2, @3 ]));
+
+		[replacement sendNext:@5];
+		expect(receivedValues).to.equal((@[ @1, @2, @3, @5 ]));
+	});
+
+	it(@"should forward error from the receiver", ^{
+		RACSubject *receiver = [RACSubject subject];
+		__block BOOL receivedError = NO;
+
+		[[receiver takeUntilReplacement:RACSignal.never] subscribeError:^(NSError *error) {
+			receivedError = YES;
+		}];
+
+		[receiver sendError:nil];
+		expect(receivedError).to.beTruthy();
+	});
+
+	it(@"should not forward completed from the receiver", ^{
+		RACSubject *receiver = [RACSubject subject];
+		__block BOOL receivedCompleted = NO;
+
+		[[receiver takeUntilReplacement:RACSignal.never] subscribeCompleted: ^{
+			receivedCompleted = YES;
+		}];
+
+		[receiver sendCompleted];
+		expect(receivedCompleted).to.beFalsy();
+	});
+
+	it(@"should forward error from the replacement signal", ^{
+		RACSubject *replacement = [RACSubject subject];
+		__block BOOL receivedError = NO;
+
+		[[RACSignal.never takeUntilReplacement:replacement] subscribeError:^(NSError *error) {
+			receivedError = YES;
+		}];
+
+		[replacement sendError:nil];
+		expect(receivedError).to.beTruthy();
+	});
+
+	it(@"should forward completed from the replacement signal", ^{
+		RACSubject *replacement = [RACSubject subject];
+		__block BOOL receivedCompleted = NO;
+
+		[[RACSignal.never takeUntilReplacement:replacement] subscribeCompleted: ^{
+			receivedCompleted = YES;
+		}];
+
+		[replacement sendCompleted];
+		expect(receivedCompleted).to.beTruthy();
+	});
+	
+	it(@"should not forward values from the receiver if both send synchronously", ^{
+		RACSignal *receiver = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) {
+			[subscriber sendNext:@1];
+			[subscriber sendNext:@2];
+			[subscriber sendNext:@3];
+			return nil;
+		}];
+		RACSignal *replacement = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) {
+			[subscriber sendNext:@4];
+			[subscriber sendNext:@5];
+			[subscriber sendNext:@6];
+			return nil;
+		}];
+
+		NSMutableArray *receivedValues = [NSMutableArray array];
+
+		[[receiver takeUntilReplacement:replacement] subscribeNext:^(id x) {
+			[receivedValues addObject:x];
+		}];
+
+		expect(receivedValues).to.equal((@[ @4, @5, @6 ]));
+	});
+
+	it(@"should dispose of the receiver when it's disposed of", ^{
+		__block BOOL receiverDisposed = NO;
+		RACSignal *receiver = [RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+			return [RACDisposable disposableWithBlock:^{
+				receiverDisposed = YES;
+			}];
+		}];
+
+		[[[receiver takeUntilReplacement:RACSignal.never] subscribeCompleted:^{}] dispose];
+
+		expect(receiverDisposed).to.beTruthy();
+	});
+
+	it(@"should dispose of the replacement signal when it's disposed of", ^{
+		__block BOOL replacementDisposed = NO;
+		RACSignal *replacement = [RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+			return [RACDisposable disposableWithBlock:^{
+				replacementDisposed = YES;
+			}];
+		}];
+
+		[[[RACSignal.never takeUntilReplacement:replacement] subscribeCompleted:^{}] dispose];
+
+		expect(replacementDisposed).to.beTruthy();
+	});
+
+	it(@"should dispose of the receiver when the replacement signal sends an event", ^{
+		__block BOOL receiverDisposed = NO;
+		RACSignal *receiver = [RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+			return [RACDisposable disposableWithBlock:^{
+				receiverDisposed = YES;
+			}];
+		}];
+		RACSubject *replacement = [RACSubject subject];
+
+		[[receiver takeUntilReplacement:replacement] subscribeCompleted:^{}];
+
+		expect(receiverDisposed).to.beFalsy();
+
+		[replacement sendNext:nil];
+		
+		expect(receiverDisposed).to.beTruthy();
+	});
+});
+
+describe(@"disposal", ^{
+	it(@"should dispose of the didSubscribe disposable", ^{
+		__block BOOL innerDisposed = NO;
+		RACSignal *signal = [RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+			return [RACDisposable disposableWithBlock:^{
+				innerDisposed = YES;
+			}];
+		}];
+
+		expect(innerDisposed).to.beFalsy();
+
+		RACDisposable *disposable = [signal subscribeNext:^(id x) {}];
+		expect(disposable).notTo.beNil();
+
+		[disposable dispose];
+		expect(innerDisposed).to.beTruthy();
+	});
+
+	it(@"should dispose of the didSubscribe disposable asynchronously", ^{
+		__block BOOL innerDisposed = NO;
+		RACSignal *signal = [RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+			return [RACDisposable disposableWithBlock:^{
+				innerDisposed = YES;
+			}];
+		}];
+
+		[[RACScheduler scheduler] schedule:^{
+			RACDisposable *disposable = [signal subscribeNext:^(id x) {}];
+			[disposable dispose];
+		}];
+
+		expect(innerDisposed).will.beTruthy();
+	});
+});
+
+describe(@"querying", ^{
+	__block RACSignal *signal = nil;
+	id nextValueSent = @"1";
+	
+	beforeEach(^{
+		signal = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) {
+			[subscriber sendNext:nextValueSent];
+			[subscriber sendNext:@"other value"];
+			[subscriber sendCompleted];
+			return nil;
+		}];
+	});
+	
+	it(@"should return first 'next' value with -firstOrDefault:success:error:", ^{
+		RACSignal *signal = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) {
+			[subscriber sendNext:@1];
+			[subscriber sendNext:@2];
+			[subscriber sendNext:@3];
+			[subscriber sendCompleted];
+			return nil;
+		}];
+
+		expect(signal).notTo.beNil();
+
+		__block BOOL success = NO;
+		__block NSError *error = nil;
+		expect([signal firstOrDefault:@5 success:&success error:&error]).to.equal(@1);
+		expect(success).to.beTruthy();
+		expect(error).to.beNil();
+	});
+	
+	it(@"should return first default value with -firstOrDefault:success:error:", ^{
+		RACSignal *signal = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) {
+			[subscriber sendCompleted];
+			return nil;
+		}];
+
+		expect(signal).notTo.beNil();
+
+		__block BOOL success = NO;
+		__block NSError *error = nil;
+		expect([signal firstOrDefault:@5 success:&success error:&error]).to.equal(@5);
+		expect(success).to.beTruthy();
+		expect(error).to.beNil();
+	});
+	
+	it(@"should return error with -firstOrDefault:success:error:", ^{
+		RACSignal *signal = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) {
+			[subscriber sendError:RACSignalTestError];
+			return nil;
+		}];
+
+		expect(signal).notTo.beNil();
+
+		__block BOOL success = NO;
+		__block NSError *error = nil;
+		expect([signal firstOrDefault:@5 success:&success error:&error]).to.equal(@5);
+		expect(success).to.beFalsy();
+		expect(error).to.equal(RACSignalTestError);
+	});
+
+	it(@"shouldn't crash when returning an error from a background scheduler", ^{
+		RACSignal *signal = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) {
+			[[RACScheduler scheduler] schedule:^{
+				[subscriber sendError:RACSignalTestError];
+			}];
+
+			return nil;
+		}];
+
+		expect(signal).notTo.beNil();
+
+		__block BOOL success = NO;
+		__block NSError *error = nil;
+		expect([signal firstOrDefault:@5 success:&success error:&error]).to.equal(@5);
+		expect(success).to.beFalsy();
+		expect(error).to.equal(RACSignalTestError);
+	});
+
+	it(@"should terminate the subscription after returning from -firstOrDefault:success:error:", ^{
+		__block BOOL disposed = NO;
+		RACSignal *signal = [RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+			[subscriber sendNext:RACUnit.defaultUnit];
+
+			return [RACDisposable disposableWithBlock:^{
+				disposed = YES;
+			}];
+		}];
+
+		expect(signal).notTo.beNil();
+		expect(disposed).to.beFalsy();
+
+		expect([signal firstOrDefault:nil success:NULL error:NULL]).to.equal(RACUnit.defaultUnit);
+		expect(disposed).to.beTruthy();
+	});
+
+	it(@"should return YES from -waitUntilCompleted: when successful", ^{
+		RACSignal *signal = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) {
+			[subscriber sendNext:RACUnit.defaultUnit];
+			[subscriber sendCompleted];
+			return nil;
+		}];
+
+		__block NSError *error = nil;
+		expect([signal waitUntilCompleted:&error]).to.beTruthy();
+		expect(error).to.beNil();
+	});
+
+	it(@"should return NO from -waitUntilCompleted: upon error", ^{
+		RACSignal *signal = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) {
+			[subscriber sendNext:RACUnit.defaultUnit];
+			[subscriber sendError:RACSignalTestError];
+			return nil;
+		}];
+
+		__block NSError *error = nil;
+		expect([signal waitUntilCompleted:&error]).to.beFalsy();
+		expect(error).to.equal(RACSignalTestError);
+	});
+
+	it(@"should return a delayed value from -asynchronousFirstOrDefault:success:error:", ^{
+		RACSignal *signal = [[RACSignal return:RACUnit.defaultUnit] delay:0];
+
+		__block BOOL scheduledBlockRan = NO;
+		[RACScheduler.mainThreadScheduler schedule:^{
+			scheduledBlockRan = YES;
+		}];
+
+		expect(scheduledBlockRan).to.beFalsy();
+
+		BOOL success = NO;
+		NSError *error = nil;
+		id value = [signal asynchronousFirstOrDefault:nil success:&success error:&error];
+
+		expect(scheduledBlockRan).to.beTruthy();
+
+		expect(value).to.equal(RACUnit.defaultUnit);
+		expect(success).to.beTruthy();
+		expect(error).to.beNil();
+	});
+
+	it(@"should return a default value from -asynchronousFirstOrDefault:success:error:", ^{
+		RACSignal *signal = [[RACSignal error:RACSignalTestError] delay:0];
+
+		__block BOOL scheduledBlockRan = NO;
+		[RACScheduler.mainThreadScheduler schedule:^{
+			scheduledBlockRan = YES;
+		}];
+
+		expect(scheduledBlockRan).to.beFalsy();
+
+		BOOL success = NO;
+		NSError *error = nil;
+		id value = [signal asynchronousFirstOrDefault:RACUnit.defaultUnit success:&success error:&error];
+
+		expect(scheduledBlockRan).to.beTruthy();
+
+		expect(value).to.equal(RACUnit.defaultUnit);
+		expect(success).to.beFalsy();
+		expect(error).to.equal(RACSignalTestError);
+	});
+
+	it(@"should return a delayed error from -asynchronousFirstOrDefault:success:error:", ^{
+		RACSignal *signal = [[RACSignal
+			createSignal:^(id<RACSubscriber> subscriber) {
+				return [[RACScheduler scheduler] schedule:^{
+					[subscriber sendError:RACSignalTestError];
+				}];
+			}]
+			deliverOn:RACScheduler.mainThreadScheduler];
+
+		__block NSError *error = nil;
+		__block BOOL success = NO;
+		expect([signal asynchronousFirstOrDefault:nil success:&success error:&error]).to.beNil();
+
+		expect(success).to.beFalsy();
+		expect(error).to.equal(RACSignalTestError);
+	});
+
+	it(@"should terminate the subscription after returning from -asynchronousFirstOrDefault:success:error:", ^{
+		__block BOOL disposed = NO;
+		RACSignal *signal = [RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+			[[RACScheduler scheduler] schedule:^{
+				[subscriber sendNext:RACUnit.defaultUnit];
+			}];
+
+			return [RACDisposable disposableWithBlock:^{
+				disposed = YES;
+			}];
+		}];
+
+		expect(signal).notTo.beNil();
+		expect(disposed).to.beFalsy();
+
+		expect([signal asynchronousFirstOrDefault:nil success:NULL error:NULL]).to.equal(RACUnit.defaultUnit);
+		expect(disposed).will.beTruthy();
+	});
+
+	it(@"should return a delayed success from -asynchronouslyWaitUntilCompleted:", ^{
+		RACSignal *signal = [[RACSignal return:RACUnit.defaultUnit] delay:0];
+
+		__block BOOL scheduledBlockRan = NO;
+		[RACScheduler.mainThreadScheduler schedule:^{
+			scheduledBlockRan = YES;
+		}];
+
+		expect(scheduledBlockRan).to.beFalsy();
+
+		NSError *error = nil;
+		BOOL success = [signal asynchronouslyWaitUntilCompleted:&error];
+
+		expect(scheduledBlockRan).to.beTruthy();
+
+		expect(success).to.beTruthy();
+		expect(error).to.beNil();
+	});
+});
+
+describe(@"continuation", ^{
+	it(@"should repeat after completion", ^{
+		__block NSUInteger numberOfSubscriptions = 0;
+		RACScheduler *scheduler = [RACScheduler scheduler];
+
+		RACSignal *signal = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) {
+			return [scheduler schedule:^{
+				if (numberOfSubscriptions == 3) {
+					[subscriber sendError:RACSignalTestError];
+					return;
+				}
+				
+				numberOfSubscriptions++;
+				
+				[subscriber sendNext:@"1"];
+				[subscriber sendCompleted];
+				[subscriber sendError:RACSignalTestError];
+			}];
+		}];
+		
+		__block NSUInteger nextCount = 0;
+		__block BOOL gotCompleted = NO;
+		[[signal repeat] subscribeNext:^(id x) {
+			nextCount++;
+		} error:^(NSError *error) {
+			
+		} completed:^{
+			gotCompleted = YES;
+		}];
+		
+		expect(nextCount).will.equal(3);
+		expect(gotCompleted).to.beFalsy();
+	});
+
+	it(@"should stop repeating when disposed", ^{
+		RACSignal *signal = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) {
+			[subscriber sendNext:@1];
+			[subscriber sendCompleted];
+			return nil;
+		}];
+
+		NSMutableArray *values = [NSMutableArray array];
+
+		__block BOOL completed = NO;
+		__block RACDisposable *disposable = [[signal repeat] subscribeNext:^(id x) {
+			[values addObject:x];
+			[disposable dispose];
+		} completed:^{
+			completed = YES;
+		}];
+
+		expect(values).will.equal(@[ @1 ]);
+		expect(completed).to.beFalsy();
+	});
+
+	it(@"should stop repeating when disposed by -take:", ^{
+		RACSignal *signal = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) {
+			[subscriber sendNext:@1];
+			[subscriber sendCompleted];
+			return nil;
+		}];
+
+		NSMutableArray *values = [NSMutableArray array];
+
+		__block BOOL completed = NO;
+		[[[signal repeat] take:1] subscribeNext:^(id x) {
+			[values addObject:x];
+		} completed:^{
+			completed = YES;
+		}];
+
+		expect(values).will.equal(@[ @1 ]);
+		expect(completed).to.beTruthy();
+	});
+});
+
+describe(@"+combineLatestWith:", ^{
+	__block RACSubject *subject1 = nil;
+	__block RACSubject *subject2 = nil;
+	__block RACSignal *combined = nil;
+	
+	beforeEach(^{
+		subject1 = [RACSubject subject];
+		subject2 = [RACSubject subject];
+		combined = [RACSignal combineLatest:@[ subject1, subject2 ]];
+	});
+	
+	it(@"should send next only once both signals send next", ^{
+		__block RACTuple *tuple;
+		
+		[combined subscribeNext:^(id x) {
+			tuple = x;
+		}];
+		
+		expect(tuple).to.beNil();
+
+		[subject1 sendNext:@"1"];
+		expect(tuple).to.beNil();
+
+		[subject2 sendNext:@"2"];
+		expect(tuple).to.equal(RACTuplePack(@"1", @"2"));
+	});
+	
+	it(@"should send nexts when either signal sends multiple times", ^{
+		NSMutableArray *results = [NSMutableArray array];
+		[combined subscribeNext:^(id x) {
+			[results addObject:x];
+		}];
+		
+		[subject1 sendNext:@"1"];
+		[subject2 sendNext:@"2"];
+		
+		[subject1 sendNext:@"3"];
+		[subject2 sendNext:@"4"];
+		
+		expect(results[0]).to.equal(RACTuplePack(@"1", @"2"));
+		expect(results[1]).to.equal(RACTuplePack(@"3", @"2"));
+		expect(results[2]).to.equal(RACTuplePack(@"3", @"4"));
+	});
+	
+	it(@"should complete when only both signals complete", ^{
+		__block BOOL completed = NO;
+		
+		[combined subscribeCompleted:^{
+			completed = YES;
+		}];
+
+		expect(completed).to.beFalsy();
+		
+		[subject1 sendCompleted];
+		expect(completed).to.beFalsy();
+
+		[subject2 sendCompleted];
+		expect(completed).to.beTruthy();
+	});
+	
+	it(@"should error when either signal errors", ^{
+		__block NSError *receivedError = nil;
+		[combined subscribeError:^(NSError *error) {
+			receivedError = error;
+		}];
+		
+		[subject1 sendError:RACSignalTestError];
+		expect(receivedError).to.equal(RACSignalTestError);
+	});
+
+	it(@"shouldn't create a retain cycle", ^{
+		__block BOOL subjectDeallocd = NO;
+		__block BOOL signalDeallocd = NO;
+
+		@autoreleasepool {
+			RACSubject *subject __attribute__((objc_precise_lifetime)) = [RACSubject subject];
+			[subject.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				subjectDeallocd = YES;
+			}]];
+			
+			RACSignal *signal __attribute__((objc_precise_lifetime)) = [RACSignal combineLatest:@[ subject ]];
+			[signal.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				signalDeallocd = YES;
+			}]];
+
+			[signal subscribeCompleted:^{}];
+			[subject sendCompleted];
+		}
+
+		expect(subjectDeallocd).will.beTruthy();
+		expect(signalDeallocd).will.beTruthy();
+	});
+
+	it(@"should combine the same signal", ^{
+		RACSignal *combined = [subject1 combineLatestWith:subject1];
+
+		__block RACTuple *tuple;
+		[combined subscribeNext:^(id x) {
+			tuple = x;
+		}];
+		
+		[subject1 sendNext:@"foo"];
+		expect(tuple).to.equal(RACTuplePack(@"foo", @"foo"));
+		
+		[subject1 sendNext:@"bar"];
+		expect(tuple).to.equal(RACTuplePack(@"bar", @"bar"));
+	});
+    
+	it(@"should combine the same side-effecting signal", ^{
+		__block NSUInteger counter = 0;
+		RACSignal *sideEffectingSignal = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) {
+			[subscriber sendNext:@(++counter)];
+			[subscriber sendCompleted];
+			return nil;
+		}];
+
+		RACSignal *combined = [sideEffectingSignal combineLatestWith:sideEffectingSignal];
+		expect(counter).to.equal(0);
+
+		NSMutableArray *receivedValues = [NSMutableArray array];
+		[combined subscribeNext:^(id x) {
+			[receivedValues addObject:x];
+		}];
+		
+		expect(counter).to.equal(2);
+
+		NSArray *expected = @[ RACTuplePack(@1, @2) ];
+		expect(receivedValues).to.equal(expected);
+	});
+});
+
+describe(@"+combineLatest:", ^{
+	it(@"should return tuples even when only combining one signal", ^{
+		RACSubject *subject = [RACSubject subject];
+
+		__block RACTuple *tuple;
+		[[RACSignal combineLatest:@[ subject ]] subscribeNext:^(id x) {
+			tuple = x;
+		}];
+
+		[subject sendNext:@"foo"];
+		expect(tuple).to.equal(RACTuplePack(@"foo"));
+	});
+
+	it(@"should complete immediately when not given any signals", ^{
+		RACSignal *signal = [RACSignal combineLatest:@[]];
+
+		__block BOOL completed = NO;
+		[signal subscribeCompleted:^{
+			completed = YES;
+		}];
+
+		expect(completed).to.beTruthy();
+	});
+
+	it(@"should only complete after all its signals complete", ^{
+		RACSubject *subject1 = [RACSubject subject];
+		RACSubject *subject2 = [RACSubject subject];
+		RACSubject *subject3 = [RACSubject subject];
+		RACSignal *combined = [RACSignal combineLatest:@[ subject1, subject2, subject3 ]];
+
+		__block BOOL completed = NO;
+		[combined subscribeCompleted:^{
+			completed = YES;
+		}];
+
+		expect(completed).to.beFalsy();
+
+		[subject1 sendCompleted];
+		expect(completed).to.beFalsy();
+
+		[subject2 sendCompleted];
+		expect(completed).to.beFalsy();
+
+		[subject3 sendCompleted];
+		expect(completed).to.beTruthy();
+	});
+});
+
+describe(@"+combineLatest:reduce:", ^{
+	__block RACSubject *subject1;
+	__block RACSubject *subject2;
+	__block RACSubject *subject3;
+
+	beforeEach(^{
+		subject1 = [RACSubject subject];
+		subject2 = [RACSubject subject];
+		subject3 = [RACSubject subject];
+	});
+
+	it(@"should send nils for nil values", ^{
+		__block id receivedVal1;
+		__block id receivedVal2;
+		__block id receivedVal3;
+
+		RACSignal *combined = [RACSignal combineLatest:@[ subject1, subject2, subject3 ] reduce:^ id (id val1, id val2, id val3) {
+			receivedVal1 = val1;
+			receivedVal2 = val2;
+			receivedVal3 = val3;
+			return nil;
+		}];
+
+		__block BOOL gotValue = NO;
+		[combined subscribeNext:^(id x) {
+			gotValue = YES;
+		}];
+
+		[subject1 sendNext:nil];
+		[subject2 sendNext:nil];
+		[subject3 sendNext:nil];
+
+		expect(gotValue).to.beTruthy();
+		expect(receivedVal1).to.beNil();
+		expect(receivedVal2).to.beNil();
+		expect(receivedVal3).to.beNil();
+	});
+
+	it(@"should send the return result of the reduce block", ^{
+		RACSignal *combined = [RACSignal combineLatest:@[ subject1, subject2, subject3 ] reduce:^(NSString *string1, NSString *string2, NSString *string3) {
+			return [NSString stringWithFormat:@"%@: %@%@", string1, string2, string3];
+		}];
+
+		__block id received;
+		[combined subscribeNext:^(id x) {
+			received = x;
+		}];
+
+		[subject1 sendNext:@"hello"];
+		[subject2 sendNext:@"world"];
+		[subject3 sendNext:@"!!1"];
+
+		expect(received).to.equal(@"hello: world!!1");
+	});
+	
+	it(@"should handle multiples of the same signals", ^{
+		RACSignal *combined = [RACSignal combineLatest:@[ subject1, subject2, subject1, subject3 ] reduce:^(NSString *string1, NSString *string2, NSString *string3, NSString *string4) {
+			return [NSString stringWithFormat:@"%@ : %@ = %@ : %@", string1, string2, string3, string4];
+		}];
+		
+		NSMutableArray *receivedValues = NSMutableArray.array;
+		
+		[combined subscribeNext:^(id x) {
+			[receivedValues addObject:x];
+		}];
+		
+		[subject1 sendNext:@"apples"];
+		expect(receivedValues.lastObject).to.beNil();
+		
+		[subject2 sendNext:@"oranges"];
+		expect(receivedValues.lastObject).to.beNil();
+
+		[subject3 sendNext:@"cattle"];
+		expect(receivedValues.lastObject).to.equal(@"apples : oranges = apples : cattle");
+		
+		[subject1 sendNext:@"horses"];
+		expect(receivedValues.lastObject).to.equal(@"horses : oranges = horses : cattle");
+	});
+    
+	it(@"should handle multiples of the same side-effecting signal", ^{
+		__block NSUInteger counter = 0;
+		RACSignal *sideEffectingSignal = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) {
+			[subscriber sendNext:@(++counter)];
+			[subscriber sendCompleted];
+			return nil;
+		}];
+
+		RACSignal *combined = [RACSignal combineLatest:@[ sideEffectingSignal, sideEffectingSignal, sideEffectingSignal ] reduce:^(id x, id y, id z) {
+			return [NSString stringWithFormat:@"%@%@%@", x, y, z];
+		}];
+
+		NSMutableArray *receivedValues = [NSMutableArray array];
+		expect(counter).to.equal(0);
+		
+		[combined subscribeNext:^(id x) {
+			[receivedValues addObject:x];
+		}];
+		
+		expect(counter).to.equal(3);
+		expect(receivedValues).to.equal(@[ @"123" ]);
+	});
+});
+
+describe(@"distinctUntilChanged", ^{
+	it(@"should only send values that are distinct from the previous value", ^{
+		RACSignal *sub = [[RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) {
+			[subscriber sendNext:@1];
+			[subscriber sendNext:@2];
+			[subscriber sendNext:@2];
+			[subscriber sendNext:@1];
+			[subscriber sendNext:@1];
+			[subscriber sendCompleted];
+			return nil;
+		}] distinctUntilChanged];
+		
+		NSArray *values = sub.toArray;
+		NSArray *expected = @[ @1, @2, @1 ];
+		expect(values).to.equal(expected);
+	});
+
+	it(@"shouldn't consider nils to always be distinct", ^{
+		RACSignal *sub = [[RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) {
+			[subscriber sendNext:@1];
+			[subscriber sendNext:nil];
+			[subscriber sendNext:nil];
+			[subscriber sendNext:nil];
+			[subscriber sendNext:@1];
+			[subscriber sendCompleted];
+			return nil;
+		}] distinctUntilChanged];
+		
+		NSArray *values = sub.toArray;
+		NSArray *expected = @[ @1, [NSNull null], @1 ];
+		expect(values).to.equal(expected);
+	});
+
+	it(@"should consider initial nil to be distinct", ^{
+		RACSignal *sub = [[RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) {
+			[subscriber sendNext:nil];
+			[subscriber sendNext:nil];
+			[subscriber sendNext:@1];
+			[subscriber sendCompleted];
+			return nil;
+		}] distinctUntilChanged];
+		
+		NSArray *values = sub.toArray;
+		NSArray *expected = @[ [NSNull null], @1 ];
+		expect(values).to.equal(expected);
+	});
+});
+
+describe(@"RACObserve", ^{
+	__block RACTestObject *testObject;
+
+	beforeEach(^{
+		testObject = [[RACTestObject alloc] init];
+	});
+
+	it(@"should work with object properties", ^{
+		NSArray *expected = @[ @"hello", @"world" ];
+		testObject.objectValue = expected[0];
+
+		NSMutableArray *valuesReceived = [NSMutableArray array];
+		[RACObserve(testObject, objectValue) subscribeNext:^(id x) {
+			[valuesReceived addObject:x];
+		}];
+
+		testObject.objectValue = expected[1];
+
+		expect(valuesReceived).to.equal(expected);
+	});
+
+	it(@"should work with non-object properties", ^{
+		NSArray *expected = @[ @42, @43 ];
+		testObject.integerValue = [expected[0] integerValue];
+
+		NSMutableArray *valuesReceived = [NSMutableArray array];
+		[RACObserve(testObject, integerValue) subscribeNext:^(id x) {
+			[valuesReceived addObject:x];
+		}];
+
+		testObject.integerValue = [expected[1] integerValue];
+
+		expect(valuesReceived).to.equal(expected);
+	});
+
+	it(@"should read the initial value upon subscription", ^{
+		testObject.objectValue = @"foo";
+
+		RACSignal *signal = RACObserve(testObject, objectValue);
+		testObject.objectValue = @"bar";
+
+		expect([signal first]).to.equal(@"bar");
+	});
+});
+
+describe(@"-setKeyPath:onObject:", ^{
+	id setupBlock = ^(RACTestObject *testObject, NSString *keyPath, id nilValue, RACSignal *signal) {
+		[signal setKeyPath:keyPath onObject:testObject nilValue:nilValue];
+	};
+
+	itShouldBehaveLike(RACPropertySignalExamples, ^{
+		return @{ RACPropertySignalExamplesSetupBlock: setupBlock };
+	});
+
+	it(@"shouldn't send values to dealloc'd objects", ^{
+		RACSubject *subject = [RACSubject subject];
+		@autoreleasepool {
+			RACTestObject *testObject __attribute__((objc_precise_lifetime)) = [[RACTestObject alloc] init];
+			[subject setKeyPath:@keypath(testObject.objectValue) onObject:testObject];
+			expect(testObject.objectValue).to.beNil();
+
+			[subject sendNext:@1];
+			expect(testObject.objectValue).to.equal(@1);
+
+			[subject sendNext:@2];
+			expect(testObject.objectValue).to.equal(@2);
+		}
+
+		// This shouldn't do anything.
+		[subject sendNext:@3];
+	});
+
+	it(@"should allow a new derivation after the signal's completed", ^{
+		RACSubject *subject1 = [RACSubject subject];
+		RACTestObject *testObject = [[RACTestObject alloc] init];
+		[subject1 setKeyPath:@keypath(testObject.objectValue) onObject:testObject];
+		[subject1 sendCompleted];
+
+		RACSubject *subject2 = [RACSubject subject];
+		// This will assert if the previous completion didn't dispose of the
+		// subscription.
+		[subject2 setKeyPath:@keypath(testObject.objectValue) onObject:testObject];
+	});
+
+	it(@"should set the given value when nil is received", ^{
+		RACSubject *subject = [RACSubject subject];
+		RACTestObject *testObject = [[RACTestObject alloc] init];
+		[subject setKeyPath:@keypath(testObject.integerValue) onObject:testObject nilValue:@5];
+
+		[subject sendNext:@1];
+		expect(testObject.integerValue).to.equal(1);
+
+		[subject sendNext:nil];
+		expect(testObject.integerValue).to.equal(5);
+
+		[subject sendCompleted];
+		expect(testObject.integerValue).to.equal(5);
+	});
+
+	it(@"should keep object alive over -sendNext:", ^{
+		RACSubject *subject = [RACSubject subject];
+		__block RACTestObject *testObject = [[RACTestObject alloc] init];
+		__block id deallocValue;
+
+		__unsafe_unretained RACTestObject *unsafeTestObject = testObject;
+		[testObject.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+			deallocValue = unsafeTestObject.slowObjectValue;
+		}]];
+
+		[subject setKeyPath:@keypath(testObject.slowObjectValue) onObject:testObject];
+		expect(testObject.slowObjectValue).to.beNil();
+
+		// Attempt to deallocate concurrently.
+		[[RACScheduler scheduler] afterDelay:0.01 schedule:^{
+			testObject = nil;
+		}];
+
+		expect(deallocValue).to.beNil();
+		[subject sendNext:@1];
+		expect(deallocValue).to.equal(@1);
+	});
+});
+
+describe(@"memory management", ^{
+	it(@"should dealloc signals if the signal does nothing", ^{
+		__block BOOL deallocd = NO;
+		@autoreleasepool {
+			RACSignal *signal __attribute__((objc_precise_lifetime)) = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) {
+				return nil;
+			}];
+
+			[signal.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				deallocd = YES;
+			}]];
+		}
+
+		expect(deallocd).will.beTruthy();
+	});
+
+	it(@"should retain signals for a single run loop iteration", ^{
+		__block BOOL deallocd = NO;
+
+		@autoreleasepool {
+			RACSignal *signal __attribute__((objc_precise_lifetime)) = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) {
+				return nil;
+			}];
+
+			[signal.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				deallocd = YES;
+			}]];
+		}
+
+		expect(deallocd).to.beFalsy();
+		expect(deallocd).will.beTruthy();
+	});
+
+	it(@"should dealloc signals if the signal immediately completes", ^{
+		__block BOOL deallocd = NO;
+		@autoreleasepool {
+			__block BOOL done = NO;
+
+			RACSignal *signal __attribute__((objc_precise_lifetime)) = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) {
+				[subscriber sendCompleted];
+				return nil;
+			}];
+
+			[signal.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				deallocd = YES;
+			}]];
+
+			[signal subscribeCompleted:^{
+				done = YES;
+			}];
+
+			expect(done).will.beTruthy();
+		}
+		
+		expect(deallocd).will.beTruthy();
+	});
+
+	it(@"should dealloc a replay subject if it completes immediately", ^{
+		__block BOOL completed = NO;
+		__block BOOL deallocd = NO;
+		@autoreleasepool {
+			RACReplaySubject *subject __attribute__((objc_precise_lifetime)) = [RACReplaySubject subject];
+			[subject sendCompleted];
+
+			[subject.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				deallocd = YES;
+			}]];
+
+			[subject subscribeCompleted:^{
+				completed = YES;
+			}];
+		}
+
+		expect(completed).will.beTruthy();
+
+		expect(deallocd).will.beTruthy();
+	});
+
+	it(@"should dealloc if the signal was created on a background queue", ^{
+		__block BOOL completed = NO;
+		__block BOOL deallocd = NO;
+		@autoreleasepool {
+			[[RACScheduler scheduler] schedule:^{
+				RACSignal *signal __attribute__((objc_precise_lifetime)) = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) {
+					[subscriber sendCompleted];
+					return nil;
+				}];
+
+				[signal.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+					deallocd = YES;
+				}]];
+
+				[signal subscribeCompleted:^{
+					completed = YES;
+				}];
+			}];
+		}
+
+		expect(completed).will.beTruthy();
+
+		expect(deallocd).will.beTruthy();
+	});
+
+	it(@"should dealloc if the signal was created on a background queue, never gets any subscribers, and the background queue gets delayed", ^{
+		__block BOOL deallocd = NO;
+		@autoreleasepool {
+			[[RACScheduler scheduler] schedule:^{
+				RACSignal *signal __attribute__((objc_precise_lifetime)) = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) {
+					return nil;
+				}];
+
+				[signal.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+					deallocd = YES;
+				}]];
+
+				[NSThread sleepForTimeInterval:1];
+
+				expect(deallocd).to.beFalsy();
+			}];
+		}
+
+		// The default test timeout is 1s so we'd race to see if the queue delay
+		// or default timeout happens first. To avoid that, just bump the
+		// timeout slightly for this test.
+		NSTimeInterval originalTestTimeout = Expecta.asynchronousTestTimeout;
+		Expecta.asynchronousTestTimeout = 1.1f;
+		expect(deallocd).will.beTruthy();
+		Expecta.asynchronousTestTimeout = originalTestTimeout;
+	});
+
+	it(@"should retain signals when subscribing", ^{
+		__block BOOL deallocd = NO;
+
+		RACDisposable *disposable;
+		@autoreleasepool {
+			@autoreleasepool {
+				@autoreleasepool {
+					RACSignal *signal __attribute__((objc_precise_lifetime)) = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) {
+						return nil;
+					}];
+					
+					[signal.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+						deallocd = YES;
+					}]];
+					
+					disposable = [signal subscribeCompleted:^{}];
+				}
+				
+				// Spin the run loop to account for RAC magic that retains the
+				// signal for a single iteration.
+				[NSRunLoop.mainRunLoop runMode:NSDefaultRunLoopMode beforeDate:[NSDate date]];
+			}
+			
+			expect(deallocd).to.beFalsy();
+			
+			[disposable dispose];
+		}
+		expect(deallocd).will.beTruthy();
+	});
+
+	it(@"should retain intermediate signals when subscribing", ^{
+		RACSubject *subject = [RACSubject subject];
+		expect(subject).notTo.beNil();
+
+		__block BOOL gotNext = NO;
+		__block BOOL completed = NO;
+
+		RACDisposable *disposable;
+
+		@autoreleasepool {
+			@autoreleasepool {
+				RACSignal *intermediateSignal = [subject doNext:^(id _) {
+					gotNext = YES;
+				}];
+
+				expect(intermediateSignal).notTo.beNil();
+
+				disposable = [intermediateSignal subscribeCompleted:^{
+					completed = YES;
+				}];
+			}
+
+			// Spin the run loop to account for RAC magic that retains the
+			// signal for a single iteration.
+			[NSRunLoop.mainRunLoop runMode:NSDefaultRunLoopMode beforeDate:[NSDate date]];
+		}
+
+		[subject sendNext:@5];
+		expect(gotNext).to.beTruthy();
+
+		[subject sendCompleted];
+		expect(completed).to.beTruthy();
+		
+		[disposable dispose];
+	});
+});
+
+describe(@"-merge:", ^{
+	__block RACSubject *sub1;
+	__block RACSubject *sub2;
+	__block RACSignal *merged;
+	beforeEach(^{
+		sub1 = [RACSubject subject];
+		sub2 = [RACSubject subject];
+		merged = [sub1 merge:sub2];
+	});
+
+	it(@"should send all values from both signals", ^{
+		NSMutableArray *values = [NSMutableArray array];
+		[merged subscribeNext:^(id x) {
+			[values addObject:x];
+		}];
+
+		[sub1 sendNext:@1];
+		[sub2 sendNext:@2];
+		[sub2 sendNext:@3];
+		[sub1 sendNext:@4];
+
+		NSArray *expected = @[ @1, @2, @3, @4 ];
+		expect(values).to.equal(expected);
+	});
+
+	it(@"should send an error if one occurs", ^{
+		__block NSError *errorReceived;
+		[merged subscribeError:^(NSError *error) {
+			errorReceived = error;
+		}];
+
+		[sub1 sendError:RACSignalTestError];
+		expect(errorReceived).to.equal(RACSignalTestError);
+	});
+
+	it(@"should complete only after both signals complete", ^{
+		NSMutableArray *values = [NSMutableArray array];
+		__block BOOL completed = NO;
+		[merged subscribeNext:^(id x) {
+			[values addObject:x];
+		} completed:^{
+			completed = YES;
+		}];
+
+		[sub1 sendNext:@1];
+		[sub2 sendNext:@2];
+		[sub2 sendNext:@3];
+		[sub2 sendCompleted];
+		expect(completed).to.beFalsy();
+
+		[sub1 sendNext:@4];
+		[sub1 sendCompleted];
+		expect(completed).to.beTruthy();
+
+		NSArray *expected = @[ @1, @2, @3, @4 ];
+		expect(values).to.equal(expected);
+	});
+
+	it(@"should complete only after both signals complete for any number of subscribers", ^{
+		__block BOOL completed1 = NO;
+		__block BOOL completed2 = NO;
+		[merged subscribeCompleted:^{
+			completed1 = YES;
+		}];
+
+		[merged subscribeCompleted:^{
+			completed2 = YES;
+		}];
+
+		expect(completed1).to.beFalsy();
+		expect(completed2).to.beFalsy();
+
+		[sub1 sendCompleted];
+		[sub2 sendCompleted];
+		expect(completed1).to.beTruthy();
+		expect(completed2).to.beTruthy();
+	});
+});
+
+describe(@"+merge:", ^{
+	__block RACSubject *sub1;
+	__block RACSubject *sub2;
+	__block RACSignal *merged;
+	beforeEach(^{
+		sub1 = [RACSubject subject];
+		sub2 = [RACSubject subject];
+		merged = [RACSignal merge:@[ sub1, sub2 ].objectEnumerator];
+	});
+
+	it(@"should send all values from both signals", ^{
+		NSMutableArray *values = [NSMutableArray array];
+		[merged subscribeNext:^(id x) {
+			[values addObject:x];
+		}];
+
+		[sub1 sendNext:@1];
+		[sub2 sendNext:@2];
+		[sub2 sendNext:@3];
+		[sub1 sendNext:@4];
+
+		NSArray *expected = @[ @1, @2, @3, @4 ];
+		expect(values).to.equal(expected);
+	});
+
+	it(@"should send an error if one occurs", ^{
+		__block NSError *errorReceived;
+		[merged subscribeError:^(NSError *error) {
+			errorReceived = error;
+		}];
+
+		[sub1 sendError:RACSignalTestError];
+		expect(errorReceived).to.equal(RACSignalTestError);
+	});
+
+	it(@"should complete only after both signals complete", ^{
+		NSMutableArray *values = [NSMutableArray array];
+		__block BOOL completed = NO;
+		[merged subscribeNext:^(id x) {
+			[values addObject:x];
+		} completed:^{
+			completed = YES;
+		}];
+
+		[sub1 sendNext:@1];
+		[sub2 sendNext:@2];
+		[sub2 sendNext:@3];
+		[sub2 sendCompleted];
+		expect(completed).to.beFalsy();
+
+		[sub1 sendNext:@4];
+		[sub1 sendCompleted];
+		expect(completed).to.beTruthy();
+
+		NSArray *expected = @[ @1, @2, @3, @4 ];
+		expect(values).to.equal(expected);
+	});
+
+	it(@"should complete immediately when not given any signals", ^{
+		RACSignal *signal = [RACSignal merge:@[].objectEnumerator];
+
+		__block BOOL completed = NO;
+		[signal subscribeCompleted:^{
+			completed = YES;
+		}];
+
+		expect(completed).to.beTruthy();
+	});
+
+	it(@"should complete only after both signals complete for any number of subscribers", ^{
+		__block BOOL completed1 = NO;
+		__block BOOL completed2 = NO;
+		[merged subscribeCompleted:^{
+			completed1 = YES;
+		}];
+
+		[merged subscribeCompleted:^{
+			completed2 = YES;
+		}];
+
+		expect(completed1).to.beFalsy();
+		expect(completed2).to.beFalsy();
+
+		[sub1 sendCompleted];
+		[sub2 sendCompleted];
+		expect(completed1).to.beTruthy();
+		expect(completed2).to.beTruthy();
+	});
+});
+
+describe(@"-flatten:", ^{
+	__block BOOL subscribedTo1 = NO;
+	__block BOOL subscribedTo2 = NO;
+	__block BOOL subscribedTo3 = NO;
+	__block RACSignal *sub1;
+	__block RACSignal *sub2;
+	__block RACSignal *sub3;
+	__block RACSubject *subject1;
+	__block RACSubject *subject2;
+	__block RACSubject *subject3;
+	__block RACSubject *signalsSubject;
+	__block NSMutableArray *values;
+	
+	beforeEach(^{
+		subscribedTo1 = NO;
+		subject1 = [RACSubject subject];
+		sub1 = [RACSignal defer:^{
+			subscribedTo1 = YES;
+			return subject1;
+		}];
+
+		subscribedTo2 = NO;
+		subject2 = [RACSubject subject];
+		sub2 = [RACSignal defer:^{
+			subscribedTo2 = YES;
+			return subject2;
+		}];
+
+		subscribedTo3 = NO;
+		subject3 = [RACSubject subject];
+		sub3 = [RACSignal defer:^{
+			subscribedTo3 = YES;
+			return subject3;
+		}];
+
+		signalsSubject = [RACSubject subject];
+
+		values = [NSMutableArray array];
+	});
+
+	describe(@"when its max is 0", ^{
+		it(@"should merge all the signals concurrently", ^{
+			[[signalsSubject flatten:0] subscribeNext:^(id x) {
+				[values addObject:x];
+			}];
+
+			expect(subscribedTo1).to.beFalsy();
+			expect(subscribedTo2).to.beFalsy();
+			expect(subscribedTo3).to.beFalsy();
+
+			[signalsSubject sendNext:sub1];
+			[signalsSubject sendNext:sub2];
+
+			expect(subscribedTo1).to.beTruthy();
+			expect(subscribedTo2).to.beTruthy();
+			expect(subscribedTo3).to.beFalsy();
+
+			[subject1 sendNext:@1];
+
+			[signalsSubject sendNext:sub3];
+			
+			expect(subscribedTo1).to.beTruthy();
+			expect(subscribedTo2).to.beTruthy();
+			expect(subscribedTo3).to.beTruthy();
+
+			[subject1 sendCompleted];
+
+			[subject2 sendNext:@2];
+			[subject2 sendCompleted];
+
+			[subject3 sendNext:@3];
+			[subject3 sendCompleted];
+
+			NSArray *expected = @[ @1, @2, @3 ];
+			expect(values).to.equal(expected);
+		});
+
+		itShouldBehaveLike(RACSignalMergeConcurrentCompletionExampleGroup, @{ RACSignalMaxConcurrent: @0 });
+	});
+
+	describe(@"when its max is > 0", ^{
+		it(@"should merge only the given number at a time", ^{
+			[[signalsSubject flatten:1] subscribeNext:^(id x) {
+				[values addObject:x];
+			}];
+
+			expect(subscribedTo1).to.beFalsy();
+			expect(subscribedTo2).to.beFalsy();
+			expect(subscribedTo3).to.beFalsy();
+
+			[signalsSubject sendNext:sub1];
+			[signalsSubject sendNext:sub2];
+
+			expect(subscribedTo1).to.beTruthy();
+			expect(subscribedTo2).to.beFalsy();
+			expect(subscribedTo3).to.beFalsy();
+
+			[subject1 sendNext:@1];
+
+			[signalsSubject sendNext:sub3];
+
+			expect(subscribedTo1).to.beTruthy();
+			expect(subscribedTo2).to.beFalsy();
+			expect(subscribedTo3).to.beFalsy();
+
+			[signalsSubject sendCompleted];
+
+			expect(subscribedTo1).to.beTruthy();
+			expect(subscribedTo2).to.beFalsy();
+			expect(subscribedTo3).to.beFalsy();
+
+			[subject1 sendCompleted];
+
+			expect(subscribedTo2).to.beTruthy();
+			expect(subscribedTo3).to.beFalsy();
+
+			[subject2 sendNext:@2];
+			[subject2 sendCompleted];
+
+			expect(subscribedTo3).to.beTruthy();
+
+			[subject3 sendNext:@3];
+			[subject3 sendCompleted];
+
+			NSArray *expected = @[ @1, @2, @3 ];
+			expect(values).to.equal(expected);
+		});
+
+		itShouldBehaveLike(RACSignalMergeConcurrentCompletionExampleGroup, @{ RACSignalMaxConcurrent: @1 });
+	});
+
+	it(@"shouldn't create a retain cycle", ^{
+		__block BOOL subjectDeallocd = NO;
+		__block BOOL signalDeallocd = NO;
+		@autoreleasepool {
+			RACSubject *subject __attribute__((objc_precise_lifetime)) = [RACSubject subject];
+			[subject.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				subjectDeallocd = YES;
+			}]];
+
+			RACSignal *signal __attribute__((objc_precise_lifetime)) = [subject flatten];
+			[signal.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+				signalDeallocd = YES;
+			}]];
+
+			[signal subscribeCompleted:^{}];
+
+			[subject sendCompleted];
+		}
+
+		expect(subjectDeallocd).will.beTruthy();
+		expect(signalDeallocd).will.beTruthy();
+	});
+
+	it(@"should not crash when disposing while subscribing", ^{
+		RACDisposable *disposable = [[signalsSubject flatten:0] subscribeCompleted:^{
+		}];
+
+		[signalsSubject sendNext:[RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) {
+			[disposable dispose];
+			[subscriber sendCompleted];
+			return nil;
+		}]];
+
+		[signalsSubject sendCompleted];
+	});
+
+	it(@"should dispose after last synchronous signal subscription and should not crash", ^{
+
+		RACSignal *flattened = [signalsSubject flatten:1];
+		RACDisposable *flattenDisposable = [flattened subscribeCompleted:^{}];
+
+		RACSignal *syncSignal = [RACSignal createSignal:^ RACDisposable *(id<RACSubscriber> subscriber) {
+			expect(flattenDisposable.disposed).to.beFalsy();
+			[subscriber sendCompleted];
+			expect(flattenDisposable.disposed).to.beTruthy();
+			return nil;
+		}];
+
+		RACSignal *asyncSignal = [sub1 delay:0];
+
+		[signalsSubject sendNext:asyncSignal];
+		[signalsSubject sendNext:syncSignal];
+
+		[signalsSubject sendCompleted];
+
+		[subject1 sendCompleted];
+
+		expect(flattenDisposable.disposed).will.beTruthy();
+	});
+
+	it(@"should not crash when disposed because of takeUntil:", ^{
+		for (int i = 0; i < 100; i++) {
+			RACSubject *flattenedReceiver = [RACSubject subject];
+			RACSignal *done = [flattenedReceiver map:^(NSNumber *n) {
+				return @(n.integerValue == 1);
+			}];
+
+			RACSignal *flattened = [signalsSubject flatten:1];
+
+			RACDisposable *flattenDisposable = [[flattened takeUntil:[done ignore:@NO]] subscribe:flattenedReceiver];
+
+			RACSignal *syncSignal = [RACSignal createSignal:^ RACDisposable *(id<RACSubscriber> subscriber) {
+				expect(flattenDisposable.disposed).to.beFalsy();
+				[subscriber sendNext:@1];
+				expect(flattenDisposable.disposed).to.beTruthy();
+				[subscriber sendCompleted];
+				return nil;
+			}];
+
+			RACSignal *asyncSignal = [sub1 delay:0];
+			[subject1 sendNext:@0];
+
+			[signalsSubject sendNext:asyncSignal];
+			[signalsSubject sendNext:syncSignal];
+			[signalsSubject sendCompleted];
+
+			[subject1 sendCompleted];
+
+			expect(flattenDisposable.disposed).will.beTruthy();
+		}
+	});
+});
+
+describe(@"-switchToLatest", ^{
+	__block RACSubject *subject;
+
+	__block NSMutableArray *values;
+	__block NSError *lastError = nil;
+	__block BOOL completed = NO;
+
+	beforeEach(^{
+		subject = [RACSubject subject];
+
+		values = [NSMutableArray array];
+		lastError = nil;
+		completed = NO;
+
+		[[subject switchToLatest] subscribeNext:^(id x) {
+			expect(lastError).to.beNil();
+			expect(completed).to.beFalsy();
+
+			[values addObject:x];
+		} error:^(NSError *error) {
+			expect(lastError).to.beNil();
+			expect(completed).to.beFalsy();
+
+			lastError = error;
+		} completed:^{
+			expect(lastError).to.beNil();
+			expect(completed).to.beFalsy();
+
+			completed = YES;
+		}];
+	});
+
+	it(@"should send values from the most recent signal", ^{
+		[subject sendNext:[RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) {
+			[subscriber sendNext:@1];
+			[subscriber sendNext:@2];
+			return nil;
+		}]];
+
+		[subject sendNext:[RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) {
+			[subscriber sendNext:@3];
+			[subscriber sendNext:@4];
+			return nil;
+		}]];
+
+		NSArray *expected = @[ @1, @2, @3, @4 ];
+		expect(values).to.equal(expected);
+	});
+
+	it(@"should send errors from the most recent signal", ^{
+		[subject sendNext:[RACSignal createSignal:^ id (id<RACSubscriber> subscriber) {
+			[subscriber sendError:[NSError errorWithDomain:@"" code:-1 userInfo:nil]];
+			return nil;
+		}]];
+
+		expect(lastError).notTo.beNil();
+	});
+
+	it(@"should not send completed if only the switching signal completes", ^{
+		[subject sendNext:RACSignal.never];
+
+		expect(completed).to.beFalsy();
+
+		[subject sendCompleted];
+		expect(completed).to.beFalsy();
+	});
+	
+	it(@"should send completed when the switching signal completes and the last sent signal does", ^{
+		[subject sendNext:RACSignal.empty];
+		
+		expect(completed).to.beFalsy();
+		
+		[subject sendCompleted];
+		expect(completed).to.beTruthy();
+	});
+
+	it(@"should accept nil signals", ^{
+		[subject sendNext:nil];
+		[subject sendNext:[RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) {
+			[subscriber sendNext:@1];
+			[subscriber sendNext:@2];
+			return nil;
+		}]];
+
+		NSArray *expected = @[ @1, @2 ];
+		expect(values).to.equal(expected);
+	});
+
+	it(@"should return a cold signal", ^{
+		__block NSUInteger subscriptions = 0;
+		RACSignal *signalOfSignals = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) {
+			subscriptions++;
+			[subscriber sendNext:[RACSignal empty]];
+			return nil;
+		}];
+
+		RACSignal *switched = [signalOfSignals switchToLatest];
+
+		[[switched publish] connect];
+		expect(subscriptions).to.equal(1);
+
+		[[switched publish] connect];
+		expect(subscriptions).to.equal(2);
+	});
+});
+
+describe(@"+switch:cases:default:", ^{
+	__block RACSubject *keySubject;
+
+	__block RACSubject *subjectZero;
+	__block RACSubject *subjectOne;
+	__block RACSubject *subjectTwo;
+
+	__block RACSubject *defaultSubject;
+
+	__block NSMutableArray *values;
+	__block NSError *lastError = nil;
+	__block BOOL completed = NO;
+
+	beforeEach(^{
+		keySubject = [RACSubject subject];
+
+		subjectZero = [RACSubject subject];
+		subjectOne = [RACSubject subject];
+		subjectTwo = [RACSubject subject];
+
+		defaultSubject = [RACSubject subject];
+
+		values = [NSMutableArray array];
+		lastError = nil;
+		completed = NO;
+	});
+
+	describe(@"switching between values with a default", ^{
+		__block RACSignal *switchSignal;
+
+		beforeEach(^{
+			switchSignal = [RACSignal switch:keySubject cases:@{
+				@0: subjectZero,
+				@1: subjectOne,
+				@2: subjectTwo,
+			} default:[RACSignal never]];
+
+			[switchSignal subscribeNext:^(id x) {
+				expect(lastError).to.beNil();
+				expect(completed).to.beFalsy();
+
+				[values addObject:x];
+			} error:^(NSError *error) {
+				expect(lastError).to.beNil();
+				expect(completed).to.beFalsy();
+
+				lastError = error;
+			} completed:^{
+				expect(lastError).to.beNil();
+				expect(completed).to.beFalsy();
+
+				completed = YES;
+			}];
+		});
+
+		it(@"should not send any values before a key is sent", ^{
+			[subjectZero sendNext:RACUnit.defaultUnit];
+			[subjectOne sendNext:RACUnit.defaultUnit];
+			[subjectTwo sendNext:RACUnit.defaultUnit];
+
+			expect(values).to.equal(@[]);
+			expect(lastError).to.beNil();
+			expect(completed).to.beFalsy();
+		});
+
+		it(@"should send events based on the latest key", ^{
+			[keySubject sendNext:@0];
+
+			[subjectZero sendNext:@"zero"];
+			[subjectZero sendNext:@"zero"];
+			[subjectOne sendNext:@"one"];
+			[subjectTwo sendNext:@"two"];
+
+			NSArray *expected = @[ @"zero", @"zero" ];
+			expect(values).to.equal(expected);
+
+			[keySubject sendNext:@1];
+
+			[subjectZero sendNext:@"zero"];
+			[subjectOne sendNext:@"one"];
+			[subjectTwo sendNext:@"two"];
+
+			expected = @[ @"zero", @"zero", @"one" ];
+			expect(values).to.equal(expected);
+
+			expect(lastError).to.beNil();
+			expect(completed).to.beFalsy();
+
+			[keySubject sendNext:@2];
+
+			[subjectZero sendError:[NSError errorWithDomain:@"" code:-1 userInfo:nil]];
+			[subjectOne sendError:[NSError errorWithDomain:@"" code:-1 userInfo:nil]];
+			expect(lastError).to.beNil();
+
+			[subjectTwo sendError:[NSError errorWithDomain:@"" code:-1 userInfo:nil]];
+			expect(lastError).notTo.beNil();
+		});
+
+		it(@"should not send completed when only the key signal completes", ^{
+			[keySubject sendNext:@0];
+			[subjectZero sendNext:@"zero"];
+			[keySubject sendCompleted];
+
+			expect(values).to.equal(@[ @"zero" ]);
+			expect(completed).to.beFalsy();
+		});
+
+		it(@"should send completed when the key signal and the latest sent signal complete", ^{
+			[keySubject sendNext:@0];
+			[subjectZero sendNext:@"zero"];
+			[keySubject sendCompleted];
+			[subjectZero sendCompleted];
+
+			expect(values).to.equal(@[ @"zero" ]);
+			expect(completed).to.beTruthy();
+		});
+	});
+
+	it(@"should use the default signal if key that was sent does not have an associated signal", ^{
+		[[RACSignal
+			switch:keySubject
+			cases:@{
+				@0: subjectZero,
+				@1: subjectOne,
+			}
+			default:defaultSubject]
+			subscribeNext:^(id x) {
+				[values addObject:x];
+			}];
+
+		[keySubject sendNext:@"not a valid key"];
+		[defaultSubject sendNext:@"default"];
+
+		expect(values).to.equal(@[ @"default" ]);
+
+		[keySubject sendNext:nil];
+		[defaultSubject sendNext:@"default"];
+
+		expect(values).to.equal((@[ @"default", @"default" ]));
+	});
+
+	it(@"should send an error if key that was sent does not have an associated signal and there's no default", ^{
+		[[RACSignal
+			switch:keySubject
+			cases:@{
+				@0: subjectZero,
+				@1: subjectOne,
+			}
+			default:nil]
+			subscribeNext:^(id x) {
+				[values addObject:x];
+			} error:^(NSError *error) {
+				lastError = error;
+			}];
+
+		[keySubject sendNext:@0];
+		[subjectZero sendNext:@"zero"];
+
+		expect(values).to.equal(@[ @"zero" ]);
+		expect(lastError).to.beNil();
+
+		[keySubject sendNext:nil];
+
+		expect(values).to.equal(@[ @"zero" ]);
+		expect(lastError).notTo.beNil();
+		expect(lastError.domain).to.equal(RACSignalErrorDomain);
+		expect(lastError.code).to.equal(RACSignalErrorNoMatchingCase);
+	});
+
+	it(@"should match RACTupleNil case when a nil value is sent", ^{
+		[[RACSignal
+			switch:keySubject
+			cases:@{
+				RACTupleNil.tupleNil: subjectZero,
+			}
+			default:defaultSubject]
+			subscribeNext:^(id x) {
+				[values addObject:x];
+			}];
+
+		[keySubject sendNext:nil];
+		[subjectZero sendNext:@"zero"];
+		expect(values).to.equal(@[ @"zero" ]);
+	});
+});
+
+describe(@"+if:then:else", ^{
+	__block RACSubject *boolSubject;
+	__block RACSubject *trueSubject;
+	__block RACSubject *falseSubject;
+
+	__block NSMutableArray *values;
+	__block NSError *lastError = nil;
+	__block BOOL completed = NO;
+
+	beforeEach(^{
+		boolSubject = [RACSubject subject];
+		trueSubject = [RACSubject subject];
+		falseSubject = [RACSubject subject];
+
+		values = [NSMutableArray array];
+		lastError = nil;
+		completed = NO;
+
+		[[RACSignal if:boolSubject then:trueSubject else:falseSubject] subscribeNext:^(id x) {
+			expect(lastError).to.beNil();
+			expect(completed).to.beFalsy();
+
+			[values addObject:x];
+		} error:^(NSError *error) {
+			expect(lastError).to.beNil();
+			expect(completed).to.beFalsy();
+
+			lastError = error;
+		} completed:^{
+			expect(lastError).to.beNil();
+			expect(completed).to.beFalsy();
+
+			completed = YES;
+		}];
+	});
+
+	it(@"should not send any values before a boolean is sent", ^{
+		[trueSubject sendNext:RACUnit.defaultUnit];
+		[falseSubject sendNext:RACUnit.defaultUnit];
+
+		expect(values).to.equal(@[]);
+		expect(lastError).to.beNil();
+		expect(completed).to.beFalsy();
+	});
+
+	it(@"should send events based on the latest boolean", ^{
+		[boolSubject sendNext:@YES];
+
+		[trueSubject sendNext:@"foo"];
+		[falseSubject sendNext:@"buzz"];
+		[trueSubject sendNext:@"bar"];
+
+		NSArray *expected = @[ @"foo", @"bar" ];
+		expect(values).to.equal(expected);
+		expect(lastError).to.beNil();
+		expect(completed).to.beFalsy();
+
+		[boolSubject sendNext:@NO];
+
+		[trueSubject sendNext:@"baz"];
+		[falseSubject sendNext:@"buzz"];
+		[trueSubject sendNext:@"barfoo"];
+
+		expected = @[ @"foo", @"bar", @"buzz" ];
+		expect(values).to.equal(expected);
+		expect(lastError).to.beNil();
+		expect(completed).to.beFalsy();
+
+		[trueSubject sendError:[NSError errorWithDomain:@"" code:-1 userInfo:nil]];
+		expect(lastError).to.beNil();
+
+		[falseSubject sendError:[NSError errorWithDomain:@"" code:-1 userInfo:nil]];
+		expect(lastError).notTo.beNil();
+	});
+
+	it(@"should not send completed when only the BOOL signal completes", ^{
+		[boolSubject sendNext:@YES];
+		[trueSubject sendNext:@"foo"];
+		[boolSubject sendCompleted];
+		
+		expect(values).to.equal(@[ @"foo" ]);
+		expect(completed).to.beFalsy();
+	});
+
+	it(@"should send completed when the BOOL signal and the latest sent signal complete", ^{
+		[boolSubject sendNext:@YES];
+		[trueSubject sendNext:@"foo"];
+		[trueSubject sendCompleted];
+		[boolSubject sendCompleted];
+
+		expect(values).to.equal(@[ @"foo" ]);
+		expect(completed).to.beTruthy();
+	});
+});
+
+describe(@"+interval:onScheduler: and +interval:onScheduler:withLeeway:", ^{
+	static const NSTimeInterval interval = 0.1;
+	static const NSTimeInterval leeway = 0.2;
+	
+	__block void (^testTimer)(RACSignal *, NSNumber *, NSNumber *) = nil;
+	
+	before(^{
+		testTimer = [^(RACSignal *timer, NSNumber *minInterval, NSNumber *leeway) {
+			__block NSUInteger nextsReceived = 0;
+
+			NSTimeInterval startTime = NSDate.timeIntervalSinceReferenceDate;
+			[[timer take:3] subscribeNext:^(NSDate *date) {
+				++nextsReceived;
+
+				NSTimeInterval currentTime = date.timeIntervalSinceReferenceDate;
+
+				// Uniformly distribute the expected interval for all
+				// received values. We do this instead of saving a timestamp
+				// because a delayed interval may cause the _next_ value to
+				// send sooner than the interval.
+				NSTimeInterval expectedMinInterval = minInterval.doubleValue * nextsReceived;
+				NSTimeInterval expectedMaxInterval = expectedMinInterval + leeway.doubleValue * 3 + 0.05;
+
+				expect(currentTime - startTime).beGreaterThanOrEqualTo(expectedMinInterval);
+				expect(currentTime - startTime).beLessThanOrEqualTo(expectedMaxInterval);
+			}];
+			
+			expect(nextsReceived).will.equal(3);
+		} copy];
+	});
+	
+	describe(@"+interval:onScheduler:", ^{
+		it(@"should work on the main thread scheduler", ^{
+			testTimer([RACSignal interval:interval onScheduler:RACScheduler.mainThreadScheduler], @(interval), @0);
+		});
+		
+		it(@"should work on a background scheduler", ^{
+			testTimer([RACSignal interval:interval onScheduler:[RACScheduler scheduler]], @(interval), @0);
+		});
+	});
+	
+	describe(@"+interval:onScheduler:withLeeway:", ^{
+		it(@"should work on the main thread scheduler", ^{
+			testTimer([RACSignal interval:interval onScheduler:RACScheduler.mainThreadScheduler withLeeway:leeway], @(interval), @(leeway));
+		});
+		
+		it(@"should work on a background scheduler", ^{
+			testTimer([RACSignal interval:interval onScheduler:[RACScheduler scheduler] withLeeway:leeway], @(interval), @(leeway));
+		});
+	});
+});
+
+describe(@"-timeout:onScheduler:", ^{
+	__block RACSubject *subject;
+
+	beforeEach(^{
+		subject = [RACSubject subject];
+	});
+
+	it(@"should time out", ^{
+		RACTestScheduler *scheduler = [[RACTestScheduler alloc] init];
+
+		__block NSError *receivedError = nil;
+		[[subject timeout:1 onScheduler:scheduler] subscribeError:^(NSError *e) {
+			receivedError = e;
+		}];
+
+		expect(receivedError).to.beNil();
+
+		[scheduler stepAll];
+		expect(receivedError).willNot.beNil();
+		expect(receivedError.domain).to.equal(RACSignalErrorDomain);
+		expect(receivedError.code).to.equal(RACSignalErrorTimedOut);
+	});
+
+	it(@"should pass through events while not timed out", ^{
+		__block id next = nil;
+		__block BOOL completed = NO;
+		[[subject timeout:1 onScheduler:RACScheduler.mainThreadScheduler] subscribeNext:^(id x) {
+			next = x;
+		} completed:^{
+			completed = YES;
+		}];
+
+		[subject sendNext:RACUnit.defaultUnit];
+		expect(next).to.equal(RACUnit.defaultUnit);
+
+		[subject sendCompleted];
+		expect(completed).to.beTruthy();
+	});
+
+	it(@"should not time out after disposal", ^{
+		RACTestScheduler *scheduler = [[RACTestScheduler alloc] init];
+
+		__block NSError *receivedError = nil;
+		RACDisposable *disposable = [[subject timeout:1 onScheduler:scheduler] subscribeError:^(NSError *e) {
+			receivedError = e;
+		}];
+
+		[disposable dispose];
+		[scheduler stepAll];
+		expect(receivedError).to.beNil();
+	});
+});
+
+describe(@"-delay:", ^{
+	__block RACSubject *subject;
+	__block RACSignal *delayedSignal;
+
+	beforeEach(^{
+		subject = [RACSubject subject];
+		delayedSignal = [subject delay:0];
+	});
+
+	it(@"should delay nexts", ^{
+		__block id next = nil;
+		[delayedSignal subscribeNext:^(id x) {
+			next = x;
+		}];
+
+		[subject sendNext:@"foo"];
+		expect(next).to.beNil();
+		expect(next).will.equal(@"foo");
+	});
+
+	it(@"should delay completed", ^{
+		__block BOOL completed = NO;
+		[delayedSignal subscribeCompleted:^{
+			completed = YES;
+		}];
+
+		[subject sendCompleted];
+		expect(completed).to.beFalsy();
+		expect(completed).will.beTruthy();
+	});
+
+	it(@"should not delay errors", ^{
+		__block NSError *error = nil;
+		[delayedSignal subscribeError:^(NSError *e) {
+			error = e;
+		}];
+
+		[subject sendError:RACSignalTestError];
+		expect(error).to.equal(RACSignalTestError);
+	});
+
+	it(@"should cancel delayed events when disposed", ^{
+		__block id next = nil;
+		RACDisposable *disposable = [delayedSignal subscribeNext:^(id x) {
+			next = x;
+		}];
+
+		[subject sendNext:@"foo"];
+
+		__block BOOL done = NO;
+		[RACScheduler.mainThreadScheduler after:[NSDate date] schedule:^{
+			done = YES;
+		}];
+
+		[disposable dispose];
+
+		expect(done).will.beTruthy();
+		expect(next).to.beNil();
+	});
+});
+
+describe(@"-catch:", ^{
+	it(@"should subscribe to ensuing signal on error", ^{
+		RACSubject *subject = [RACSubject subject];
+
+		RACSignal *signal = [subject catch:^(NSError *error) {
+			return [RACSignal return:@41];
+		}];
+
+		__block id value = nil;
+		[signal subscribeNext:^(id x) {
+			value = x;
+		}];
+
+		[subject sendError:RACSignalTestError];
+		expect(value).to.equal(@41);
+	});
+
+	it(@"should prevent source error from propagating", ^{
+		RACSubject *subject = [RACSubject subject];
+
+		RACSignal *signal = [subject catch:^(NSError *error) {
+			return [RACSignal empty];
+		}];
+
+		__block BOOL errorReceived = NO;
+		[signal subscribeError:^(NSError *error) {
+			errorReceived = YES;
+		}];
+
+		[subject sendError:RACSignalTestError];
+		expect(errorReceived).to.beFalsy();
+	});
+
+	it(@"should propagate error from ensuing signal", ^{
+		RACSubject *subject = [RACSubject subject];
+
+		NSError *secondaryError = [NSError errorWithDomain:@"bubs" code:41 userInfo:nil];
+		RACSignal *signal = [subject catch:^(NSError *error) {
+			return [RACSignal error:secondaryError];
+		}];
+
+		__block NSError *errorReceived = nil;
+		[signal subscribeError:^(NSError *error) {
+			errorReceived = error;
+		}];
+
+		[subject sendError:RACSignalTestError];
+		expect(errorReceived).to.equal(secondaryError);
+	});
+
+	it(@"should dispose ensuing signal", ^{
+		RACSubject *subject = [RACSubject subject];
+
+		__block BOOL disposed = NO;
+		RACSignal *signal = [subject catch:^(NSError *error) {
+			return [RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+				return [RACDisposable disposableWithBlock:^{
+					disposed = YES;
+				}];
+			}];
+		}];
+
+		RACDisposable *disposable = [signal subscribeCompleted:^{}];
+		[subject sendError:RACSignalTestError];
+		[disposable dispose];
+
+		expect(disposed).will.beTruthy();
+	});
+});
+
+describe(@"-try:", ^{
+	__block RACSubject *subject;
+	__block NSError *receivedError;
+	__block NSMutableArray *nextValues;
+	__block BOOL completed;
+	
+	beforeEach(^{
+		subject = [RACSubject subject];
+		nextValues = [NSMutableArray array];
+		completed = NO;
+		receivedError = nil;
+		
+		[[subject try:^(NSString *value, NSError **error) {
+			if (value != nil) return YES;
+			
+			if (error != nil) *error = RACSignalTestError;
+			
+			return NO;
+		}] subscribeNext:^(id x) {
+			[nextValues addObject:x];
+		} error:^(NSError *error) {
+			receivedError = error;
+		} completed:^{
+			completed = YES;
+		}];
+	});
+	
+	it(@"should pass values while YES is returned from the tryBlock", ^{
+		[subject sendNext:@"foo"];
+		[subject sendNext:@"bar"];
+		[subject sendNext:@"baz"];
+		[subject sendNext:@"buzz"];
+		[subject sendCompleted];
+		
+		NSArray *receivedValues = [nextValues copy];
+		NSArray *expectedValues = @[ @"foo", @"bar", @"baz", @"buzz" ];
+		
+		expect(receivedError).to.beNil();
+		expect(receivedValues).to.equal(expectedValues);
+		expect(completed).to.beTruthy();
+	});
+	
+	it(@"should pass values until NO is returned from the tryBlock", ^{
+		[subject sendNext:@"foo"];
+		[subject sendNext:@"bar"];
+		[subject sendNext:nil];
+		[subject sendNext:@"buzz"];
+		[subject sendCompleted];
+		
+		NSArray *receivedValues = [nextValues copy];
+		NSArray *expectedValues = @[ @"foo", @"bar" ];
+		
+		expect(receivedError).to.equal(RACSignalTestError);
+		expect(receivedValues).to.equal(expectedValues);
+		expect(completed).to.beFalsy();
+	});
+});
+
+describe(@"-tryMap:", ^{
+	__block RACSubject *subject;
+	__block NSError *receivedError;
+	__block NSMutableArray *nextValues;
+	__block BOOL completed;
+	
+	beforeEach(^{
+		subject = [RACSubject subject];
+		nextValues = [NSMutableArray array];
+		completed = NO;
+		receivedError = nil;
+		
+		[[subject tryMap:^ id (NSString *value, NSError **error) {
+			if (value != nil) return [NSString stringWithFormat:@"%@_a", value];
+			
+			if (error != nil) *error = RACSignalTestError;
+
+			return nil;
+		}] subscribeNext:^(id x) {
+			[nextValues addObject:x];
+		} error:^(NSError *error) {
+			receivedError = error;
+		} completed:^{
+			completed = YES;
+		}];
+	});
+	
+	it(@"should map values with the mapBlock", ^{
+		[subject sendNext:@"foo"];
+		[subject sendNext:@"bar"];
+		[subject sendNext:@"baz"];
+		[subject sendNext:@"buzz"];
+		[subject sendCompleted];
+
+		NSArray *receivedValues = [nextValues copy];
+		NSArray *expectedValues = @[ @"foo_a", @"bar_a", @"baz_a", @"buzz_a" ];
+		
+		expect(receivedError).to.beNil();
+		expect(receivedValues).to.equal(expectedValues);
+		expect(completed).to.beTruthy();
+	});
+	
+	it(@"should map values with the mapBlock, until the mapBlock returns nil", ^{
+		[subject sendNext:@"foo"];
+		[subject sendNext:@"bar"];
+		[subject sendNext:nil];
+		[subject sendNext:@"buzz"];
+		[subject sendCompleted];
+		
+		NSArray *receivedValues = [nextValues copy];
+		NSArray *expectedValues = @[ @"foo_a", @"bar_a" ];
+		
+		expect(receivedError).to.equal(RACSignalTestError);
+		expect(receivedValues).to.equal(expectedValues);
+		expect(completed).to.beFalsy();
+	});
+});
+
+describe(@"throttling", ^{
+	__block RACSubject *subject;
+
+	beforeEach(^{
+		subject = [RACSubject subject];
+	});
+
+	describe(@"-throttle:", ^{
+		__block RACSignal *throttledSignal;
+
+		beforeEach(^{
+			throttledSignal = [subject throttle:0];
+		});
+
+		it(@"should throttle nexts", ^{
+			NSMutableArray *valuesReceived = [NSMutableArray array];
+			[throttledSignal subscribeNext:^(id x) {
+				[valuesReceived addObject:x];
+			}];
+
+			[subject sendNext:@"foo"];
+			[subject sendNext:@"bar"];
+			expect(valuesReceived).to.equal(@[]);
+
+			NSArray *expected = @[ @"bar" ];
+			expect(valuesReceived).will.equal(expected);
+
+			[subject sendNext:@"buzz"];
+			expect(valuesReceived).to.equal(expected);
+
+			expected = @[ @"bar", @"buzz" ];
+			expect(valuesReceived).will.equal(expected);
+		});
+
+		it(@"should forward completed immediately", ^{
+			__block BOOL completed = NO;
+			[throttledSignal subscribeCompleted:^{
+				completed = YES;
+			}];
+
+			[subject sendCompleted];
+			expect(completed).to.beTruthy();
+		});
+
+		it(@"should forward errors immediately", ^{
+			__block NSError *error = nil;
+			[throttledSignal subscribeError:^(NSError *e) {
+				error = e;
+			}];
+
+			[subject sendError:RACSignalTestError];
+			expect(error).to.equal(RACSignalTestError);
+		});
+
+		it(@"should cancel future nexts when disposed", ^{
+			__block id next = nil;
+			RACDisposable *disposable = [throttledSignal subscribeNext:^(id x) {
+				next = x;
+			}];
+
+			[subject sendNext:@"foo"];
+
+			__block BOOL done = NO;
+			[RACScheduler.mainThreadScheduler after:[NSDate date] schedule:^{
+				done = YES;
+			}];
+
+			[disposable dispose];
+
+			expect(done).will.beTruthy();
+			expect(next).to.beNil();
+		});
+	});
+
+	describe(@"-throttle:valuesPassingTest:", ^{
+		__block RACSignal *throttledSignal;
+		__block BOOL shouldThrottle;
+
+		beforeEach(^{
+			shouldThrottle = YES;
+
+			__block id value = nil;
+			throttledSignal = [[subject
+				doNext:^(id x) {
+					value = x;
+				}]
+				throttle:0 valuesPassingTest:^(id x) {
+					// Make sure that we're given the latest value.
+					expect(x).to.beIdenticalTo(value);
+
+					return shouldThrottle;
+				}];
+
+			expect(throttledSignal).notTo.beNil();
+		});
+
+		describe(@"nexts", ^{
+			__block NSMutableArray *valuesReceived;
+			__block NSMutableArray *expected;
+
+			beforeEach(^{
+				expected = [[NSMutableArray alloc] init];
+				valuesReceived = [[NSMutableArray alloc] init];
+
+				[throttledSignal subscribeNext:^(id x) {
+					[valuesReceived addObject:x];
+				}];
+			});
+
+			it(@"should forward unthrottled values immediately", ^{
+				shouldThrottle = NO;
+				[subject sendNext:@"foo"];
+
+				[expected addObject:@"foo"];
+				expect(valuesReceived).to.equal(expected);
+			});
+
+			it(@"should delay throttled values", ^{
+				[subject sendNext:@"bar"];
+				expect(valuesReceived).to.equal(expected);
+
+				[expected addObject:@"bar"];
+				expect(valuesReceived).will.equal(expected);
+			});
+
+			it(@"should drop buffered values when a throttled value arrives", ^{
+				[subject sendNext:@"foo"];
+				[subject sendNext:@"bar"];
+				[subject sendNext:@"buzz"];
+				expect(valuesReceived).to.equal(expected);
+
+				[expected addObject:@"buzz"];
+				expect(valuesReceived).will.equal(expected);
+			});
+
+			it(@"should drop buffered values when an immediate value arrives", ^{
+				[subject sendNext:@"foo"];
+				[subject sendNext:@"bar"];
+
+				shouldThrottle = NO;
+				[subject sendNext:@"buzz"];
+				[expected addObject:@"buzz"];
+				expect(valuesReceived).to.equal(expected);
+
+				// Make sure that nothing weird happens when sending another
+				// throttled value.
+				shouldThrottle = YES;
+				[subject sendNext:@"baz"];
+				expect(valuesReceived).to.equal(expected);
+
+				[expected addObject:@"baz"];
+				expect(valuesReceived).will.equal(expected);
+			});
+
+			it(@"should not be resent upon completion", ^{
+				[subject sendNext:@"bar"];
+				[expected addObject:@"bar"];
+				expect(valuesReceived).will.equal(expected);
+
+				[subject sendCompleted];
+				expect(valuesReceived).to.equal(expected);
+			});
+		});
+
+		it(@"should forward completed immediately", ^{
+			__block BOOL completed = NO;
+			[throttledSignal subscribeCompleted:^{
+				completed = YES;
+			}];
+
+			[subject sendCompleted];
+			expect(completed).to.beTruthy();
+		});
+
+		it(@"should forward errors immediately", ^{
+			__block NSError *error = nil;
+			[throttledSignal subscribeError:^(NSError *e) {
+				error = e;
+			}];
+
+			[subject sendError:RACSignalTestError];
+			expect(error).to.equal(RACSignalTestError);
+		});
+
+		it(@"should cancel future nexts when disposed", ^{
+			__block id next = nil;
+			RACDisposable *disposable = [throttledSignal subscribeNext:^(id x) {
+				next = x;
+			}];
+
+			[subject sendNext:@"foo"];
+
+			__block BOOL done = NO;
+			[RACScheduler.mainThreadScheduler after:[NSDate date] schedule:^{
+				done = YES;
+			}];
+
+			[disposable dispose];
+
+			expect(done).will.beTruthy();
+			expect(next).to.beNil();
+		});
+	});
+});
+
+describe(@"-then:", ^{
+	it(@"should continue onto returned signal", ^{
+		RACSubject *subject = [RACSubject subject];
+
+		__block id value = nil;
+		[[subject then:^{
+			return [RACSignal return:@2];
+		}] subscribeNext:^(id x) {
+			value = x;
+		}];
+
+		[subject sendNext:@1];
+
+		// The value shouldn't change until the first signal completes.
+		expect(value).to.beNil();
+
+		[subject sendCompleted];
+
+		expect(value).to.equal(@2);
+	});
+
+	it(@"should sequence even if no next value is sent", ^{
+		RACSubject *subject = [RACSubject subject];
+
+		__block id value = nil;
+		[[subject then:^{
+			return [RACSignal return:RACUnit.defaultUnit];
+		}] subscribeNext:^(id x) {
+			value = x;
+		}];
+
+		[subject sendCompleted];
+
+		expect(value).to.equal(RACUnit.defaultUnit);
+	});
+});
+
+describe(@"-sequence", ^{
+	RACSignal *signal = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) {
+		[subscriber sendNext:@1];
+		[subscriber sendNext:@2];
+		[subscriber sendNext:@3];
+		[subscriber sendNext:@4];
+		[subscriber sendCompleted];
+		return nil;
+	}];
+
+	itShouldBehaveLike(RACSequenceExamples, ^{
+		return @{
+			RACSequenceExampleSequence: signal.sequence,
+			RACSequenceExampleExpectedValues: @[ @1, @2, @3, @4 ]
+		};
+	});
+});
+
+it(@"should complete take: even if the original signal doesn't", ^{
+	RACSignal *sendOne = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) {
+		[subscriber sendNext:RACUnit.defaultUnit];
+		return nil;
+	}];
+
+	__block id value = nil;
+	__block BOOL completed = NO;
+	[[sendOne take:1] subscribeNext:^(id received) {
+		value = received;
+	} completed:^{
+		completed = YES;
+	}];
+
+	expect(value).to.equal(RACUnit.defaultUnit);
+	expect(completed).to.beTruthy();
+});
+
+describe(@"+zip:", ^{
+	__block RACSubject *subject1 = nil;
+	__block RACSubject *subject2 = nil;
+	__block BOOL hasSentError = NO;
+	__block BOOL hasSentCompleted = NO;
+	__block RACDisposable *disposable = nil;
+	__block void (^send2NextAndErrorTo1)(void) = nil;
+	__block void (^send3NextAndErrorTo1)(void) = nil;
+	__block void (^send2NextAndCompletedTo2)(void) = nil;
+	__block void (^send3NextAndCompletedTo2)(void) = nil;
+	
+	before(^{
+		send2NextAndErrorTo1 = [^{
+			[subject1 sendNext:@1];
+			[subject1 sendNext:@2];
+			[subject1 sendError:RACSignalTestError];
+		} copy];
+		send3NextAndErrorTo1 = [^{
+			[subject1 sendNext:@1];
+			[subject1 sendNext:@2];
+			[subject1 sendNext:@3];
+			[subject1 sendError:RACSignalTestError];
+		} copy];
+		send2NextAndCompletedTo2 = [^{
+			[subject2 sendNext:@1];
+			[subject2 sendNext:@2];
+			[subject2 sendCompleted];
+		} copy];
+		send3NextAndCompletedTo2 = [^{
+			[subject2 sendNext:@1];
+			[subject2 sendNext:@2];
+			[subject2 sendNext:@3];
+			[subject2 sendCompleted];
+		} copy];
+		subject1 = [RACSubject subject];
+		subject2 = [RACSubject subject];
+		hasSentError = NO;
+		hasSentCompleted = NO;
+		disposable = [[RACSignal zip:@[ subject1, subject2 ]] subscribeError:^(NSError *error) {
+			hasSentError = YES;
+		} completed:^{
+			hasSentCompleted = YES;
+		}];
+	});
+	
+	after(^{
+		[disposable dispose];
+	});
+	
+	it(@"should complete as soon as no new zipped values are possible", ^{
+		[subject1 sendNext:@1];
+		[subject2 sendNext:@1];
+		expect(hasSentCompleted).to.beFalsy();
+		
+		[subject1 sendNext:@2];
+		[subject1 sendCompleted];
+		expect(hasSentCompleted).to.beFalsy();
+		
+		[subject2 sendNext:@2];
+		expect(hasSentCompleted).to.beTruthy();
+	});
+	
+	it(@"outcome should not be dependent on order of signals", ^{
+		[subject2 sendCompleted];
+		expect(hasSentCompleted).to.beTruthy();
+	});
+    
+	it(@"should forward errors sent earlier than (time-wise) and before (position-wise) a complete", ^{
+		send2NextAndErrorTo1();
+		send3NextAndCompletedTo2();
+		expect(hasSentError).to.beTruthy();
+		expect(hasSentCompleted).to.beFalsy();
+	});
+	
+	it(@"should forward errors sent earlier than (time-wise) and after (position-wise) a complete", ^{
+		send3NextAndErrorTo1();
+		send2NextAndCompletedTo2();
+		expect(hasSentError).to.beTruthy();
+		expect(hasSentCompleted).to.beFalsy();
+	});
+	
+	it(@"should forward errors sent later than (time-wise) and before (position-wise) a complete", ^{
+		send3NextAndCompletedTo2();
+		send2NextAndErrorTo1();
+		expect(hasSentError).to.beTruthy();
+		expect(hasSentCompleted).to.beFalsy();
+	});
+	
+	it(@"should ignore errors sent later than (time-wise) and after (position-wise) a complete", ^{
+		send2NextAndCompletedTo2();
+		send3NextAndErrorTo1();
+		expect(hasSentError).to.beFalsy();
+		expect(hasSentCompleted).to.beTruthy();
+	});
+	
+	it(@"should handle signals sending values unevenly", ^{
+		__block NSError *receivedError = nil;
+		__block BOOL hasCompleted = NO;
+		
+		RACSubject *a = [RACSubject subject];
+		RACSubject *b = [RACSubject subject];
+		RACSubject *c = [RACSubject subject];
+		
+		NSMutableArray *receivedValues = NSMutableArray.array;
+		NSArray *expectedValues = nil;
+		
+		[[RACSignal zip:@[ a, b, c ] reduce:^(NSNumber *a, NSNumber *b, NSNumber *c) {
+			return [NSString stringWithFormat:@"%@%@%@", a, b, c];
+		}] subscribeNext:^(id x) {
+			[receivedValues addObject:x];
+		} error:^(NSError *error) {
+			receivedError = error;
+		} completed:^{
+			hasCompleted = YES;
+		}];
+		
+		[a sendNext:@1];
+		[a sendNext:@2];
+		[a sendNext:@3];
+		
+		[b sendNext:@1];
+		
+		[c sendNext:@1];
+		[c sendNext:@2];
+		
+		// a: [===......]
+		// b: [=........]
+		// c: [==.......]
+		
+		expectedValues = @[ @"111" ];
+		expect(receivedValues).to.equal(expectedValues);
+		expect(receivedError).to.beNil();
+		expect(hasCompleted).to.beFalsy();
+		
+		[b sendNext:@2];
+		[b sendNext:@3];
+		[b sendNext:@4];
+		[b sendCompleted];
+		
+		// a: [===......]
+		// b: [====C....]
+		// c: [==.......]
+		
+		expectedValues = @[ @"111", @"222" ];
+		expect(receivedValues).to.equal(expectedValues);
+		expect(receivedError).to.beNil();
+		expect(hasCompleted).to.beFalsy();
+		
+		[c sendNext:@3];
+		[c sendNext:@4];
+		[c sendNext:@5];
+		[c sendError:RACSignalTestError];
+		
+		// a: [===......]
+		// b: [====C....]
+		// c: [=====E...]
+		
+		expectedValues = @[ @"111", @"222", @"333" ];
+		expect(receivedValues).to.equal(expectedValues);
+		expect(receivedError).to.equal(RACSignalTestError);
+		expect(hasCompleted).to.beFalsy();
+		
+		[a sendNext:@4];
+		[a sendNext:@5];
+		[a sendNext:@6];
+		[a sendNext:@7];
+		
+		// a: [=======..]
+		// b: [====C....]
+		// c: [=====E...]
+		
+		expectedValues = @[ @"111", @"222", @"333" ];
+		expect(receivedValues).to.equal(expectedValues);
+		expect(receivedError).to.equal(RACSignalTestError);
+		expect(hasCompleted).to.beFalsy();
+	});
+	
+	it(@"should handle multiples of the same side-effecting signal", ^{
+		__block NSUInteger counter = 0;
+		RACSignal *sideEffectingSignal = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) {
+			++counter;
+			[subscriber sendNext:@1];
+			[subscriber sendCompleted];
+			return nil;
+		}];
+		RACSignal *combined = [RACSignal zip:@[ sideEffectingSignal, sideEffectingSignal ] reduce:^ NSString * (id x, id y) {
+			return [NSString stringWithFormat:@"%@%@", x, y];
+		}];
+		NSMutableArray *receivedValues = NSMutableArray.array;
+		
+		expect(counter).to.equal(0);
+		
+		[combined subscribeNext:^(id x) {
+			[receivedValues addObject:x];
+		}];
+		
+		expect(counter).to.equal(2);
+		expect(receivedValues).to.equal(@[ @"11" ]);
+	});
+});
+
+describe(@"-sample:", ^{
+	it(@"should send the latest value when the sampler signal fires", ^{
+		RACSubject *subject = [RACSubject subject];
+		RACSubject *sampleSubject = [RACSubject subject];
+		RACSignal *sampled = [subject sample:sampleSubject];
+		NSMutableArray *values = [NSMutableArray array];
+		[sampled subscribeNext:^(id x) {
+			[values addObject:x];
+		}];
+		
+		[sampleSubject sendNext:RACUnit.defaultUnit];
+		expect(values).to.equal(@[]);
+		
+		[subject sendNext:@1];
+		[subject sendNext:@2];
+		expect(values).to.equal(@[]);
+
+		[sampleSubject sendNext:RACUnit.defaultUnit];
+		NSArray *expected = @[ @2 ];
+		expect(values).to.equal(expected);
+
+		[subject sendNext:@3];
+		expect(values).to.equal(expected);
+
+		[sampleSubject sendNext:RACUnit.defaultUnit];
+		expected = @[ @2, @3 ];
+		expect(values).to.equal(expected);
+
+		[sampleSubject sendNext:RACUnit.defaultUnit];
+		expected = @[ @2, @3, @3 ];
+		expect(values).to.equal(expected);
+	});
+});
+
+describe(@"-collect", ^{
+	__block RACSubject *subject;
+	__block RACSignal *collected;
+
+	__block id value;
+	__block BOOL hasCompleted;
+
+	beforeEach(^{
+		subject = [RACSubject subject];
+		collected = [subject collect];
+		
+		value = nil;
+		hasCompleted = NO;
+		
+		[collected subscribeNext:^(id x) {
+			value = x;
+		} completed:^{
+			hasCompleted = YES;
+		}];
+	});
+	
+	it(@"should send a single array when the original signal completes", ^{
+		NSArray *expected = @[ @1, @2, @3 ];
+
+		[subject sendNext:@1];
+		[subject sendNext:@2];
+		[subject sendNext:@3];
+		expect(value).to.beNil();
+
+		[subject sendCompleted];
+		expect(value).to.equal(expected);
+		expect(hasCompleted).to.beTruthy();
+	});
+
+	it(@"should add NSNull to an array for nil values", ^{
+		NSArray *expected = @[ NSNull.null, @1, NSNull.null ];
+		
+		[subject sendNext:nil];
+		[subject sendNext:@1];
+		[subject sendNext:nil];
+		expect(value).to.beNil();
+		
+		[subject sendCompleted];
+		expect(value).to.equal(expected);
+		expect(hasCompleted).to.beTruthy();
+	});
+});
+
+describe(@"-bufferWithTime:", ^{
+	__block RACTestScheduler *scheduler;
+
+	__block RACSubject *input;
+	__block RACSignal *bufferedInput;
+	__block RACTuple *latestValue;
+
+	beforeEach(^{
+		scheduler = [[RACTestScheduler alloc] init];
+
+		input = [RACSubject subject];
+		bufferedInput = [input bufferWithTime:1 onScheduler:scheduler];
+		latestValue = nil;
+
+		[bufferedInput subscribeNext:^(RACTuple *x) {
+			latestValue = x;
+		}];
+	});
+
+	it(@"should buffer nexts", ^{
+		[input sendNext:@1];
+		[input sendNext:@2];
+
+		[scheduler stepAll];
+		expect(latestValue).to.equal(RACTuplePack(@1, @2));
+		
+		[input sendNext:@3];
+		[input sendNext:@4];
+
+		[scheduler stepAll];
+		expect(latestValue).to.equal(RACTuplePack(@3, @4));
+	});
+
+	it(@"should not perform buffering until a value is sent", ^{
+		[input sendNext:@1];
+		[input sendNext:@2];
+		[scheduler stepAll];
+		expect(latestValue).to.equal(RACTuplePack(@1, @2));
+
+		[scheduler stepAll];
+		expect(latestValue).to.equal(RACTuplePack(@1, @2));
+		
+		[input sendNext:@3];
+		[input sendNext:@4];
+		[scheduler stepAll];
+		expect(latestValue).to.equal(RACTuplePack(@3, @4));
+	});
+
+	it(@"should flush any buffered nexts upon completion", ^{
+		[input sendNext:@1];
+		[input sendCompleted];
+		[scheduler stepAll];
+		expect(latestValue).to.equal(RACTuplePack(@1));
+	});
+
+	it(@"should support NSNull values", ^{
+		[input sendNext:NSNull.null];
+		[scheduler stepAll];
+		expect(latestValue).to.equal(RACTuplePack(NSNull.null));
+	});
+
+	it(@"should buffer nil values", ^{
+		[input sendNext:nil];
+		[scheduler stepAll];
+		expect(latestValue).to.equal(RACTuplePack(nil));
+	});
+});
+
+describe(@"-concat", ^{
+	__block RACSubject *subject;
+
+	__block RACSignal *oneSignal;
+	__block RACSignal *twoSignal;
+	__block RACSignal *threeSignal;
+
+	__block RACSignal *errorSignal;
+	__block RACSignal *completedSignal;
+
+	beforeEach(^{
+		subject = [RACReplaySubject subject];
+
+		oneSignal = [RACSignal return:@1];
+		twoSignal = [RACSignal return:@2];
+		threeSignal = [RACSignal return:@3];
+
+		errorSignal = [RACSignal error:RACSignalTestError];
+		completedSignal = RACSignal.empty;
+	});
+
+	it(@"should concatenate the values of inner signals", ^{
+		[subject sendNext:oneSignal];
+		[subject sendNext:twoSignal];
+		[subject sendNext:completedSignal];
+		[subject sendNext:threeSignal];
+
+		NSMutableArray *values = [NSMutableArray array];
+		[[subject concat] subscribeNext:^(id x) {
+			[values addObject:x];
+		}];
+
+		NSArray *expected = @[ @1, @2, @3 ];
+		expect(values).to.equal(expected);
+	});
+
+	it(@"should complete only after all signals complete", ^{
+		RACReplaySubject *valuesSubject = [RACReplaySubject subject];
+
+		[subject sendNext:valuesSubject];
+		[subject sendCompleted];
+
+		[valuesSubject sendNext:@1];
+		[valuesSubject sendNext:@2];
+		[valuesSubject sendCompleted];
+
+		NSArray *expected = @[ @1, @2 ];
+		expect([[subject concat] toArray]).to.equal(expected);
+	});
+
+	it(@"should pass through errors", ^{
+		[subject sendNext:errorSignal];
+		
+		NSError *error = nil;
+		[[subject concat] firstOrDefault:nil success:NULL error:&error];
+		expect(error).to.equal(RACSignalTestError);
+	});
+
+	it(@"should concat signals sent later", ^{
+		[subject sendNext:oneSignal];
+
+		NSMutableArray *values = [NSMutableArray array];
+		[[subject concat] subscribeNext:^(id x) {
+			[values addObject:x];
+		}];
+
+		NSArray *expected = @[ @1 ];
+		expect(values).to.equal(expected);
+
+		[subject sendNext:[twoSignal delay:0]];
+
+		expected = @[ @1, @2 ];
+		expect(values).will.equal(expected);
+
+		[subject sendNext:threeSignal];
+
+		expected = @[ @1, @2, @3 ];
+		expect(values).to.equal(expected);
+	});
+
+	it(@"should dispose the current signal", ^{
+		__block BOOL disposed = NO;
+		RACSignal *innerSignal = [RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+			return [RACDisposable disposableWithBlock:^{
+				disposed = YES;
+			}];
+		}];
+
+		RACDisposable *concatDisposable = [[subject concat] subscribeCompleted:^{}];
+		
+		[subject sendNext:innerSignal];
+		expect(disposed).notTo.beTruthy();
+
+		[concatDisposable dispose];
+		expect(disposed).to.beTruthy();
+	});
+
+	it(@"should dispose later signals", ^{
+		__block BOOL disposed = NO;
+		RACSignal *laterSignal = [RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+			return [RACDisposable disposableWithBlock:^{
+				disposed = YES;
+			}];
+		}];
+
+		RACSubject *firstSignal = [RACSubject subject];
+		RACSignal *outerSignal = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) {
+			[subscriber sendNext:firstSignal];
+			[subscriber sendNext:laterSignal];
+			return nil;
+		}];
+
+		RACDisposable *concatDisposable = [[outerSignal concat] subscribeCompleted:^{}];
+
+		[firstSignal sendCompleted];
+		expect(disposed).notTo.beTruthy();
+
+		[concatDisposable dispose];
+		expect(disposed).to.beTruthy();
+	});
+});
+
+describe(@"-initially:", ^{
+	__block RACSubject *subject;
+
+	__block NSUInteger initiallyInvokedCount;
+	__block RACSignal *signal;
+
+	beforeEach(^{
+		subject = [RACSubject subject];
+
+		initiallyInvokedCount = 0;
+		signal = [subject initially:^{
+			++initiallyInvokedCount;
+		}];
+	});
+
+	it(@"should not run without a subscription", ^{
+		[subject sendCompleted];
+		expect(initiallyInvokedCount).to.equal(0);
+	});
+
+	it(@"should run on subscription", ^{
+		[signal subscribe:[RACSubscriber new]];
+		expect(initiallyInvokedCount).to.equal(1);
+	});
+
+	it(@"should re-run for each subscription", ^{
+		[signal subscribe:[RACSubscriber new]];
+		[signal subscribe:[RACSubscriber new]];
+		expect(initiallyInvokedCount).to.equal(2);
+	});
+});
+
+describe(@"-finally:", ^{
+	__block RACSubject *subject;
+
+	__block BOOL finallyInvoked;
+	__block RACSignal *signal;
+
+	beforeEach(^{
+		subject = [RACSubject subject];
+		
+		finallyInvoked = NO;
+		signal = [subject finally:^{
+			finallyInvoked = YES;
+		}];
+	});
+
+	it(@"should not run finally without a subscription", ^{
+		[subject sendCompleted];
+		expect(finallyInvoked).to.beFalsy();
+	});
+
+	describe(@"with a subscription", ^{
+		__block RACDisposable *disposable;
+
+		beforeEach(^{
+			disposable = [signal subscribeCompleted:^{}];
+		});
+		
+		afterEach(^{
+			[disposable dispose];
+		});
+
+		it(@"should not run finally upon next", ^{
+			[subject sendNext:RACUnit.defaultUnit];
+			expect(finallyInvoked).to.beFalsy();
+		});
+
+		it(@"should run finally upon completed", ^{
+			[subject sendCompleted];
+			expect(finallyInvoked).to.beTruthy();
+		});
+
+		it(@"should run finally upon error", ^{
+			[subject sendError:nil];
+			expect(finallyInvoked).to.beTruthy();
+		});
+	});
+});
+
+describe(@"-ignoreValues", ^{
+	__block RACSubject *subject;
+
+	__block BOOL gotNext;
+	__block BOOL gotCompleted;
+	__block NSError *receivedError;
+
+	beforeEach(^{
+		subject = [RACSubject subject];
+
+		gotNext = NO;
+		gotCompleted = NO;
+		receivedError = nil;
+
+		[[subject ignoreValues] subscribeNext:^(id _) {
+			gotNext = YES;
+		} error:^(NSError *error) {
+			receivedError = error;
+		} completed:^{
+			gotCompleted = YES;
+		}];
+	});
+
+	it(@"should skip nexts and pass through completed", ^{
+		[subject sendNext:RACUnit.defaultUnit];
+		[subject sendCompleted];
+
+		expect(gotNext).to.beFalsy();
+		expect(gotCompleted).to.beTruthy();
+		expect(receivedError).to.beNil();
+	});
+
+	it(@"should skip nexts and pass through errors", ^{
+		[subject sendNext:RACUnit.defaultUnit];
+		[subject sendError:RACSignalTestError];
+
+		expect(gotNext).to.beFalsy();
+		expect(gotCompleted).to.beFalsy();
+		expect(receivedError).to.equal(RACSignalTestError);
+	});
+});
+
+describe(@"-materialize", ^{
+	it(@"should convert nexts and completed into RACEvents", ^{
+		NSArray *events = [[[RACSignal return:RACUnit.defaultUnit] materialize] toArray];
+		NSArray *expected = @[
+			[RACEvent eventWithValue:RACUnit.defaultUnit],
+			RACEvent.completedEvent
+		];
+
+		expect(events).to.equal(expected);
+	});
+
+	it(@"should convert errors into RACEvents and complete", ^{
+		NSArray *events = [[[RACSignal error:RACSignalTestError] materialize] toArray];
+		NSArray *expected = @[ [RACEvent eventWithError:RACSignalTestError] ];
+		expect(events).to.equal(expected);
+	});
+});
+
+describe(@"-dematerialize", ^{
+	it(@"should convert nexts from RACEvents", ^{
+		RACSignal *events = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) {
+			[subscriber sendNext:[RACEvent eventWithValue:@1]];
+			[subscriber sendNext:[RACEvent eventWithValue:@2]];
+			[subscriber sendCompleted];
+			return nil;
+		}];
+
+		NSArray *expected = @[ @1, @2 ];
+		expect([[events dematerialize] toArray]).to.equal(expected);
+	});
+
+	it(@"should convert completed from a RACEvent", ^{
+		RACSignal *events = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) {
+			[subscriber sendNext:[RACEvent eventWithValue:@1]];
+			[subscriber sendNext:RACEvent.completedEvent];
+			[subscriber sendNext:[RACEvent eventWithValue:@2]];
+			[subscriber sendCompleted];
+			return nil;
+		}];
+
+		NSArray *expected = @[ @1 ];
+		expect([[events dematerialize] toArray]).to.equal(expected);
+	});
+
+	it(@"should convert error from a RACEvent", ^{
+		RACSignal *events = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) {
+			[subscriber sendNext:[RACEvent eventWithError:RACSignalTestError]];
+			[subscriber sendNext:[RACEvent eventWithValue:@1]];
+			[subscriber sendCompleted];
+			return nil;
+		}];
+
+		__block NSError *error = nil;
+		expect([[events dematerialize] firstOrDefault:nil success:NULL error:&error]).to.beNil();
+		expect(error).to.equal(RACSignalTestError);
+	});
+});
+
+describe(@"-not", ^{
+	it(@"should invert every BOOL sent", ^{
+		RACSubject *subject = [RACReplaySubject subject];
+		[subject sendNext:@NO];
+		[subject sendNext:@YES];
+		[subject sendCompleted];
+		NSArray *results = [[subject not] toArray];
+		NSArray *expected = @[ @YES, @NO ];
+		expect(results).to.equal(expected);
+	});
+});
+
+describe(@"-and", ^{
+	it(@"should return YES if all YES values are sent", ^{
+		RACSubject *subject = [RACReplaySubject subject];
+		
+		[subject sendNext:RACTuplePack(@YES, @NO, @YES)];
+		[subject sendNext:RACTuplePack(@NO, @NO, @NO)];
+		[subject sendNext:RACTuplePack(@YES, @YES, @YES)];
+		[subject sendCompleted];
+		
+		NSArray *results = [[subject and] toArray];
+		NSArray *expected = @[ @NO, @NO, @YES ];
+		
+		expect(results).to.equal(expected);
+	});
+});
+
+describe(@"-or", ^{
+	it(@"should return YES for any YES values sent", ^{
+		RACSubject *subject = [RACReplaySubject subject];
+		
+		[subject sendNext:RACTuplePack(@YES, @NO, @YES)];
+		[subject sendNext:RACTuplePack(@NO, @NO, @NO)];
+		[subject sendCompleted];
+		
+		NSArray *results = [[subject or] toArray];
+		NSArray *expected = @[ @YES, @NO ];
+		
+		expect(results).to.equal(expected);
+	});
+});
+
+describe(@"-groupBy:", ^{
+	it(@"should send completed to all grouped signals.", ^{
+		RACSubject *subject = [RACReplaySubject subject];
+
+		__block NSUInteger groupedSignalCount = 0;
+		__block NSUInteger completedGroupedSignalCount = 0;
+		[[subject groupBy:^(NSNumber *number) {
+			return @(floorf(number.floatValue));
+		}] subscribeNext:^(RACGroupedSignal *groupedSignal) {
+			++groupedSignalCount;
+
+			[groupedSignal subscribeCompleted:^{
+				++completedGroupedSignalCount;
+			}];
+		}];
+
+		[subject sendNext:@1];
+		[subject sendNext:@2];
+		[subject sendCompleted];
+
+		expect(completedGroupedSignalCount).to.equal(groupedSignalCount);
+	});
+
+	it(@"should send error to all grouped signals.", ^{
+		RACSubject *subject = [RACReplaySubject subject];
+
+		__block NSUInteger groupedSignalCount = 0;
+		__block NSUInteger erroneousGroupedSignalCount = 0;
+		[[subject groupBy:^(NSNumber *number) {
+			return @(floorf(number.floatValue));
+		}] subscribeNext:^(RACGroupedSignal *groupedSignal) {
+			++groupedSignalCount;
+
+			[groupedSignal subscribeError:^(NSError *error) {
+				++erroneousGroupedSignalCount;
+
+				expect(error.domain).to.equal(@"TestDomain");
+				expect(error.code).to.equal(123);
+			}];
+		}];
+
+		[subject sendNext:@1];
+		[subject sendNext:@2];
+		[subject sendError:[NSError errorWithDomain:@"TestDomain" code:123 userInfo:nil]];
+
+		expect(erroneousGroupedSignalCount).to.equal(groupedSignalCount);
+	});
+});
+
+describe(@"starting signals", ^{
+	describe(@"+startLazilyWithScheduler:block:", ^{
+		itBehavesLike(RACSignalStartSharedExamplesName, ^{
+			NSArray *expectedValues = @[ @42, @43 ];
+			RACScheduler *scheduler = [RACScheduler scheduler];
+			RACSignal *signal = [RACSignal startLazilyWithScheduler:scheduler block:^(id<RACSubscriber> subscriber) {
+				for (id value in expectedValues) {
+					[subscriber sendNext:value];
+				}
+				[subscriber sendCompleted];
+			}];
+			return @{
+				RACSignalStartSignal: signal,
+				RACSignalStartExpectedValues: expectedValues,
+				RACSignalStartExpectedScheduler: scheduler,
+			};
+		});
+
+		__block NSUInteger invokedCount = 0;
+		__block void (^subscribe)(void);
+
+		beforeEach(^{
+			invokedCount = 0;
+
+			RACSignal *signal = [RACSignal startLazilyWithScheduler:RACScheduler.immediateScheduler block:^(id<RACSubscriber> subscriber) {
+				invokedCount++;
+				[subscriber sendNext:@42];
+				[subscriber sendCompleted];
+			}];
+
+			subscribe = [^{
+				[signal subscribe:[RACSubscriber subscriberWithNext:nil error:nil completed:nil]];
+			} copy];
+		});
+
+		it(@"should only invoke the block on subscription", ^{
+			expect(invokedCount).to.equal(0);
+			subscribe();
+			expect(invokedCount).to.equal(1);
+		});
+
+		it(@"should only invoke the block once", ^{
+			expect(invokedCount).to.equal(0);
+			subscribe();
+			expect(invokedCount).to.equal(1);
+			subscribe();
+			expect(invokedCount).to.equal(1);
+			subscribe();
+			expect(invokedCount).to.equal(1);
+		});
+
+		it(@"should invoke the block on the given scheduler", ^{
+			RACScheduler *scheduler = [RACScheduler scheduler];
+			__block RACScheduler *currentScheduler;
+			[[[RACSignal
+				startLazilyWithScheduler:scheduler block:^(id<RACSubscriber> subscriber) {
+					currentScheduler = RACScheduler.currentScheduler;
+				}]
+				publish]
+				connect];
+
+			expect(currentScheduler).will.equal(scheduler);
+		});
+	});
+
+	describe(@"+startEagerlyWithScheduler:block:", ^{
+		itBehavesLike(RACSignalStartSharedExamplesName, ^{
+			NSArray *expectedValues = @[ @42, @43 ];
+			RACScheduler *scheduler = [RACScheduler scheduler];
+			RACSignal *signal = [RACSignal startEagerlyWithScheduler:scheduler block:^(id<RACSubscriber> subscriber) {
+				for (id value in expectedValues) {
+					[subscriber sendNext:value];
+				}
+				[subscriber sendCompleted];
+			}];
+			return @{
+				RACSignalStartSignal: signal,
+				RACSignalStartExpectedValues: expectedValues,
+				RACSignalStartExpectedScheduler: scheduler,
+			};
+		});
+
+		it(@"should immediately invoke the block", ^{
+			__block BOOL blockInvoked = NO;
+			[RACSignal startEagerlyWithScheduler:[RACScheduler scheduler] block:^(id<RACSubscriber> subscriber) {
+				blockInvoked = YES;
+			}];
+
+			expect(blockInvoked).will.beTruthy();
+		});
+
+		it(@"should only invoke the block once", ^{
+			__block NSUInteger invokedCount = 0;
+			RACSignal *signal = [RACSignal startEagerlyWithScheduler:RACScheduler.immediateScheduler block:^(id<RACSubscriber> subscriber) {
+				invokedCount++;
+			}];
+
+			expect(invokedCount).to.equal(1);
+
+			[[signal publish] connect];
+			expect(invokedCount).to.equal(1);
+
+			[[signal publish] connect];
+			expect(invokedCount).to.equal(1);
+		});
+
+		it(@"should invoke the block on the given scheduler", ^{
+			RACScheduler *scheduler = [RACScheduler scheduler];
+			__block RACScheduler *currentScheduler;
+			[RACSignal startEagerlyWithScheduler:scheduler block:^(id<RACSubscriber> subscriber) {
+				currentScheduler = RACScheduler.currentScheduler;
+			}];
+
+			expect(currentScheduler).will.equal(scheduler);
+		});
+	});
+});
+
+describe(@"-toArray", ^{
+	__block RACSubject *subject;
+	
+	beforeEach(^{
+		subject = [RACReplaySubject subject];
+	});
+	
+	it(@"should return an array which contains NSNulls for nil values", ^{
+		NSArray *expected = @[ NSNull.null, @1, NSNull.null ];
+		
+		[subject sendNext:nil];
+		[subject sendNext:@1];
+		[subject sendNext:nil];
+		[subject sendCompleted];
+		
+		expect([subject toArray]).to.equal(expected);
+	});
+
+	it(@"should return nil upon error", ^{
+		[subject sendError:nil];
+		expect([subject toArray]).to.beNil();
+	});
+
+	it(@"should return nil upon error even if some nexts were sent", ^{
+		[subject sendNext:@1];
+		[subject sendNext:@2];
+		[subject sendError:nil];
+		
+		expect([subject toArray]).to.beNil();
+	});
+});
+
+describe(@"-ignore:", ^{
+	it(@"should ignore nil", ^{
+		RACSignal *signal = [[RACSignal
+			createSignal:^ id (id<RACSubscriber> subscriber) {
+				[subscriber sendNext:@1];
+				[subscriber sendNext:nil];
+				[subscriber sendNext:@3];
+				[subscriber sendNext:@4];
+				[subscriber sendNext:nil];
+				[subscriber sendCompleted];
+				return nil;
+			}]
+			ignore:nil];
+		
+		NSArray *expected = @[ @1, @3, @4 ];
+		expect([signal toArray]).to.equal(expected);
+	});
+});
+
+describe(@"-replayLazily", ^{
+	__block NSUInteger subscriptionCount;
+	__block BOOL disposed;
+
+	__block RACSignal *signal;
+	__block RACSubject *disposeSubject;
+	__block RACSignal *replayedSignal;
+
+	beforeEach(^{
+		subscriptionCount = 0;
+		disposed = NO;
+
+		signal = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) {
+			subscriptionCount++;
+			[subscriber sendNext:RACUnit.defaultUnit];
+
+			RACDisposable *schedulingDisposable = [RACScheduler.mainThreadScheduler schedule:^{
+				[subscriber sendNext:RACUnit.defaultUnit];
+				[subscriber sendCompleted];
+			}];
+
+			return [RACDisposable disposableWithBlock:^{
+				[schedulingDisposable dispose];
+				disposed = YES;
+			}];
+		}];
+
+		disposeSubject = [RACSubject subject];
+		replayedSignal = [[signal takeUntil:disposeSubject] replayLazily];
+	});
+
+	it(@"should forward the input signal upon subscription", ^{
+		expect(subscriptionCount).to.equal(0);
+
+		expect([replayedSignal asynchronouslyWaitUntilCompleted:NULL]).to.beTruthy();
+		expect(subscriptionCount).to.equal(1);
+	});
+
+	it(@"should replay the input signal for future subscriptions", ^{
+		NSArray *events = [[[replayedSignal materialize] collect] asynchronousFirstOrDefault:nil success:NULL error:NULL];
+		expect(events).notTo.beNil();
+
+		expect([[[replayedSignal materialize] collect] asynchronousFirstOrDefault:nil success:NULL error:NULL]).to.equal(events);
+		expect(subscriptionCount).to.equal(1);
+	});
+
+	it(@"should replay even after disposal", ^{
+		__block NSUInteger valueCount = 0;
+		[replayedSignal subscribeNext:^(id x) {
+			valueCount++;
+		}];
+
+		[disposeSubject sendCompleted];
+		expect(valueCount).to.equal(1);
+		expect([[replayedSignal toArray] count]).to.equal(valueCount);
+	});
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACSignalStartExamples.h b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSignalStartExamples.h
new file mode 100644
index 0000000..3e01c36
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSignalStartExamples.h
@@ -0,0 +1,20 @@
+//
+//  RACSignalStartExamples.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 5/29/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+extern NSString * const RACSignalStartSharedExamplesName;
+
+// The signal to test, created by some +start...: variation.
+extern NSString * const RACSignalStartSignal;
+
+// An NSArray of the values which the signal should be expected to send.
+extern NSString * const RACSignalStartExpectedValues;
+
+// The scheduler on which the signal should be expected to send values.
+extern NSString * const RACSignalStartExpectedScheduler;
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACSignalStartExamples.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSignalStartExamples.m
new file mode 100644
index 0000000..6416630
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSignalStartExamples.m
@@ -0,0 +1,74 @@
+//
+//  RACSignalStartExamples.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 5/29/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSignalStartExamples.h"
+#import "RACSignal.h"
+#import "RACSignal+Operations.h"
+#import "RACScheduler.h"
+#import "RACSubscriber.h"
+#import "RACMulticastConnection.h"
+
+NSString * const RACSignalStartSharedExamplesName = @"RACSignalStartSharedExamplesName";
+
+NSString * const RACSignalStartSignal = @"RACSignalStartSignal";
+NSString * const RACSignalStartExpectedValues = @"RACSignalStartExpectedValues";
+NSString * const RACSignalStartExpectedScheduler = @"RACSignalStartExpectedScheduler";
+
+SharedExampleGroupsBegin(RACSignalStartSpec)
+
+sharedExamples(RACSignalStartSharedExamplesName, ^(NSDictionary *data) {
+	__block RACSignal *signal;
+	__block NSArray *expectedValues;
+	__block RACScheduler *scheduler;
+	__block RACScheduler * (^subscribeAndGetScheduler)(void);
+
+	beforeEach(^{
+		signal = data[RACSignalStartSignal];
+		expectedValues = data[RACSignalStartExpectedValues];
+		scheduler = data[RACSignalStartExpectedScheduler];
+
+		subscribeAndGetScheduler = [^{
+			__block RACScheduler *schedulerInDelivery;
+			[signal subscribeNext:^(id _) {
+				schedulerInDelivery = RACScheduler.currentScheduler;
+			}];
+
+			expect(schedulerInDelivery).willNot.beNil();
+			return schedulerInDelivery;
+		} copy];
+	});
+
+	it(@"should send values from the returned signal", ^{
+		NSArray *values = [signal toArray];
+		expect(values).to.equal(expectedValues);
+	});
+
+	it(@"should replay all values", ^{
+		// Force a subscription so that we get replayed results.
+		[[signal publish] connect];
+		
+		NSArray *values = [signal toArray];
+		expect(values).to.equal(expectedValues);
+	});
+
+	it(@"should deliver the original results on the given scheduler", ^{
+		RACScheduler *currentScheduler = subscribeAndGetScheduler();
+		expect(currentScheduler).to.equal(scheduler);
+	});
+
+	it(@"should deliver replayed results on the given scheduler", ^{
+		// Force a subscription so that we get replayed results on the
+		// tested subscription.
+		subscribeAndGetScheduler();
+
+		RACScheduler *currentScheduler = subscribeAndGetScheduler();
+		expect(currentScheduler).to.equal(scheduler);
+	});
+});
+
+SharedExampleGroupsEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACStreamExamples.h b/ReactiveCocoaFramework/ReactiveCocoaTests/RACStreamExamples.h
new file mode 100644
index 0000000..318a6a8
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACStreamExamples.h
@@ -0,0 +1,26 @@
+//
+//  RACStreamExamples.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-11-01.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+// The name of the shared examples for a RACStream subclass.
+extern NSString * const RACStreamExamples;
+
+// The RACStream subclass to test.
+extern NSString * const RACStreamExamplesClass;
+
+// An infinite RACStream to test, making sure that certain operations
+// terminate.
+//
+// The stream should contain infinite RACUnit values.
+extern NSString * const RACStreamExamplesInfiniteStream;
+
+// A block with the signature:
+//
+// void (^)(RACStream *stream, NSArray *expectedValues)
+//
+// … used to verify that a stream contains the expected values.
+extern NSString * const RACStreamExamplesVerifyValuesBlock;
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACStreamExamples.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACStreamExamples.m
new file mode 100644
index 0000000..bdf22f1
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACStreamExamples.m
@@ -0,0 +1,648 @@
+//
+//  RACStreamExamples.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-11-01.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACStreamExamples.h"
+
+#import "RACStream.h"
+#import "RACUnit.h"
+#import "RACTuple.h"
+
+NSString * const RACStreamExamples = @"RACStreamExamples";
+NSString * const RACStreamExamplesClass = @"RACStreamExamplesClass";
+NSString * const RACStreamExamplesInfiniteStream = @"RACStreamExamplesInfiniteStream";
+NSString * const RACStreamExamplesVerifyValuesBlock = @"RACStreamExamplesVerifyValuesBlock";
+
+SharedExampleGroupsBegin(RACStreamExamples)
+
+sharedExamplesFor(RACStreamExamples, ^(NSDictionary *data) {
+	__block Class streamClass;
+	__block void (^verifyValues)(RACStream *, NSArray *);
+	__block RACStream *infiniteStream;
+
+	__block RACStream *(^streamWithValues)(NSArray *);
+	
+	before(^{
+		streamClass = data[RACStreamExamplesClass];
+		verifyValues = data[RACStreamExamplesVerifyValuesBlock];
+		infiniteStream = data[RACStreamExamplesInfiniteStream];
+		streamWithValues = [^(NSArray *values) {
+			RACStream *stream = [streamClass empty];
+
+			for (id value in values) {
+				stream = [stream concat:[streamClass return:value]];
+			}
+
+			return stream;
+		} copy];
+	});
+
+	it(@"should return an empty stream", ^{
+		RACStream *stream = [streamClass empty];
+		verifyValues(stream, @[]);
+	});
+
+	it(@"should lift a value into a stream", ^{
+		RACStream *stream = [streamClass return:RACUnit.defaultUnit];
+		verifyValues(stream, @[ RACUnit.defaultUnit ]);
+	});
+
+	describe(@"-concat:", ^{
+		it(@"should concatenate two streams", ^{
+			RACStream *stream = [[streamClass return:@0] concat:[streamClass return:@1]];
+			verifyValues(stream, @[ @0, @1 ]);
+		});
+
+		it(@"should concatenate three streams", ^{
+			RACStream *stream = [[[streamClass return:@0] concat:[streamClass return:@1]] concat:[streamClass return:@2]];
+			verifyValues(stream, @[ @0, @1, @2 ]);
+		});
+
+		it(@"should concatenate around an empty stream", ^{
+			RACStream *stream = [[[streamClass return:@0] concat:[streamClass empty]] concat:[streamClass return:@2]];
+			verifyValues(stream, @[ @0, @2 ]);
+		});
+	});
+
+	it(@"should flatten", ^{
+		RACStream *stream = [[streamClass return:[streamClass return:RACUnit.defaultUnit]] flatten];
+		verifyValues(stream, @[ RACUnit.defaultUnit ]);
+	});
+
+	describe(@"-bind:", ^{
+		it(@"should return the result of binding a single value", ^{
+			RACStream *stream = [[streamClass return:@0] bind:^{
+				return ^(NSNumber *value, BOOL *stop) {
+					NSNumber *newValue = @(value.integerValue + 1);
+					return [streamClass return:newValue];
+				};
+			}];
+
+			verifyValues(stream, @[ @1 ]);
+		});
+
+		it(@"should concatenate the result of binding multiple values", ^{
+			RACStream *baseStream = streamWithValues(@[ @0, @1 ]);
+			RACStream *stream = [baseStream bind:^{
+				return ^(NSNumber *value, BOOL *stop) {
+					NSNumber *newValue = @(value.integerValue + 1);
+					return [streamClass return:newValue];
+				};
+			}];
+
+			verifyValues(stream, @[ @1, @2 ]);
+		});
+
+		it(@"should concatenate with an empty result from binding a value", ^{
+			RACStream *baseStream = streamWithValues(@[ @0, @1, @2 ]);
+			RACStream *stream = [baseStream bind:^{
+				return ^(NSNumber *value, BOOL *stop) {
+					if (value.integerValue == 1) return [streamClass empty];
+
+					NSNumber *newValue = @(value.integerValue + 1);
+					return [streamClass return:newValue];
+				};
+			}];
+
+			verifyValues(stream, @[ @1, @3 ]);
+		});
+
+		it(@"should terminate immediately when returning nil", ^{
+			RACStream *stream = [infiniteStream bind:^{
+				return ^ id (id _, BOOL *stop) {
+					return nil;
+				};
+			}];
+
+			verifyValues(stream, @[]);
+		});
+
+		it(@"should terminate after one value when setting 'stop'", ^{
+			RACStream *stream = [infiniteStream bind:^{
+				return ^ id (id value, BOOL *stop) {
+					*stop = YES;
+					return [streamClass return:value];
+				};
+			}];
+
+			verifyValues(stream, @[ RACUnit.defaultUnit ]);
+		});
+
+		it(@"should terminate immediately when returning nil and setting 'stop'", ^{
+			RACStream *stream = [infiniteStream bind:^{
+				return ^ id (id _, BOOL *stop) {
+					*stop = YES;
+					return nil;
+				};
+			}];
+
+			verifyValues(stream, @[]);
+		});
+
+		it(@"should be restartable even with block state", ^{
+			NSArray *values = @[ @0, @1, @2 ];
+			RACStream *baseStream = streamWithValues(values);
+
+			RACStream *countingStream = [baseStream bind:^{
+				__block NSUInteger counter = 0;
+
+				return ^(id x, BOOL *stop) {
+					return [streamClass return:@(counter++)];
+				};
+			}];
+
+			verifyValues(countingStream, @[ @0, @1, @2 ]);
+			verifyValues(countingStream, @[ @0, @1, @2 ]);
+		});
+
+		it(@"should be interleavable even with block state", ^{
+			NSArray *values = @[ @0, @1, @2 ];
+			RACStream *baseStream = streamWithValues(values);
+
+			RACStream *countingStream = [baseStream bind:^{
+				__block NSUInteger counter = 0;
+
+				return ^(id x, BOOL *stop) {
+					return [streamClass return:@(counter++)];
+				};
+			}];
+
+			// Just so +zip:reduce: thinks this is a unique stream.
+			RACStream *anotherStream = [[streamClass empty] concat:countingStream];
+
+			RACStream *zipped = [streamClass zip:@[ countingStream, anotherStream ] reduce:^(NSNumber *v1, NSNumber *v2) {
+				return @(v1.integerValue + v2.integerValue);
+			}];
+
+			verifyValues(zipped, @[ @0, @2, @4 ]);
+		});
+	});
+
+	describe(@"-flattenMap:", ^{
+		it(@"should return a single mapped result", ^{
+			RACStream *stream = [[streamClass return:@0] flattenMap:^(NSNumber *value) {
+				NSNumber *newValue = @(value.integerValue + 1);
+				return [streamClass return:newValue];
+			}];
+
+			verifyValues(stream, @[ @1 ]);
+		});
+
+		it(@"should concatenate the results of mapping multiple values", ^{
+			RACStream *baseStream = streamWithValues(@[ @0, @1 ]);
+			RACStream *stream = [baseStream flattenMap:^(NSNumber *value) {
+				NSNumber *newValue = @(value.integerValue + 1);
+				return [streamClass return:newValue];
+			}];
+
+			verifyValues(stream, @[ @1, @2 ]);
+		});
+
+		it(@"should concatenate with an empty result from mapping a value", ^{
+			RACStream *baseStream = streamWithValues(@[ @0, @1, @2 ]);
+			RACStream *stream = [baseStream flattenMap:^(NSNumber *value) {
+				if (value.integerValue == 1) return [streamClass empty];
+
+				NSNumber *newValue = @(value.integerValue + 1);
+				return [streamClass return:newValue];
+			}];
+
+			verifyValues(stream, @[ @1, @3 ]);
+		});
+
+		it(@"should treat nil streams like empty streams", ^{
+			RACStream *baseStream = streamWithValues(@[ @0, @1, @2 ]);
+			RACStream *stream = [baseStream flattenMap:^ RACStream * (NSNumber *value) {
+				if (value.integerValue == 1) return nil;
+
+				NSNumber *newValue = @(value.integerValue + 1);
+				return [streamClass return:newValue];
+			}];
+
+			verifyValues(stream, @[ @1, @3 ]);
+		});
+	});
+
+	it(@"should map", ^{
+		RACStream *baseStream = streamWithValues(@[ @0, @1, @2 ]);
+		RACStream *stream = [baseStream map:^(NSNumber *value) {
+			return @(value.integerValue + 1);
+		}];
+
+		verifyValues(stream, @[ @1, @2, @3 ]);
+	});
+
+	it(@"should map and replace", ^{
+		RACStream *baseStream = streamWithValues(@[ @0, @1, @2 ]);
+		RACStream *stream = [baseStream mapReplace:RACUnit.defaultUnit];
+
+		verifyValues(stream, @[ RACUnit.defaultUnit, RACUnit.defaultUnit, RACUnit.defaultUnit ]);
+	});
+
+	it(@"should filter", ^{
+		RACStream *baseStream = streamWithValues(@[ @0, @1, @2, @3, @4, @5, @6 ]);
+		RACStream *stream = [baseStream filter:^ BOOL (NSNumber *value) {
+			return value.integerValue % 2 == 0;
+		}];
+
+		verifyValues(stream, @[ @0, @2, @4, @6 ]);
+	});
+
+	describe(@"-ignore:", ^{
+		it(@"should ignore a value", ^{
+			RACStream *baseStream = streamWithValues(@[ @0, @1, @2, @3, @4, @5, @6 ]);
+			RACStream *stream = [baseStream ignore:@1];
+
+			verifyValues(stream, @[ @0, @2, @3, @4, @5, @6 ]);
+		});
+
+		it(@"should ignore based on object equality", ^{
+			RACStream *baseStream = streamWithValues(@[ @"0", @"1", @"2", @"3", @"4", @"5", @"6" ]);
+
+			NSMutableString *valueToIgnore = [[NSMutableString alloc] init];
+			[valueToIgnore appendString:@"1"];
+			RACStream *stream = [baseStream ignore:valueToIgnore];
+
+			verifyValues(stream, @[ @"0", @"2", @"3", @"4", @"5", @"6" ]);
+		});
+	});
+
+	it(@"should start with a value", ^{
+		RACStream *stream = [[streamClass return:@1] startWith:@0];
+		verifyValues(stream, @[ @0, @1 ]);
+	});
+
+	describe(@"-skip:", ^{
+		__block NSArray *values;
+		__block RACStream *stream;
+
+		before(^{
+			values = @[ @0, @1, @2 ];
+			stream = streamWithValues(values);
+		});
+
+		it(@"should skip any valid number of values", ^{
+			for (NSUInteger i = 0; i < values.count; i++) {
+				verifyValues([stream skip:i], [values subarrayWithRange:NSMakeRange(i, values.count - i)]);
+			}
+		});
+
+		it(@"should return an empty stream when skipping too many values", ^{
+			verifyValues([stream skip:4], @[]);
+		});
+	});
+
+	describe(@"-take:", ^{
+		describe(@"with three values", ^{
+			__block NSArray *values;
+			__block RACStream *stream;
+
+			before(^{
+				values = @[ @0, @1, @2 ];
+				stream = streamWithValues(values);
+			});
+
+			it(@"should take any valid number of values", ^{
+				for (NSUInteger i = 0; i < values.count; i++) {
+					verifyValues([stream take:i], [values subarrayWithRange:NSMakeRange(0, i)]);
+				}
+			});
+
+			it(@"should return the same stream when taking too many values", ^{
+				verifyValues([stream take:4], values);
+			});
+		});
+
+		it(@"should take and terminate from an infinite stream", ^{
+			verifyValues([infiniteStream take:0], @[]);
+			verifyValues([infiniteStream take:1], @[ RACUnit.defaultUnit ]);
+			verifyValues([infiniteStream take:2], @[ RACUnit.defaultUnit, RACUnit.defaultUnit ]);
+		});
+
+		it(@"should take and terminate from a single-item stream", ^{
+			NSArray *values = @[ RACUnit.defaultUnit ];
+			RACStream *stream = streamWithValues(values);
+			verifyValues([stream take:1], values);
+		});
+	});
+  
+	describe(@"zip stream creation methods", ^{
+		__block NSArray *valuesOne;
+
+		__block RACStream *streamOne;
+		__block RACStream *streamTwo;
+		__block RACStream *streamThree;
+		__block NSArray *threeStreams;
+
+		__block NSArray *oneStreamTuples;
+		__block NSArray *twoStreamTuples;
+		__block NSArray *threeStreamTuples;
+		
+		before(^{
+			valuesOne = @[ @"Ada", @"Bob", @"Dea" ];
+			NSArray *valuesTwo = @[ @"eats", @"cooks", @"jumps" ];
+			NSArray *valuesThree = @[ @"fish", @"bear", @"rock" ];
+
+			streamOne = streamWithValues(valuesOne);
+			streamTwo = streamWithValues(valuesTwo);
+			streamThree = streamWithValues(valuesThree);
+			threeStreams = @[ streamOne, streamTwo, streamThree ];
+
+			oneStreamTuples = @[
+				RACTuplePack(valuesOne[0]),
+				RACTuplePack(valuesOne[1]),
+				RACTuplePack(valuesOne[2]),
+			];
+
+			twoStreamTuples = @[
+				RACTuplePack(valuesOne[0], valuesTwo[0]),
+				RACTuplePack(valuesOne[1], valuesTwo[1]),
+				RACTuplePack(valuesOne[2], valuesTwo[2]),
+			];
+
+			threeStreamTuples = @[
+				RACTuplePack(valuesOne[0], valuesTwo[0], valuesThree[0]),
+				RACTuplePack(valuesOne[1], valuesTwo[1], valuesThree[1]),
+				RACTuplePack(valuesOne[2], valuesTwo[2], valuesThree[2]),
+			];
+		});
+
+		describe(@"-zipWith:", ^{
+			it(@"should make a stream of tuples", ^{
+				RACStream *stream = [streamOne zipWith:streamTwo];
+				verifyValues(stream, twoStreamTuples);
+			});
+			
+			it(@"should truncate streams", ^{
+				RACStream *shortStream = streamWithValues(@[ @"now", @"later" ]);
+				RACStream *stream = [streamOne zipWith:shortStream];
+
+				verifyValues(stream, @[
+					RACTuplePack(valuesOne[0], @"now"),
+					RACTuplePack(valuesOne[1], @"later")
+				]);
+			});
+			
+			it(@"should work on infinite streams", ^{
+				RACStream *stream = [streamOne zipWith:infiniteStream];
+				verifyValues(stream, @[
+					RACTuplePack(valuesOne[0], RACUnit.defaultUnit),
+					RACTuplePack(valuesOne[1], RACUnit.defaultUnit),
+					RACTuplePack(valuesOne[2], RACUnit.defaultUnit)
+				]);
+			});
+			
+			it(@"should handle multiples of the same stream", ^{
+				RACStream *stream = [streamOne zipWith:streamOne];
+				verifyValues(stream, @[
+					RACTuplePack(valuesOne[0], valuesOne[0]),
+					RACTuplePack(valuesOne[1], valuesOne[1]),
+					RACTuplePack(valuesOne[2], valuesOne[2]),
+				]);
+			});
+		});
+		
+		describe(@"+zip:reduce:", ^{
+			it(@"should reduce values", ^{
+				RACStream *stream = [streamClass zip:threeStreams reduce:^ NSString * (id x, id y, id z) {
+					return [NSString stringWithFormat:@"%@ %@ %@", x, y, z];
+				}];
+				verifyValues(stream, @[ @"Ada eats fish", @"Bob cooks bear", @"Dea jumps rock" ]);
+			});
+			
+			it(@"should truncate streams", ^{
+				RACStream *shortStream = streamWithValues(@[ @"now", @"later" ]);
+				NSArray *streams = [threeStreams arrayByAddingObject:shortStream];
+				RACStream *stream = [streamClass zip:streams reduce:^ NSString * (id w, id x, id y, id z) {
+					return [NSString stringWithFormat:@"%@ %@ %@ %@", w, x, y, z];
+				}];
+				verifyValues(stream, @[ @"Ada eats fish now", @"Bob cooks bear later" ]);
+			});
+			
+			it(@"should work on infinite streams", ^{
+				NSArray *streams = [threeStreams arrayByAddingObject:infiniteStream];
+				RACStream *stream = [streamClass zip:streams reduce:^ NSString * (id w, id x, id y, id z) {
+					return [NSString stringWithFormat:@"%@ %@ %@", w, x, y];
+				}];
+				verifyValues(stream, @[ @"Ada eats fish", @"Bob cooks bear", @"Dea jumps rock" ]);
+			});
+			
+			it(@"should handle multiples of the same stream", ^{
+				NSArray *streams = @[ streamOne, streamOne, streamTwo, streamThree, streamTwo, streamThree ];
+				RACStream *stream = [streamClass zip:streams reduce:^ NSString * (id x1, id x2, id y1, id z1, id y2, id z2) {
+					return [NSString stringWithFormat:@"%@ %@ %@ %@ %@ %@", x1, x2, y1, z1, y2, z2];
+				}];
+				verifyValues(stream, @[ @"Ada Ada eats fish eats fish", @"Bob Bob cooks bear cooks bear", @"Dea Dea jumps rock jumps rock" ]);
+			});
+		});
+		
+		describe(@"+zip:", ^{
+			it(@"should make a stream of tuples out of single value", ^{
+				RACStream *stream = [streamClass zip:@[ streamOne ]];
+				verifyValues(stream, oneStreamTuples);
+			});
+
+			it(@"should make a stream of tuples out of an array of streams", ^{
+				RACStream *stream = [streamClass zip:threeStreams];
+				verifyValues(stream, threeStreamTuples);
+			});
+
+			it(@"should make an empty stream if given an empty array", ^{
+				RACStream *stream = [streamClass zip:@[]];
+				verifyValues(stream, @[]);
+			});
+			
+			it(@"should make a stream of tuples out of an enumerator of streams", ^{
+				RACStream *stream = [streamClass zip:threeStreams.objectEnumerator];
+				verifyValues(stream, threeStreamTuples);
+			});
+			
+			it(@"should make an empty stream if given an empty enumerator", ^{
+				RACStream *stream = [streamClass zip:@[].objectEnumerator];
+				verifyValues(stream, @[]);
+			});
+		});
+	});
+
+	describe(@"+concat:", ^{
+		__block NSArray *streams = nil;
+		__block NSArray *result = nil;
+		
+		before(^{
+			RACStream *a = [streamClass return:@0];
+			RACStream *b = [streamClass empty];
+			RACStream *c = streamWithValues(@[ @1, @2, @3 ]);
+			RACStream *d = [streamClass return:@4];
+			RACStream *e = [streamClass return:@5];
+			RACStream *f = [streamClass empty];
+			RACStream *g = [streamClass empty];
+			RACStream *h = streamWithValues(@[ @6, @7 ]);
+			streams = @[ a, b, c, d, e, f, g, h ];
+			result = @[ @0, @1, @2, @3, @4, @5, @6, @7 ];
+		});
+		
+		it(@"should concatenate an array of streams", ^{
+			RACStream *stream = [streamClass concat:streams];
+			verifyValues(stream, result);
+		});
+		
+		it(@"should concatenate an enumerator of streams", ^{
+			RACStream *stream = [streamClass concat:streams.objectEnumerator];
+			verifyValues(stream, result);
+		});
+	});
+
+	it(@"should scan", ^{
+		RACStream *stream = streamWithValues(@[ @1, @2, @3, @4 ]);
+		RACStream *scanned = [stream scanWithStart:@0 reduce:^(NSNumber *running, NSNumber *next) {
+			return @(running.integerValue + next.integerValue);
+		}];
+
+		verifyValues(scanned, @[ @1, @3, @6, @10 ]);
+	});
+
+	describe(@"taking with a predicate", ^{
+		NSArray *values = @[ @0, @1, @2, @3, @0, @2, @4 ];
+
+		__block RACStream *stream;
+
+		before(^{
+			stream = streamWithValues(values);
+		});
+
+		it(@"should take until a predicate is true", ^{
+			RACStream *taken = [stream takeUntilBlock:^ BOOL (NSNumber *x) {
+				return x.integerValue >= 3;
+			}];
+
+			verifyValues(taken, @[ @0, @1, @2 ]);
+		});
+
+		it(@"should take while a predicate is true", ^{
+			RACStream *taken = [stream takeWhileBlock:^ BOOL (NSNumber *x) {
+				return x.integerValue <= 1;
+			}];
+
+			verifyValues(taken, @[ @0, @1 ]);
+		});
+
+		it(@"should take a full stream", ^{
+			RACStream *taken = [stream takeWhileBlock:^ BOOL (NSNumber *x) {
+				return x.integerValue <= 10;
+			}];
+
+			verifyValues(taken, values);
+		});
+
+		it(@"should return an empty stream", ^{
+			RACStream *taken = [stream takeWhileBlock:^ BOOL (NSNumber *x) {
+				return x.integerValue < 0;
+			}];
+
+			verifyValues(taken, @[]);
+		});
+
+		it(@"should terminate an infinite stream", ^{
+			RACStream *infiniteCounter = [infiniteStream scanWithStart:@0 reduce:^(NSNumber *running, id _) {
+				return @(running.unsignedIntegerValue + 1);
+			}];
+
+			RACStream *taken = [infiniteCounter takeWhileBlock:^ BOOL (NSNumber *x) {
+				return x.integerValue <= 5;
+			}];
+
+			verifyValues(taken, @[ @1, @2, @3, @4, @5 ]);
+		});
+	});
+
+	describe(@"skipping with a predicate", ^{
+		NSArray *values = @[ @0, @1, @2, @3, @0, @2, @4 ];
+
+		__block RACStream *stream;
+
+		before(^{
+			stream = streamWithValues(values);
+		});
+
+		it(@"should skip until a predicate is true", ^{
+			RACStream *taken = [stream skipUntilBlock:^ BOOL (NSNumber *x) {
+				return x.integerValue >= 3;
+			}];
+
+			verifyValues(taken, @[ @3, @0, @2, @4 ]);
+		});
+
+		it(@"should skip while a predicate is true", ^{
+			RACStream *taken = [stream skipWhileBlock:^ BOOL (NSNumber *x) {
+				return x.integerValue <= 1;
+			}];
+
+			verifyValues(taken, @[ @2, @3, @0, @2, @4 ]);
+		});
+
+		it(@"should skip a full stream", ^{
+			RACStream *taken = [stream skipWhileBlock:^ BOOL (NSNumber *x) {
+				return x.integerValue <= 10;
+			}];
+
+			verifyValues(taken, @[]);
+		});
+
+		it(@"should finish skipping immediately", ^{
+			RACStream *taken = [stream skipWhileBlock:^ BOOL (NSNumber *x) {
+				return x.integerValue < 0;
+			}];
+
+			verifyValues(taken, values);
+		});
+	});
+
+	describe(@"-combinePreviousWithStart:reduce:", ^{
+		NSArray *values = @[ @1, @2, @3 ];
+		__block RACStream *stream;
+		beforeEach(^{
+			stream = streamWithValues(values);
+		});
+
+		it(@"should pass the previous next into the reduce block", ^{
+			NSMutableArray *previouses = [NSMutableArray array];
+			RACStream *mapped = [stream combinePreviousWithStart:nil reduce:^(id previous, id next) {
+				[previouses addObject:previous ?: RACTupleNil.tupleNil];
+				return next;
+			}];
+
+			verifyValues(mapped, @[ @1, @2, @3 ]);
+
+			NSArray *expected = @[ RACTupleNil.tupleNil, @1, @2 ];
+			expect(previouses).to.equal(expected);
+		});
+
+		it(@"should send the combined value", ^{
+			RACStream *mapped = [stream combinePreviousWithStart:@1 reduce:^(NSNumber *previous, NSNumber *next) {
+				return [NSString stringWithFormat:@"%lu - %lu", (unsigned long)previous.unsignedIntegerValue, (unsigned long)next.unsignedIntegerValue];
+			}];
+
+			verifyValues(mapped, @[ @"1 - 1", @"1 - 2", @"2 - 3" ]);
+		});
+	});
+
+	it(@"should reduce tuples", ^{
+		RACStream *stream = streamWithValues(@[
+			RACTuplePack(@"foo", @"bar"),
+			RACTuplePack(@"buzz", @"baz"),
+			RACTuplePack(@"", @"_")
+		]);
+
+		RACStream *reduced = [stream reduceEach:^(NSString *a, NSString *b) {
+			return [a stringByAppendingString:b];
+		}];
+
+		verifyValues(reduced, @[ @"foobar", @"buzzbaz", @"_" ]);
+	});
+});
+
+SharedExampleGroupsEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubclassObject.h b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubclassObject.h
new file mode 100644
index 0000000..962b7eb
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubclassObject.h
@@ -0,0 +1,23 @@
+//
+//  RACSubclassObject.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 3/18/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACTestObject.h"
+
+@interface RACSubclassObject : RACTestObject
+
+// Set whenever -forwardInvocation: is invoked on the receiver.
+@property (nonatomic, assign) SEL forwardedSelector;
+
+// Invokes the superclass implementation with `objectValue` concatenated to
+// "SUBCLASS".
+- (NSString *)combineObjectValue:(id)objectValue andIntegerValue:(NSInteger)integerValue;
+
+// Asynchronously invokes the superclass implementation on the current scheduler.
+- (void)setObjectValue:(id)objectValue andSecondObjectValue:(id)secondObjectValue;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubclassObject.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubclassObject.m
new file mode 100644
index 0000000..41e61f7
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubclassObject.m
@@ -0,0 +1,38 @@
+//
+//  RACSubclassObject.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 3/18/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSubclassObject.h"
+#import "RACScheduler.h"
+
+@implementation RACSubclassObject
+
+- (void)forwardInvocation:(NSInvocation *)invocation {
+	self.forwardedSelector = invocation.selector;
+}
+
+- (NSMethodSignature *)methodSignatureForSelector:(SEL)selector {
+	NSParameterAssert(selector != NULL);
+
+	NSMethodSignature *signature = [super methodSignatureForSelector:selector];
+	if (signature != nil) return signature;
+
+	return [super methodSignatureForSelector:@selector(description)];
+}
+
+- (NSString *)combineObjectValue:(id)objectValue andIntegerValue:(NSInteger)integerValue {
+	NSString *appended = [[objectValue description] stringByAppendingString:@"SUBCLASS"];
+	return [super combineObjectValue:appended andIntegerValue:integerValue];
+}
+
+- (void)setObjectValue:(id)objectValue andSecondObjectValue:(id)secondObjectValue {
+	[RACScheduler.currentScheduler schedule:^{
+		[super setObjectValue:objectValue andSecondObjectValue:secondObjectValue];
+	}];
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubjectSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubjectSpec.m
new file mode 100644
index 0000000..6bc175f
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubjectSpec.m
@@ -0,0 +1,335 @@
+//
+//  RACSubjectSpec.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 6/24/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSubscriberExamples.h"
+
+#import <libkern/OSAtomic.h>
+#import "EXTScope.h"
+#import "RACBehaviorSubject.h"
+#import "RACDisposable.h"
+#import "RACReplaySubject.h"
+#import "RACScheduler.h"
+#import "RACSignal+Operations.h"
+#import "RACSubject.h"
+#import "RACUnit.h"
+
+SpecBegin(RACSubject)
+
+describe(@"RACSubject", ^{
+	__block RACSubject *subject;
+	__block NSMutableArray *values;
+
+	__block BOOL success;
+	__block NSError *error;
+
+	beforeEach(^{
+		values = [NSMutableArray array];
+
+		subject = [RACSubject subject];
+		success = YES;
+		error = nil;
+
+		[subject subscribeNext:^(id value) {
+			[values addObject:value];
+		} error:^(NSError *e) {
+			error = e;
+			success = NO;
+		} completed:^{
+			success = YES;
+		}];
+	});
+
+	itShouldBehaveLike(RACSubscriberExamples, ^{
+		return @{
+			RACSubscriberExampleSubscriber: subject,
+			RACSubscriberExampleValuesReceivedBlock: [^{ return [values copy]; } copy],
+			RACSubscriberExampleErrorReceivedBlock: [^{ return error; } copy],
+			RACSubscriberExampleSuccessBlock: [^{ return success; } copy]
+		};
+	});
+});
+
+describe(@"RACReplaySubject", ^{
+	__block RACReplaySubject *subject = nil;
+
+	describe(@"with a capacity of 1", ^{
+		beforeEach(^{
+			subject = [RACReplaySubject replaySubjectWithCapacity:1];
+		});
+		
+		it(@"should send the last value", ^{
+			id firstValue = @"blah";
+			id secondValue = @"more blah";
+			
+			[subject sendNext:firstValue];
+			[subject sendNext:secondValue];
+			
+			__block id valueReceived = nil;
+			[subject subscribeNext:^(id x) {
+				valueReceived = x;
+			}];
+			
+			expect(valueReceived).to.equal(secondValue);
+		});
+		
+		it(@"should send the last value to new subscribers after completion", ^{
+			id firstValue = @"blah";
+			id secondValue = @"more blah";
+			
+			__block id valueReceived = nil;
+			__block NSUInteger nextsReceived = 0;
+			
+			[subject sendNext:firstValue];
+			[subject sendNext:secondValue];
+			
+			expect(nextsReceived).to.equal(0);
+			expect(valueReceived).to.beNil();
+			
+			[subject sendCompleted];
+			
+			[subject subscribeNext:^(id x) {
+				valueReceived = x;
+				nextsReceived++;
+			}];
+			
+			expect(nextsReceived).to.equal(1);
+			expect(valueReceived).to.equal(secondValue);
+		});
+
+		it(@"should not send any values to new subscribers if none were sent originally", ^{
+			[subject sendCompleted];
+
+			__block BOOL nextInvoked = NO;
+			[subject subscribeNext:^(id x) {
+				nextInvoked = YES;
+			}];
+
+			expect(nextInvoked).to.beFalsy();
+		});
+
+		it(@"should resend errors", ^{
+			NSError *error = [NSError errorWithDomain:NSCocoaErrorDomain code:0 userInfo:nil];
+			[subject sendError:error];
+
+			__block BOOL errorSent = NO;
+			[subject subscribeError:^(NSError *sentError) {
+				expect(sentError).to.equal(error);
+				errorSent = YES;
+			}];
+
+			expect(errorSent).to.beTruthy();
+		});
+
+		it(@"should resend nil errors", ^{
+			[subject sendError:nil];
+
+			__block BOOL errorSent = NO;
+			[subject subscribeError:^(NSError *sentError) {
+				expect(sentError).to.beNil();
+				errorSent = YES;
+			}];
+
+			expect(errorSent).to.beTruthy();
+		});
+	});
+
+	describe(@"with an unlimited capacity", ^{
+		beforeEach(^{
+			subject = [RACReplaySubject subject];
+		});
+
+		itShouldBehaveLike(RACSubscriberExamples, ^{
+			return @{
+				RACSubscriberExampleSubscriber: subject,
+				RACSubscriberExampleValuesReceivedBlock: [^{
+					NSMutableArray *values = [NSMutableArray array];
+
+					// This subscription should synchronously dump all values already
+					// received into 'values'.
+					[subject subscribeNext:^(id value) {
+						[values addObject:value];
+					}];
+
+					return values;
+				} copy],
+				RACSubscriberExampleErrorReceivedBlock: [^{
+					__block NSError *error = nil;
+
+					[subject subscribeError:^(NSError *x) {
+						error = x;
+					}];
+
+					return error;
+				} copy],
+				RACSubscriberExampleSuccessBlock: [^{
+					__block BOOL success = YES;
+
+					[subject subscribeError:^(NSError *x) {
+						success = NO;
+					}];
+
+					return success;
+				} copy]
+			};
+		});
+		
+		it(@"should send both values to new subscribers after completion", ^{
+			id firstValue = @"blah";
+			id secondValue = @"more blah";
+			
+			[subject sendNext:firstValue];
+			[subject sendNext:secondValue];
+			[subject sendCompleted];
+			
+			__block BOOL completed = NO;
+			NSMutableArray *valuesReceived = [NSMutableArray array];
+			[subject subscribeNext:^(id x) {
+				[valuesReceived addObject:x];
+			} completed:^{
+				completed = YES;
+			}];
+			
+			expect(valuesReceived.count).to.equal(2);
+			NSArray *expected = [NSArray arrayWithObjects:firstValue, secondValue, nil];
+			expect(valuesReceived).to.equal(expected);
+			expect(completed).to.beTruthy();
+		});
+
+		it(@"should send values in the same order live as when replaying", ^{
+			NSUInteger count = 49317;
+
+			// Just leak it, ain't no thang.
+			__unsafe_unretained volatile id *values = (__unsafe_unretained id *)calloc(count, sizeof(*values));
+			__block volatile int32_t nextIndex = 0;
+
+			[subject subscribeNext:^(NSNumber *value) {
+				int32_t indexPlusOne = OSAtomicIncrement32(&nextIndex);
+				values[indexPlusOne - 1] = value;
+			}];
+
+			dispatch_queue_t queue = dispatch_queue_create("com.github.ReactiveCocoa.RACSubjectSpec", DISPATCH_QUEUE_CONCURRENT);
+			@onExit {
+				dispatch_release(queue);
+			};
+
+			dispatch_suspend(queue);
+			
+			for (NSUInteger i = 0; i < count; i++) {
+				dispatch_async(queue, ^{
+					[subject sendNext:@(i)];
+				});
+			}
+
+			dispatch_resume(queue);
+			dispatch_barrier_sync(queue, ^{
+				[subject sendCompleted];
+			});
+
+			OSMemoryBarrier();
+
+			NSArray *liveValues = [NSArray arrayWithObjects:(id *)values count:(NSUInteger)nextIndex];
+			expect(liveValues.count).to.equal(count);
+			
+			NSArray *replayedValues = subject.toArray;
+			expect(replayedValues.count).to.equal(count);
+
+			// It should return the same ordering for multiple invocations too.
+			expect(replayedValues).to.equal(subject.toArray);
+
+			[replayedValues enumerateObjectsUsingBlock:^(id value, NSUInteger index, BOOL *stop) {
+				expect(liveValues[index]).to.equal(value);
+			}];
+		});
+
+		it(@"should have a current scheduler when replaying", ^{
+			[subject sendNext:RACUnit.defaultUnit];
+
+			__block RACScheduler *currentScheduler;
+			[subject subscribeNext:^(id x) {
+				currentScheduler = RACScheduler.currentScheduler;
+			}];
+
+			expect(currentScheduler).notTo.beNil();
+
+			currentScheduler = nil;
+			dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+				[subject subscribeNext:^(id x) {
+					currentScheduler = RACScheduler.currentScheduler;
+				}];
+			});
+
+			expect(currentScheduler).willNot.beNil();
+		});
+		
+		it(@"should stop replaying when the subscription is disposed", ^{
+			NSMutableArray *values = [NSMutableArray array];
+
+			[subject sendNext:@0];
+			[subject sendNext:@1];
+
+			dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+				__block RACDisposable *disposable = [subject subscribeNext:^(id x) {
+					expect(disposable).notTo.beNil();
+
+					[values addObject:x];
+					[disposable dispose];
+				}];
+			});
+
+			expect(values).will.equal(@[ @0 ]);
+		});
+
+		it(@"should finish replaying before completing", ^{
+			[subject sendNext:@1];
+
+			__block id received;
+			dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+				[subject subscribeNext:^(id x) {
+					received = x;
+				}];
+
+				[subject sendCompleted];
+			});
+
+			expect(received).will.equal(@1);
+		});
+
+		it(@"should finish replaying before erroring", ^{
+			[subject sendNext:@1];
+
+			__block id received;
+			dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+				[subject subscribeNext:^(id x) {
+					received = x;
+				}];
+
+				[subject sendError:[NSError errorWithDomain:@"blah" code:-99 userInfo:nil]];
+			});
+
+			expect(received).will.equal(@1);
+		});
+
+		it(@"should finish replaying before sending new values", ^{
+			[subject sendNext:@1];
+
+			NSMutableArray *received = [NSMutableArray array];
+			dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+				[subject subscribeNext:^(id x) {
+					[received addObject:x];
+				}];
+
+				[subject sendNext:@2];
+			});
+
+			NSArray *expected = @[ @1, @2 ];
+			expect(received).will.equal(expected);
+		});
+	});
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubscriberExamples.h b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubscriberExamples.h
new file mode 100644
index 0000000..edc9e5a
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubscriberExamples.h
@@ -0,0 +1,23 @@
+//
+//  RACSubscriberExamples.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-11-27.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+// The name of the shared examples for implementors of <RACSubscriber>.
+extern NSString * const RACSubscriberExamples;
+
+// id<RACSubscriber>
+extern NSString * const RACSubscriberExampleSubscriber;
+
+// A block which returns an NSArray of the values received so far.
+extern NSString * const RACSubscriberExampleValuesReceivedBlock;
+
+// A block which returns any NSError received so far.
+extern NSString * const RACSubscriberExampleErrorReceivedBlock;
+
+// A block which returns a BOOL indicating whether the subscriber is successful
+// so far.
+extern NSString * const RACSubscriberExampleSuccessBlock;
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubscriberExamples.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubscriberExamples.m
new file mode 100644
index 0000000..946a307
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubscriberExamples.m
@@ -0,0 +1,185 @@
+//
+//  RACSubscriberExamples.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-11-27.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSubscriberExamples.h"
+
+#import "NSObject+RACDeallocating.h"
+#import "RACCompoundDisposable.h"
+#import "RACDisposable.h"
+#import "RACSubject.h"
+#import "RACSubscriber.h"
+
+NSString * const RACSubscriberExamples = @"RACSubscriberExamples";
+NSString * const RACSubscriberExampleSubscriber = @"RACSubscriberExampleSubscriber";
+NSString * const RACSubscriberExampleValuesReceivedBlock = @"RACSubscriberExampleValuesReceivedBlock";
+NSString * const RACSubscriberExampleErrorReceivedBlock = @"RACSubscriberExampleErrorReceivedBlock";
+NSString * const RACSubscriberExampleSuccessBlock = @"RACSubscriberExampleSuccessBlock";
+
+SharedExampleGroupsBegin(RACSubscriberExamples)
+
+sharedExamplesFor(RACSubscriberExamples, ^(NSDictionary *data) {
+	__block NSArray * (^valuesReceived)(void);
+	__block NSError * (^errorReceived)(void);
+	__block BOOL (^success)(void);
+	__block id<RACSubscriber> subscriber;
+	
+	beforeEach(^{
+		valuesReceived = data[RACSubscriberExampleValuesReceivedBlock];
+		errorReceived = data[RACSubscriberExampleErrorReceivedBlock];
+		success = data[RACSubscriberExampleSuccessBlock];
+		subscriber = data[RACSubscriberExampleSubscriber];
+		expect(subscriber).notTo.beNil();
+	});
+
+	it(@"should accept a nil error", ^{
+		[subscriber sendError:nil];
+
+		expect(success()).to.beFalsy();
+		expect(errorReceived()).to.beNil();
+		expect(valuesReceived()).to.equal(@[]);
+	});
+
+	describe(@"with values", ^{
+		__block NSSet *values;
+		
+		beforeEach(^{
+			NSMutableSet *mutableValues = [NSMutableSet set];
+			for (NSUInteger i = 0; i < 20; i++) {
+				[mutableValues addObject:@(i)];
+			}
+
+			values = [mutableValues copy];
+		});
+
+		it(@"should send nexts serially, even when delivered from multiple threads", ^{
+			NSArray *allValues = values.allObjects;
+			dispatch_apply(allValues.count, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), [^(size_t index) {
+				[subscriber sendNext:allValues[index]];
+			} copy]);
+
+			expect(success()).to.beTruthy();
+			expect(errorReceived()).to.beNil();
+
+			NSSet *valuesReceivedSet = [NSSet setWithArray:valuesReceived()];
+			expect(valuesReceivedSet).to.equal(values);
+		});
+	});
+
+	describe(@"multiple subscriptions", ^{
+		__block RACSubject *first;
+		__block RACSubject *second;
+
+		beforeEach(^{
+			first = [RACSubject subject];
+			[first subscribe:subscriber];
+
+			second = [RACSubject subject];
+			[second subscribe:subscriber];
+		});
+
+		it(@"should send values from all subscriptions", ^{
+			[first sendNext:@"foo"];
+			[second sendNext:@"bar"];
+			[first sendNext:@"buzz"];
+			[second sendNext:@"baz"];
+
+			expect(success()).to.beTruthy();
+			expect(errorReceived()).to.beNil();
+
+			NSArray *expected = @[ @"foo", @"bar", @"buzz", @"baz" ];
+			expect(valuesReceived()).to.equal(expected);
+		});
+
+		it(@"should terminate after the first error from any subscription", ^{
+			NSError *error = [NSError errorWithDomain:@"" code:-1 userInfo:nil];
+
+			[first sendNext:@"foo"];
+			[second sendError:error];
+			[first sendNext:@"buzz"];
+
+			expect(success()).to.beFalsy();
+			expect(errorReceived()).to.equal(error);
+
+			NSArray *expected = @[ @"foo" ];
+			expect(valuesReceived()).to.equal(expected);
+		});
+
+		it(@"should terminate after the first completed from any subscription", ^{
+			[first sendNext:@"foo"];
+			[second sendNext:@"bar"];
+			[first sendCompleted];
+			[second sendNext:@"baz"];
+
+			expect(success()).to.beTruthy();
+			expect(errorReceived()).to.beNil();
+
+			NSArray *expected = @[ @"foo", @"bar" ];
+			expect(valuesReceived()).to.equal(expected);
+		});
+
+		it(@"should dispose of all current subscriptions upon termination", ^{
+			__block BOOL firstDisposed = NO;
+			RACSignal *firstDisposableSignal = [RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+				return [RACDisposable disposableWithBlock:^{
+					firstDisposed = YES;
+				}];
+			}];
+
+			__block BOOL secondDisposed = NO;
+			RACSignal *secondDisposableSignal = [RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+				return [RACDisposable disposableWithBlock:^{
+					secondDisposed = YES;
+				}];
+			}];
+
+			[firstDisposableSignal subscribe:subscriber];
+			[secondDisposableSignal subscribe:subscriber];
+			
+			expect(firstDisposed).to.beFalsy();
+			expect(secondDisposed).to.beFalsy();
+
+			[first sendCompleted];
+
+			expect(firstDisposed).to.beTruthy();
+			expect(secondDisposed).to.beTruthy();
+		});
+
+		it(@"should dispose of future subscriptions upon termination", ^{
+			__block BOOL disposed = NO;
+			RACSignal *disposableSignal = [RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+				return [RACDisposable disposableWithBlock:^{
+					disposed = YES;
+				}];
+			}];
+
+			[first sendCompleted];
+			expect(disposed).to.beFalsy();
+
+			[disposableSignal subscribe:subscriber];
+			expect(disposed).to.beTruthy();
+		});
+	});
+
+	describe(@"memory management", ^{
+		it(@"should not retain disposed disposables", ^{
+			__block BOOL disposableDeallocd = NO;
+			@autoreleasepool {
+				RACCompoundDisposable *disposable __attribute__((objc_precise_lifetime)) = [RACCompoundDisposable disposableWithBlock:^{}];
+				[disposable.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+					disposableDeallocd = YES;
+				}]];
+
+				[subscriber didSubscribeWithDisposable:disposable];
+				[disposable dispose];
+			}
+			expect(disposableDeallocd).to.beTruthy();
+		});
+	});
+});
+
+SharedExampleGroupsEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubscriberSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubscriberSpec.m
new file mode 100644
index 0000000..8a1725d
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubscriberSpec.m
@@ -0,0 +1,130 @@
+//
+//  RACSubscriberSpec.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-11-27.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSubscriberExamples.h"
+
+#import "RACSubscriber.h"
+#import "RACSubscriber+Private.h"
+#import <libkern/OSAtomic.h>
+
+SpecBegin(RACSubscriber)
+
+__block RACSubscriber *subscriber;
+__block NSMutableArray *values;
+
+__block volatile BOOL finished;
+__block volatile int32_t nextsAfterFinished;
+
+__block BOOL success;
+__block NSError *error;
+
+beforeEach(^{
+	values = [NSMutableArray array];
+
+	finished = NO;
+	nextsAfterFinished = 0;
+
+	success = YES;
+	error = nil;
+
+	subscriber = [RACSubscriber subscriberWithNext:^(id value) {
+		if (finished) OSAtomicIncrement32Barrier(&nextsAfterFinished);
+
+		[values addObject:value];
+	} error:^(NSError *e) {
+		error = e;
+		success = NO;
+	} completed:^{
+		success = YES;
+	}];
+});
+
+itShouldBehaveLike(RACSubscriberExamples, ^{
+	return @{
+		RACSubscriberExampleSubscriber: subscriber,
+		RACSubscriberExampleValuesReceivedBlock: [^{ return [values copy]; } copy],
+		RACSubscriberExampleErrorReceivedBlock: [^{ return error; } copy],
+		RACSubscriberExampleSuccessBlock: [^{ return success; } copy]
+	};
+});
+
+describe(@"finishing", ^{
+	__block void (^sendValues)(void);
+	__block BOOL expectedSuccess;
+
+	__block dispatch_group_t dispatchGroup;
+	__block dispatch_queue_t concurrentQueue;
+
+	beforeEach(^{
+		dispatchGroup = dispatch_group_create();
+		expect(dispatchGroup).notTo.beNil();
+
+		concurrentQueue = dispatch_queue_create("com.github.ReactiveCocoa.RACSubscriberSpec", DISPATCH_QUEUE_CONCURRENT);
+		expect(concurrentQueue).notTo.beNil();
+
+		dispatch_suspend(concurrentQueue);
+
+		sendValues = [^{
+			for (NSUInteger i = 0; i < 15; i++) {
+				dispatch_group_async(dispatchGroup, concurrentQueue, ^{
+					[subscriber sendNext:@(i)];
+				});
+			}
+		} copy];
+
+		sendValues();
+	});
+
+	afterEach(^{
+		sendValues();
+		dispatch_resume(concurrentQueue);
+
+		// Time out after one second.
+		dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC));
+		expect(dispatch_group_wait(dispatchGroup, time)).to.equal(0);
+		
+		dispatch_release(dispatchGroup);
+		dispatchGroup = NULL;
+
+		dispatch_release(concurrentQueue);
+		concurrentQueue = NULL;
+
+		expect(nextsAfterFinished).to.equal(0);
+
+		if (expectedSuccess) {
+			expect(success).to.beTruthy();
+			expect(error).to.beNil();
+		} else {
+			expect(success).to.beFalsy();
+		}
+	});
+
+	it(@"should never invoke next after sending completed", ^{
+		expectedSuccess = YES;
+
+		dispatch_group_async(dispatchGroup, concurrentQueue, ^{
+			[subscriber sendCompleted];
+
+			finished = YES;
+			OSMemoryBarrier();
+		});
+	});
+
+	it(@"should never invoke next after sending error", ^{
+		expectedSuccess = NO;
+
+		dispatch_group_async(dispatchGroup, concurrentQueue, ^{
+			[subscriber sendError:nil];
+
+			finished = YES;
+			OSMemoryBarrier();
+		});
+	});
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubscriptingAssignmentTrampolineSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubscriptingAssignmentTrampolineSpec.m
new file mode 100644
index 0000000..9165f11
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubscriptingAssignmentTrampolineSpec.m
@@ -0,0 +1,33 @@
+//
+//  RACSubscriptingAssignmentTrampolineSpec.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 9/24/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSubscriptingAssignmentTrampoline.h"
+#import "RACPropertySignalExamples.h"
+#import "RACTestObject.h"
+#import "RACSubject.h"
+
+SpecBegin(RACSubscriptingAssignmentTrampoline)
+
+id setupBlock = ^(RACTestObject *testObject, NSString *keyPath, id nilValue, RACSignal *signal) {
+	[[RACSubscriptingAssignmentTrampoline alloc] initWithTarget:testObject nilValue:nilValue][keyPath] = signal;
+};
+
+itShouldBehaveLike(RACPropertySignalExamples, ^{
+	return @{ RACPropertySignalExamplesSetupBlock: setupBlock };
+});
+
+it(@"should expand the RAC macro properly", ^{
+	RACSubject *subject = [RACSubject subject];
+	RACTestObject *testObject = [[RACTestObject alloc] init];
+	RAC(testObject, objectValue) = subject;
+
+	[subject sendNext:@1];
+	expect(testObject.objectValue).to.equal(@1);
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACTargetQueueSchedulerSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTargetQueueSchedulerSpec.m
new file mode 100644
index 0000000..b193844
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTargetQueueSchedulerSpec.m
@@ -0,0 +1,50 @@
+//
+//  RACTargetQueueSchedulerSpec.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 6/7/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACTargetQueueScheduler.h"
+#import <libkern/OSAtomic.h>
+
+SpecBegin(RACTargetQueueScheduler)
+
+it(@"should have a valid current scheduler", ^{
+	dispatch_queue_t queue = dispatch_queue_create("test-queue", DISPATCH_QUEUE_SERIAL);
+	RACScheduler *scheduler = [[RACTargetQueueScheduler alloc] initWithName:@"test-scheduler" targetQueue:queue];
+	__block RACScheduler *currentScheduler;
+	[scheduler schedule:^{
+		currentScheduler = RACScheduler.currentScheduler;
+	}];
+
+	expect(currentScheduler).will.equal(scheduler);
+
+	dispatch_release(queue);
+});
+
+it(@"should schedule blocks FIFO even when given a concurrent queue", ^{
+	dispatch_queue_t queue = dispatch_queue_create("test-queue", DISPATCH_QUEUE_CONCURRENT);
+	RACScheduler *scheduler = [[RACTargetQueueScheduler alloc] initWithName:@"test-scheduler" targetQueue:queue];
+	__block volatile int32_t startedCount = 0;
+	__block volatile uint32_t waitInFirst = 1;
+	[scheduler schedule:^{
+		OSAtomicIncrement32Barrier(&startedCount);
+		while (waitInFirst == 1) ;
+	}];
+
+	[scheduler schedule:^{
+		OSAtomicIncrement32Barrier(&startedCount);
+	}];
+
+	expect(startedCount).will.equal(1);
+
+	OSAtomicAnd32Barrier(0, &waitInFirst);
+
+	expect(startedCount).will.equal(2);
+
+	dispatch_release(queue);
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestExampleScheduler.h b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestExampleScheduler.h
new file mode 100644
index 0000000..0470d98
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestExampleScheduler.h
@@ -0,0 +1,15 @@
+//
+//  RACTestExampleScheduler.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 6/7/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <ReactiveCocoa/ReactiveCocoa.h>
+
+@interface RACTestExampleScheduler : RACQueueScheduler
+
+- (id)initWithQueue:(dispatch_queue_t)queue;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestExampleScheduler.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestExampleScheduler.m
new file mode 100644
index 0000000..859055c
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestExampleScheduler.m
@@ -0,0 +1,39 @@
+//
+//  RACTestExampleScheduler.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 6/7/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACTestExampleScheduler.h"
+#import "RACQueueScheduler+Subclass.h"
+
+@implementation RACTestExampleScheduler
+
+#pragma mark Lifecycle
+
+- (id)initWithQueue:(dispatch_queue_t)queue {
+	return [super initWithName:nil queue:queue];
+}
+
+#pragma mark RACScheduler
+
+- (RACDisposable *)schedule:(void (^)(void))block {
+	dispatch_async(self.queue, ^{
+		[self performAsCurrentScheduler:block];
+	});
+
+	return nil;
+}
+
+- (RACDisposable *)after:(NSDate *)date schedule:(void (^)(void))block {
+	dispatch_time_t when = dispatch_time(DISPATCH_TIME_NOW, (int64_t)([date timeIntervalSinceNow] * NSEC_PER_SEC));
+	dispatch_after(when, self.queue, ^{
+		[self performAsCurrentScheduler:block];
+	});
+
+	return nil;
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestObject.h b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestObject.h
new file mode 100644
index 0000000..a963b0a
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestObject.h
@@ -0,0 +1,86 @@
+//
+//  RACTestObject.h
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 9/18/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+typedef struct {
+	long long integerField;
+	double doubleField;
+} RACTestStruct;
+
+@protocol RACTestProtocol <NSObject>
+
+@optional
+- (void)optionalProtocolMethodWithObjectValue:(id)objectValue;
+
+@end
+
+@interface RACTestObject : NSObject <RACTestProtocol>
+
+@property (nonatomic, strong) id objectValue;
+@property (nonatomic, strong) id secondObjectValue;
+@property (nonatomic, strong) RACTestObject *strongTestObjectValue;
+@property (nonatomic, weak) RACTestObject *weakTestObjectValue;
+@property (nonatomic, weak) id<RACTestProtocol> weakObjectWithProtocol;
+@property (nonatomic, assign) NSInteger integerValue;
+// Holds a copy of the string.
+@property (nonatomic, assign) char *charPointerValue;
+// Holds a copy of the string.
+@property (nonatomic, assign) const char *constCharPointerValue;
+@property (nonatomic, assign) CGRect rectValue;
+@property (nonatomic, assign) CGSize sizeValue;
+@property (nonatomic, assign) CGPoint pointValue;
+@property (nonatomic, assign) NSRange rangeValue;
+@property (nonatomic, assign) RACTestStruct structValue;
+@property (nonatomic, assign) _Bool c99BoolValue;
+@property (nonatomic, copy) NSString *stringValue;
+@property (nonatomic, copy) NSArray *arrayValue;
+@property (nonatomic, copy) NSSet *setValue;
+@property (nonatomic, copy) NSOrderedSet *orderedSetValue;
+@property (nonatomic, strong) id slowObjectValue;
+
+// Returns a new object each time, with the integerValue set to 42.
+@property (nonatomic, copy, readonly) RACTestObject *dynamicObjectProperty;
+
+// Returns a new object each time, with the integerValue set to 42.
+- (RACTestObject *)dynamicObjectMethod;
+
+// Whether to allow -setNilValueForKey: to be invoked without throwing an
+// exception.
+@property (nonatomic, assign) BOOL catchSetNilValueForKey;
+
+// Has -setObjectValue:andIntegerValue: been called?
+@property (nonatomic, assign) BOOL hasInvokedSetObjectValueAndIntegerValue;
+
+// Has -setObjectValue:andSecondObjectValue: been called?
+@property (nonatomic, assign) BOOL hasInvokedSetObjectValueAndSecondObjectValue;
+
+- (void)setObjectValue:(id)objectValue andIntegerValue:(NSInteger)integerValue;
+- (void)setObjectValue:(id)objectValue andSecondObjectValue:(id)secondObjectValue;
+
+// Returns a string of the form "objectValue: integerValue".
+- (NSString *)combineObjectValue:(id)objectValue andIntegerValue:(NSInteger)integerValue;
+- (NSString *)combineObjectValue:(id)objectValue andSecondObjectValue:(id)secondObjectValue;
+
+- (void)lifeIsGood:(id)sender;
+
++ (void)lifeIsGood:(id)sender;
+
+- (NSRange)returnRangeValueWithObjectValue:(id)objectValue andIntegerValue:(NSInteger)integerValue;
+
+// Writes 5 to the int pointed to by intPointer.
+- (void)write5ToIntPointer:(int *)intPointer;
+
+- (NSInteger)doubleInteger:(NSInteger)integer;
+- (char *)doubleString:(char *)string;
+- (const char *)doubleConstString:(const char *)string;
+- (RACTestStruct)doubleStruct:(RACTestStruct)testStruct;
+
+- (dispatch_block_t)wrapBlock:(dispatch_block_t)block;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestObject.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestObject.m
new file mode 100644
index 0000000..f590703
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestObject.m
@@ -0,0 +1,121 @@
+//
+//  RACTestObject.m
+//  ReactiveCocoa
+//
+//  Created by Josh Abernathy on 9/18/12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACTestObject.h"
+
+@implementation RACTestObject
+
+- (void)dealloc {
+	free(_charPointerValue);
+	free((void *)_constCharPointerValue);
+}
+
+- (void)setNilValueForKey:(NSString *)key {
+	if (!self.catchSetNilValueForKey) [super setNilValueForKey:key];
+}
+
+- (void)setCharPointerValue:(char *)charPointerValue {
+	if (charPointerValue == _charPointerValue) return;
+	free(_charPointerValue);
+	_charPointerValue = strdup(charPointerValue);
+}
+
+- (void)setConstCharPointerValue:(const char *)constCharPointerValue {
+	if (constCharPointerValue == _constCharPointerValue) return;
+	free((void *)_constCharPointerValue);
+	_constCharPointerValue = strdup(constCharPointerValue);
+}
+
+- (void)setObjectValue:(id)objectValue andIntegerValue:(NSInteger)integerValue {
+	self.hasInvokedSetObjectValueAndIntegerValue = YES;
+	self.objectValue = objectValue;
+	self.integerValue = integerValue;
+}
+
+- (void)setObjectValue:(id)objectValue andSecondObjectValue:(id)secondObjectValue {
+	self.hasInvokedSetObjectValueAndSecondObjectValue = YES;
+	self.objectValue = objectValue;
+	self.secondObjectValue = secondObjectValue;
+}
+
+- (void)setSlowObjectValue:(id)value {
+	[NSThread sleepForTimeInterval:0.02];
+	_slowObjectValue = value;
+}
+
+- (NSString *)combineObjectValue:(id)objectValue andIntegerValue:(NSInteger)integerValue {
+	return [NSString stringWithFormat:@"%@: %ld", objectValue, (long)integerValue];
+}
+
+- (NSString *)combineObjectValue:(id)objectValue andSecondObjectValue:(id)secondObjectValue {
+	return [NSString stringWithFormat:@"%@: %@", objectValue, secondObjectValue];
+}
+
+- (void)lifeIsGood:(id)sender {
+	
+}
+
++ (void)lifeIsGood:(id)sender {
+	
+}
+
+- (NSRange)returnRangeValueWithObjectValue:(id)objectValue andIntegerValue:(NSInteger)integerValue {
+	return NSMakeRange((NSUInteger)[objectValue integerValue], (NSUInteger)integerValue);
+}
+
+- (RACTestObject *)dynamicObjectProperty {
+	return [self dynamicObjectMethod];
+}
+
+- (RACTestObject *)dynamicObjectMethod {
+	RACTestObject *testObject = [[RACTestObject alloc] init];
+	testObject.integerValue = 42;
+	return testObject;
+}
+
+- (void)write5ToIntPointer:(int *)intPointer {
+	NSCParameterAssert(intPointer != NULL);
+	*intPointer = 5;
+}
+
+- (NSInteger)doubleInteger:(NSInteger)integer {
+	return integer * 2;
+}
+
+- (char *)doubleString:(char *)string {
+	size_t doubledSize = strlen(string) * 2 + 1;
+	char *doubledString = malloc(sizeof(char) * doubledSize);
+
+	doubledString[0] = '\0';
+	strlcat(doubledString, string, doubledSize);
+	strlcat(doubledString, string, doubledSize);
+
+	dispatch_async(dispatch_get_main_queue(), ^{
+		free(doubledString);
+	});
+
+	return doubledString;
+}
+
+- (const char *)doubleConstString:(const char *)string {
+	return [self doubleString:(char *)string];
+}
+
+- (RACTestStruct)doubleStruct:(RACTestStruct)testStruct {
+	testStruct.integerField *= 2;
+	testStruct.doubleField *= 2;
+	return testStruct;
+}
+
+- (dispatch_block_t)wrapBlock:(dispatch_block_t)block {
+	return ^{
+		block();
+	};
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestSchedulerSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestSchedulerSpec.m
new file mode 100644
index 0000000..baa8994
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestSchedulerSpec.m
@@ -0,0 +1,175 @@
+//
+//  RACTestSchedulerSpec.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-07-06.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACTestScheduler.h"
+
+SpecBegin(RACTestScheduler)
+
+__block RACTestScheduler *scheduler;
+
+beforeEach(^{
+	scheduler = [[RACTestScheduler alloc] init];
+	expect(scheduler).notTo.beNil();
+});
+
+it(@"should do nothing when stepping while empty", ^{
+	[scheduler step];
+	[scheduler step:5];
+	[scheduler stepAll];
+});
+
+it(@"should execute the earliest enqueued block when stepping", ^{
+	__block BOOL firstExecuted = NO;
+	[scheduler schedule:^{
+		firstExecuted = YES;
+	}];
+
+	__block BOOL secondExecuted = NO;
+	[scheduler schedule:^{
+		secondExecuted = YES;
+	}];
+
+	expect(firstExecuted).to.beFalsy();
+	expect(secondExecuted).to.beFalsy();
+
+	[scheduler step];
+	expect(firstExecuted).to.beTruthy();
+	expect(secondExecuted).to.beFalsy();
+
+	[scheduler step];
+	expect(secondExecuted).to.beTruthy();
+});
+
+it(@"should step multiple times", ^{
+	__block BOOL firstExecuted = NO;
+	[scheduler schedule:^{
+		firstExecuted = YES;
+	}];
+
+	__block BOOL secondExecuted = NO;
+	[scheduler schedule:^{
+		secondExecuted = YES;
+	}];
+
+	__block BOOL thirdExecuted = NO;
+	[scheduler schedule:^{
+		thirdExecuted = YES;
+	}];
+
+	expect(firstExecuted).to.beFalsy();
+	expect(secondExecuted).to.beFalsy();
+	expect(thirdExecuted).to.beFalsy();
+
+	[scheduler step:2];
+	expect(firstExecuted).to.beTruthy();
+	expect(secondExecuted).to.beTruthy();
+	expect(thirdExecuted).to.beFalsy();
+
+	[scheduler step:1];
+	expect(thirdExecuted).to.beTruthy();
+});
+
+it(@"should step through all scheduled blocks", ^{
+	__block NSUInteger executions = 0;
+	for (NSUInteger i = 0; i < 10; i++) {
+		[scheduler schedule:^{
+			executions++;
+		}];
+	}
+
+	expect(executions).to.equal(0);
+
+	[scheduler stepAll];
+	expect(executions).to.equal(10);
+});
+
+it(@"should execute blocks in date order when stepping", ^{
+	__block BOOL laterExecuted = NO;
+	[scheduler after:[NSDate distantFuture] schedule:^{
+		laterExecuted = YES;
+	}];
+
+	__block BOOL earlierExecuted = NO;
+	[scheduler after:[NSDate dateWithTimeIntervalSinceNow:20] schedule:^{
+		earlierExecuted = YES;
+	}];
+
+	expect(earlierExecuted).to.beFalsy();
+	expect(laterExecuted).to.beFalsy();
+
+	[scheduler step];
+	expect(earlierExecuted).to.beTruthy();
+	expect(laterExecuted).to.beFalsy();
+
+	[scheduler step];
+	expect(laterExecuted).to.beTruthy();
+});
+
+it(@"should execute delayed blocks in date order when stepping", ^{
+	__block BOOL laterExecuted = NO;
+	[scheduler afterDelay:100 schedule:^{
+		laterExecuted = YES;
+	}];
+
+	__block BOOL earlierExecuted = NO;
+	[scheduler afterDelay:50 schedule:^{
+		earlierExecuted = YES;
+	}];
+
+	expect(earlierExecuted).to.beFalsy();
+	expect(laterExecuted).to.beFalsy();
+
+	[scheduler step];
+	expect(earlierExecuted).to.beTruthy();
+	expect(laterExecuted).to.beFalsy();
+
+	[scheduler step];
+	expect(laterExecuted).to.beTruthy();
+});
+
+it(@"should execute a repeating blocks in date order", ^{
+	__block NSUInteger firstExecutions = 0;
+	[scheduler after:[NSDate dateWithTimeIntervalSinceNow:20] repeatingEvery:5 withLeeway:0 schedule:^{
+		firstExecutions++;
+	}];
+
+	__block NSUInteger secondExecutions = 0;
+	[scheduler after:[NSDate dateWithTimeIntervalSinceNow:22] repeatingEvery:10 withLeeway:0 schedule:^{
+		secondExecutions++;
+	}];
+
+	expect(firstExecutions).to.equal(0);
+	expect(secondExecutions).to.equal(0);
+
+	// 20 ticks
+	[scheduler step];
+	expect(firstExecutions).to.equal(1);
+	expect(secondExecutions).to.equal(0);
+
+	// 22 ticks
+	[scheduler step];
+	expect(firstExecutions).to.equal(1);
+	expect(secondExecutions).to.equal(1);
+
+	// 25 ticks
+	[scheduler step];
+	expect(firstExecutions).to.equal(2);
+	expect(secondExecutions).to.equal(1);
+
+	// 30 ticks
+	[scheduler step];
+	expect(firstExecutions).to.equal(3);
+	expect(secondExecutions).to.equal(1);
+
+	// 32 ticks
+	[scheduler step];
+	expect(firstExecutions).to.equal(3);
+	expect(secondExecutions).to.equal(2);
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestUIButton.h b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestUIButton.h
new file mode 100644
index 0000000..03e9716
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestUIButton.h
@@ -0,0 +1,16 @@
+//
+//  RACTestUIButton.h
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-06-15.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <UIKit/UIKit.h>
+
+// Enables use of -sendActionsForControlEvents: in unit tests.
+@interface RACTestUIButton : UIButton
+
++ (instancetype)button;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestUIButton.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestUIButton.m
new file mode 100644
index 0000000..48b2674
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestUIButton.m
@@ -0,0 +1,27 @@
+//
+//  RACTestUIButton.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-06-15.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACTestUIButton.h"
+
+@implementation RACTestUIButton
+
++ (instancetype)button {
+	RACTestUIButton *button = [self buttonWithType:UIButtonTypeCustom];
+	return button;
+}
+
+// Required for unit testing – controls don't work normally
+// outside of normal apps. 
+-(void)sendAction:(SEL)action to:(id)target forEvent:(UIEvent *)event {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
+	[target performSelector:action withObject:self];
+#pragma clang diagnostic pop
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACTupleSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTupleSpec.m
new file mode 100644
index 0000000..e85d76d
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTupleSpec.m
@@ -0,0 +1,120 @@
+//
+//  RACTupleSpec.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-12-12.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import "RACTuple.h"
+#import "RACUnit.h"
+
+SpecBegin(RACTuple)
+
+describe(@"RACTupleUnpack", ^{
+	it(@"should unpack a single value", ^{
+		RACTupleUnpack(RACUnit *value) = [RACTuple tupleWithObjects:RACUnit.defaultUnit, nil];
+		expect(value).to.equal(RACUnit.defaultUnit);
+	});
+
+	it(@"should translate RACTupleNil", ^{
+		RACTupleUnpack(id value) = [RACTuple tupleWithObjects:RACTupleNil.tupleNil, nil];
+		expect(value).to.beNil();
+	});
+
+	it(@"should unpack multiple values", ^{
+		RACTupleUnpack(NSString *str, NSNumber *num) = [RACTuple tupleWithObjects:@"foobar", @5, nil];
+
+		expect(str).to.equal(@"foobar");
+		expect(num).to.equal(@5);
+	});
+
+	it(@"should fill in missing values with nil", ^{
+		RACTupleUnpack(NSString *str, NSNumber *num) = [RACTuple tupleWithObjects:@"foobar", nil];
+
+		expect(str).to.equal(@"foobar");
+		expect(num).to.beNil();
+	});
+
+	it(@"should skip any values not assigned to", ^{
+		RACTupleUnpack(NSString *str, NSNumber *num) = [RACTuple tupleWithObjects:@"foobar", @5, RACUnit.defaultUnit, nil];
+
+		expect(str).to.equal(@"foobar");
+		expect(num).to.equal(@5);
+	});
+
+	it(@"should keep an unpacked value alive when captured in a block", ^{
+		__weak id weakPtr = nil;
+		id (^block)(void) = nil;
+
+		@autoreleasepool {
+			RACTupleUnpack(NSString *str) = [RACTuple tupleWithObjects:[[NSMutableString alloc] init], nil];
+
+			weakPtr = str;
+			expect(weakPtr).notTo.beNil();
+
+			block = [^{
+				return str;
+			} copy];
+		}
+
+		expect(weakPtr).notTo.beNil();
+		expect(block()).to.equal(weakPtr);
+	});
+});
+
+describe(@"RACTuplePack", ^{
+	it(@"should pack a single value", ^{
+		RACTuple *tuple = [RACTuple tupleWithObjects:RACUnit.defaultUnit, nil];
+		expect(RACTuplePack(RACUnit.defaultUnit)).to.equal(tuple);
+	});
+	
+	it(@"should translate nil", ^{
+		RACTuple *tuple = [RACTuple tupleWithObjects:RACTupleNil.tupleNil, nil];
+		expect(RACTuplePack(nil)).to.equal(tuple);
+	});
+	
+	it(@"should pack multiple values", ^{
+		NSString *string = @"foobar";
+		NSNumber *number = @5;
+		RACTuple *tuple = [RACTuple tupleWithObjects:string, number, nil];
+		expect(RACTuplePack(string, number)).to.equal(tuple);
+	});
+});
+
+describe(@"-tupleByAddingObject:", ^{
+	__block RACTuple *tuple;
+
+	beforeEach(^{
+		tuple = RACTuplePack(@"foo", nil, @"bar");
+	});
+
+	it(@"should add a non-nil object", ^{
+		RACTuple *newTuple = [tuple tupleByAddingObject:@"buzz"];
+		expect(newTuple.count).to.equal(4);
+		expect(newTuple[0]).to.equal(@"foo");
+		expect(newTuple[1]).to.beNil();
+		expect(newTuple[2]).to.equal(@"bar");
+		expect(newTuple[3]).to.equal(@"buzz");
+	});
+
+	it(@"should add nil", ^{
+		RACTuple *newTuple = [tuple tupleByAddingObject:nil];
+		expect(newTuple.count).to.equal(4);
+		expect(newTuple[0]).to.equal(@"foo");
+		expect(newTuple[1]).to.beNil();
+		expect(newTuple[2]).to.equal(@"bar");
+		expect(newTuple[3]).to.beNil();
+	});
+
+	it(@"should add NSNull", ^{
+		RACTuple *newTuple = [tuple tupleByAddingObject:NSNull.null];
+		expect(newTuple.count).to.equal(4);
+		expect(newTuple[0]).to.equal(@"foo");
+		expect(newTuple[1]).to.beNil();
+		expect(newTuple[2]).to.equal(@"bar");
+		expect(newTuple[3]).to.equal(NSNull.null);
+	});
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/ReactiveCocoaTests-Info.plist b/ReactiveCocoaFramework/ReactiveCocoaTests/ReactiveCocoaTests-Info.plist
new file mode 100644
index 0000000..d783a87
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/ReactiveCocoaTests-Info.plist
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>en</string>
+	<key>CFBundleExecutable</key>
+	<string>${EXECUTABLE_NAME}</string>
+	<key>CFBundleIdentifier</key>
+	<string>com.github.${PRODUCT_NAME:rfc1034identifier}</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundlePackageType</key>
+	<string>BNDL</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleVersion</key>
+	<string>1</string>
+</dict>
+</plist>
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch b/ReactiveCocoaFramework/ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch
new file mode 100644
index 0000000..970a36e
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch
@@ -0,0 +1,14 @@
+//
+//  ReactiveCocoaTests-Prefix.pch
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2012-11-29.
+//  Copyright (c) 2012 GitHub, Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import <CoreGraphics/CGGeometry.h>
+
+#define EXP_SHORTHAND
+#import "Specta.h"
+#import "Expecta.h"
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIActionSheetRACSupportSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/UIActionSheetRACSupportSpec.m
new file mode 100644
index 0000000..a695ea5
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIActionSheetRACSupportSpec.m
@@ -0,0 +1,36 @@
+//
+//  UIActionSheetRACSupportSpec.m
+//  ReactiveCocoa
+//
+//  Created by Dave Lee on 2013-06-22.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSignal.h"
+#import "RACSignal+Operations.h"
+#import "UIActionSheet+RACSignalSupport.h"
+
+SpecBegin(UIActionSheetRACSupportSpec)
+
+describe(@"-rac_buttonClickedSignal", ^{
+	__block UIActionSheet *actionSheet;
+
+	beforeEach(^{
+		actionSheet = [[UIActionSheet alloc] init];
+		[actionSheet addButtonWithTitle:@"Button 0"];
+		[actionSheet addButtonWithTitle:@"Button 1"];
+		expect(actionSheet).notTo.beNil();
+	});
+
+	it(@"should send the index of the clicked button", ^{
+		__block NSNumber *index = nil;
+		[actionSheet.rac_buttonClickedSignal subscribeNext:^(NSNumber *i) {
+			index = i;
+		}];
+
+		[actionSheet.delegate actionSheet:actionSheet clickedButtonAtIndex:1];
+		expect(index).to.equal(@1);
+	});
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIAlertViewRACSupportSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/UIAlertViewRACSupportSpec.m
new file mode 100644
index 0000000..f37294e
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIAlertViewRACSupportSpec.m
@@ -0,0 +1,34 @@
+//
+//  UIAlertViewRACSupportSpec.m
+//  ReactiveCocoa
+//
+//  Created by Henrik Hodne on 6/16/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <objc/message.h>
+#import "RACSignal.h"
+#import "UIAlertView+RACSignalSupport.h"
+
+SpecBegin(UIAlertViewRACSupport)
+
+describe(@"UIAlertView", ^{
+	__block UIAlertView *alertView;
+
+	beforeEach(^{
+		alertView = [[UIAlertView alloc] initWithFrame:CGRectZero];
+		expect(alertView).notTo.beNil();
+	});
+
+	it(@"sends the index of the clicked button to the buttonClickedSignal when a button is clicked", ^{
+		__block NSInteger index = -1;
+		[alertView.rac_buttonClickedSignal subscribeNext:^(NSNumber *sentIndex) {
+			index = sentIndex.integerValue;
+		}];
+
+		[alertView.delegate alertView:alertView clickedButtonAtIndex:2];
+		expect(index).to.equal(2);
+	});
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIBarButtonItemRACSupportSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/UIBarButtonItemRACSupportSpec.m
new file mode 100644
index 0000000..089630b
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIBarButtonItemRACSupportSpec.m
@@ -0,0 +1,40 @@
+//
+//  UIBarButtonItemRACSupportSpec.m
+//  ReactiveCocoa
+//
+//  Created by Kyle LeNeau on 4/13/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACControlCommandExamples.h"
+
+#import "UIBarButtonItem+RACCommandSupport.h"
+#import "RACCommand.h"
+#import "RACDisposable.h"
+
+SpecBegin(UIBarButtonItemRACSupport)
+
+describe(@"UIBarButtonItem", ^{
+	__block UIBarButtonItem *button;
+	
+	beforeEach(^{
+		button = [[UIBarButtonItem alloc] init];
+		expect(button).notTo.beNil();
+	});
+
+	itShouldBehaveLike(RACControlCommandExamples, ^{
+		return @{
+			RACControlCommandExampleControl: button,
+			RACControlCommandExampleActivateBlock: ^(UIBarButtonItem *button) {
+				NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:[button.target methodSignatureForSelector:button.action]];
+				invocation.selector = button.action;
+
+				id target = button.target;
+				[invocation setArgument:&target atIndex:2];
+				[invocation invokeWithTarget:target];
+			}
+		};
+	});
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIButtonRACSupportSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/UIButtonRACSupportSpec.m
new file mode 100644
index 0000000..0fefa92
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIButtonRACSupportSpec.m
@@ -0,0 +1,39 @@
+//
+//  UIButtonRACSupportSpec.m
+//  ReactiveCocoa
+//
+//  Created by Ash Furrow on 2013-06-06.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACControlCommandExamples.h"
+#import "RACTestUIButton.h"
+
+#import "UIButton+RACCommandSupport.h"
+#import "RACCommand.h"
+#import "RACDisposable.h"
+
+SpecBegin(UIButtonRACSupport)
+
+describe(@"UIButton", ^{
+	__block UIButton *button;
+	
+	beforeEach(^{
+		button = [RACTestUIButton button];
+		expect(button).notTo.beNil();
+	});
+
+	itShouldBehaveLike(RACControlCommandExamples, ^{
+		return @{
+			RACControlCommandExampleControl: button,
+			RACControlCommandExampleActivateBlock: ^(UIButton *button) {
+				#pragma clang diagnostic push
+				#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
+				[button sendActionsForControlEvents:UIControlEventTouchUpInside];
+				#pragma clang diagnostic pop
+			}
+		};
+	});
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIControlRACSupportSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/UIControlRACSupportSpec.m
new file mode 100644
index 0000000..4aaf68c
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIControlRACSupportSpec.m
@@ -0,0 +1,105 @@
+//
+//  UIControlRACSupportSpec.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-06-15.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACTestUIButton.h"
+
+#import "EXTKeyPathCoding.h"
+#import "NSObject+RACDeallocating.h"
+#import "RACChannelExamples.h"
+#import "RACCompoundDisposable.h"
+#import "RACDisposable.h"
+#import "RACSignal.h"
+#import "UIControl+RACSignalSupport.h"
+#import "UISlider+RACSignalSupport.h"
+
+SpecBegin(UIControlRACSupport)
+
+void (^setViewValueBlock)(UISlider *, NSNumber *) = ^(UISlider *view, NSNumber *value) {
+	view.value = value.floatValue;
+
+	// UIControlEvents don't trigger from programmatic modification. Do it
+	// manually.
+	for (id target in view.allTargets) {
+		// Control events are a mask, but UIControlEventAllEvents doesn't seem to
+		// match anything, 0 does.
+		for (NSString *selectorString in [view actionsForTarget:target forControlEvent:0]) {
+			SEL selector = NSSelectorFromString(selectorString);
+
+			NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:[target methodSignatureForSelector:selector]];
+			invocation.selector = selector;
+			UIEvent *event = nil;
+			[invocation setArgument:&event atIndex:2];
+
+			[invocation invokeWithTarget:target];
+		}
+	}
+};
+
+itShouldBehaveLike(RACViewChannelExamples, ^{
+	return @{
+		RACViewChannelExampleCreateViewBlock: ^{
+			return [[UISlider alloc] init];
+		},
+		RACViewChannelExampleCreateTerminalBlock: ^(UISlider *view) {
+			return [view rac_newValueChannelWithNilValue:@0.0];
+		},
+		RACViewChannelExampleKeyPath: @keypath(UISlider.new, value),
+		RACViewChannelExampleSetViewValueBlock: setViewValueBlock
+	};
+});
+
+it(@"should send on the returned signal when matching actions are sent", ^{
+	UIControl *control = [RACTestUIButton button];
+	expect(control).notTo.beNil();
+
+	__block NSUInteger receivedCount = 0;
+	[[control
+		rac_signalForControlEvents:UIControlEventTouchUpInside | UIControlEventTouchUpOutside]
+		subscribeNext:^(UIControl *sender) {
+			expect(sender).to.beIdenticalTo(control);
+			receivedCount++;
+		}];
+
+	expect(receivedCount).to.equal(0);
+	
+	[control sendActionsForControlEvents:UIControlEventTouchUpInside];
+	expect(receivedCount).to.equal(1);
+
+	// Should do nothing.
+	[control sendActionsForControlEvents:UIControlEventTouchDown];
+	expect(receivedCount).to.equal(1);
+	
+	[control sendActionsForControlEvents:UIControlEventTouchUpOutside];
+	expect(receivedCount).to.equal(2);
+});
+
+it(@"should send completed when the control is deallocated", ^{
+	__block BOOL completed = NO;
+	__block BOOL deallocated = NO;
+
+	@autoreleasepool {
+		UIControl *control __attribute__((objc_precise_lifetime)) = [RACTestUIButton button];
+		[control.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{
+			deallocated = YES;
+		}]];
+
+		[[control
+			rac_signalForControlEvents:UIControlEventTouchDown]
+			subscribeCompleted:^{
+				completed = YES;
+			}];
+
+		expect(deallocated).to.beFalsy();
+		expect(completed).to.beFalsy();
+	}
+
+	expect(deallocated).to.beTruthy();
+	expect(completed).to.beTruthy();
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/Default-568h@2x.png b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/Default-568h@2x.png
new file mode 100644
index 0000000..0891b7a
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/Default-568h@2x.png
Binary files differ
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/Default.png b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/Default.png
new file mode 100644
index 0000000..4c8ca6f
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/Default.png
Binary files differ
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/Default@2x.png b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/Default@2x.png
new file mode 100644
index 0000000..35b84cf
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/Default@2x.png
Binary files differ
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/RACAppDelegate.h b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/RACAppDelegate.h
new file mode 100644
index 0000000..88abcec
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/RACAppDelegate.h
@@ -0,0 +1,17 @@
+//
+//  RACAppDelegate.h
+//  ReactiveCocoa-iOS-UIKitTestHost
+//
+//  Created by Andrew Mackenzie-Ross on 27/06/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <UIKit/UIKit.h>
+
+@interface RACAppDelegate : UIResponder <UIApplicationDelegate>
+
+@property (nonatomic, strong) UIWindow *window;
+
++ (instancetype)delegate;
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/RACAppDelegate.m b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/RACAppDelegate.m
new file mode 100644
index 0000000..6af5af8
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/RACAppDelegate.m
@@ -0,0 +1,24 @@
+//
+//  RACAppDelegate.m
+//  ReactiveCocoa-iOS-UIKitTestHost
+//
+//  Created by Andrew Mackenzie-Ross on 27/06/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACAppDelegate.h"
+
+@implementation RACAppDelegate
+
++ (instancetype)delegate {
+	return (id)UIApplication.sharedApplication.delegate;
+}
+
+- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
+    self.window = [[UIWindow alloc] initWithFrame:UIScreen.mainScreen.bounds];
+    [self.window makeKeyAndVisible];
+
+    return YES;
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/RACTestTableViewController.h b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/RACTestTableViewController.h
new file mode 100644
index 0000000..a4163aa
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/RACTestTableViewController.h
@@ -0,0 +1,13 @@
+//
+//  RACTestTableViewController.h
+//  ReactiveCocoa
+//
+//  Created by Syo Ikeda on 12/30/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <UIKit/UIKit.h>
+
+@interface RACTestTableViewController : UITableViewController
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/RACTestTableViewController.m b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/RACTestTableViewController.m
new file mode 100644
index 0000000..0a9d496
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/RACTestTableViewController.m
@@ -0,0 +1,39 @@
+//
+//  RACTestTableViewController.m
+//  ReactiveCocoa
+//
+//  Created by Syo Ikeda on 12/30/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACTestTableViewController.h"
+
+@implementation RACTestTableViewController
+
+- (instancetype)initWithStyle:(UITableViewStyle)style {
+	self = [super initWithStyle:style];
+	if (self == nil) return nil;
+
+	[self.tableView registerClass:UITableViewHeaderFooterView.class forHeaderFooterViewReuseIdentifier:NSStringFromClass(self.class)];
+
+	return self;
+}
+
+- (UIView *)tableView:(UITableView *)tableView viewForHeaderInSection:(NSInteger)section {
+	UITableViewHeaderFooterView *headerView = [tableView dequeueReusableHeaderFooterViewWithIdentifier:NSStringFromClass(self.class)];
+	return headerView;
+}
+
+- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
+	return [tableView dequeueReusableCellWithIdentifier:NSStringFromClass(self.class)] ?: [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:NSStringFromClass(self.class)];
+}
+
+- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView {
+	return 2;
+}
+
+- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section {
+	return 20;
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/ReactiveCocoa-iOS-UIKitTestHost-Info.plist b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/ReactiveCocoa-iOS-UIKitTestHost-Info.plist
new file mode 100644
index 0000000..9d6f424
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/ReactiveCocoa-iOS-UIKitTestHost-Info.plist
@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>en</string>
+	<key>CFBundleDisplayName</key>
+	<string>${PRODUCT_NAME}</string>
+	<key>CFBundleExecutable</key>
+	<string>${EXECUTABLE_NAME}</string>
+	<key>CFBundleIdentifier</key>
+	<string>com.reactivecocoa.${PRODUCT_NAME:rfc1034identifier}</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>${PRODUCT_NAME}</string>
+	<key>CFBundlePackageType</key>
+	<string>APPL</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleVersion</key>
+	<string>1.0</string>
+	<key>LSRequiresIPhoneOS</key>
+	<true/>
+	<key>UIRequiredDeviceCapabilities</key>
+	<array>
+		<string>armv7</string>
+	</array>
+	<key>UISupportedInterfaceOrientations</key>
+	<array>
+		<string>UIInterfaceOrientationPortrait</string>
+		<string>UIInterfaceOrientationLandscapeLeft</string>
+		<string>UIInterfaceOrientationLandscapeRight</string>
+	</array>
+	<key>UISupportedInterfaceOrientations~ipad</key>
+	<array>
+		<string>UIInterfaceOrientationPortrait</string>
+		<string>UIInterfaceOrientationPortraitUpsideDown</string>
+		<string>UIInterfaceOrientationLandscapeLeft</string>
+		<string>UIInterfaceOrientationLandscapeRight</string>
+	</array>
+</dict>
+</plist>
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/ReactiveCocoa-iOS-UIKitTestHost-Prefix.pch b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/ReactiveCocoa-iOS-UIKitTestHost-Prefix.pch
new file mode 100644
index 0000000..d6ec33c
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/ReactiveCocoa-iOS-UIKitTestHost-Prefix.pch
@@ -0,0 +1,14 @@
+//
+// Prefix header for all source files of the 'ReactiveCocoa-iOS-UIKitTestHost' target in the 'ReactiveCocoa-iOS-UIKitTestHost' project
+//
+
+#import <Availability.h>
+
+#ifndef __IPHONE_3_0
+#warning "This project uses features only available in iOS SDK 3.0 and later."
+#endif
+
+#ifdef __OBJC__
+	#import <UIKit/UIKit.h>
+	#import <Foundation/Foundation.h>
+#endif
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/en.lproj/InfoPlist.strings b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/en.lproj/InfoPlist.strings
new file mode 100644
index 0000000..477b28f
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/en.lproj/InfoPlist.strings
@@ -0,0 +1,2 @@
+/* Localized versions of Info.plist keys */
+
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/main.m b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/main.m
new file mode 100644
index 0000000..7dfdd3f
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/main.m
@@ -0,0 +1,18 @@
+//
+//  main.m
+//  ReactiveCocoa-iOS-UIKitTestHost
+//
+//  Created by Andrew Mackenzie-Ross on 27/06/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import <UIKit/UIKit.h>
+
+#import "RACAppDelegate.h"
+
+int main(int argc, char *argv[])
+{
+	@autoreleasepool {
+	    return UIApplicationMain(argc, argv, nil, NSStringFromClass([RACAppDelegate class]));
+	}
+}
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/ReactiveCocoa-iOS-UIKitTest-Prefix.pch b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/ReactiveCocoa-iOS-UIKitTest-Prefix.pch
new file mode 100644
index 0000000..97b985e
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/ReactiveCocoa-iOS-UIKitTest-Prefix.pch
@@ -0,0 +1,2 @@
+#import "ReactiveCocoa-iOS-UIKitTest-Prefix.pch"
+#import "ReactiveCocoaTests-Prefix.pch"
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/ReactiveCocoa-iOS-UIKitTestHostTests-Info.plist b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/ReactiveCocoa-iOS-UIKitTestHostTests-Info.plist
new file mode 100644
index 0000000..efa4ce0
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/ReactiveCocoa-iOS-UIKitTestHostTests-Info.plist
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>en</string>
+	<key>CFBundleExecutable</key>
+	<string>${EXECUTABLE_NAME}</string>
+	<key>CFBundleIdentifier</key>
+	<string>com.reactivecocoa.${PRODUCT_NAME:rfc1034identifier}</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundlePackageType</key>
+	<string>BNDL</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleVersion</key>
+	<string>1</string>
+</dict>
+</plist>
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/UICollectionReusableViewRACSupportSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/UICollectionReusableViewRACSupportSpec.m
new file mode 100644
index 0000000..5ffe160
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/UICollectionReusableViewRACSupportSpec.m
@@ -0,0 +1,73 @@
+//
+//  UICollectionViewCellRACSupportSpec.m
+//  ReactiveCocoa
+//
+//  Created by Kent Wong on 2013-10-04.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACAppDelegate.h"
+
+#import "RACSignal.h"
+#import "RACUnit.h"
+#import "UICollectionReusableView+RACSignalSupport.h"
+
+@interface TestCollectionViewController : UICollectionViewController
+@end
+
+SpecBegin(UICollectionReusableViewRACSupport)
+
+__block UICollectionViewFlowLayout *collectionViewFlowLayout;
+__block TestCollectionViewController *collectionViewController;
+
+beforeEach(^{
+	collectionViewFlowLayout = [[UICollectionViewFlowLayout alloc] init];
+	CGSize screenSize = UIScreen.mainScreen.bounds.size;
+	collectionViewFlowLayout.itemSize = CGSizeMake(screenSize.width, screenSize.height / 2);
+	
+	collectionViewController = [[TestCollectionViewController alloc] initWithCollectionViewLayout:collectionViewFlowLayout];
+	expect(collectionViewController).notTo.beNil();
+	
+	[collectionViewController.collectionView registerClass:UICollectionViewCell.class forCellWithReuseIdentifier:NSStringFromClass(collectionViewController.class)];
+	
+	RACAppDelegate.delegate.window.rootViewController = collectionViewController;
+	expect(collectionViewController.collectionView.visibleCells.count).will.beGreaterThan(0);
+});
+
+it(@"should send on rac_prepareForReuseSignal", ^{
+	UICollectionViewCell *cell = collectionViewController.collectionView.visibleCells[0];
+	
+	__block NSUInteger invocationCount = 0;
+	[cell.rac_prepareForReuseSignal subscribeNext:^(id value) {
+		expect(value).to.equal(RACUnit.defaultUnit);
+		++invocationCount;
+	}];
+	
+	expect(invocationCount).to.equal(0);
+	
+	// The following two expectations will fail in the iOS 7 simulator, but pass on an iPad 4th gen device running iOS 7.
+	// This appears to be a known issue with the iOS 7 simulator. See http://openradar.appspot.com/14973972
+	// These tests will pass with iOS 6.0 and 6.1.
+	if ([UIDevice.currentDevice.systemVersion compare:@"7.0" options:NSNumericSearch] == NSOrderedAscending ||
+		(!TARGET_IPHONE_SIMULATOR && UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad)) {
+		[collectionViewController.collectionView reloadData];
+		expect(invocationCount).will.equal(1);
+		
+		[collectionViewController.collectionView reloadData];
+		expect(invocationCount).will.equal(2);
+	}
+});
+
+SpecEnd
+
+@implementation TestCollectionViewController
+
+- (UICollectionViewCell *)collectionView:(UICollectionView *)collectionView cellForItemAtIndexPath:(NSIndexPath *)indexPath {
+	return [collectionView dequeueReusableCellWithReuseIdentifier:NSStringFromClass(self.class) forIndexPath:indexPath];
+}
+
+- (NSInteger)collectionView:(UICollectionView *)collectionView numberOfItemsInSection:(NSInteger)section {
+	return 20;
+}
+
+@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/UITableViewCellRACSupportSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/UITableViewCellRACSupportSpec.m
new file mode 100644
index 0000000..2a69143
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/UITableViewCellRACSupportSpec.m
@@ -0,0 +1,46 @@
+//
+//  UITableViewCellRACSupportSpec.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-07-23.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACAppDelegate.h"
+#import "RACTestTableViewController.h"
+
+#import "RACSignal.h"
+#import "RACUnit.h"
+#import "UITableViewCell+RACSignalSupport.h"
+
+SpecBegin(UITableViewCellRACSupport)
+
+__block RACTestTableViewController *tableViewController;
+
+beforeEach(^{
+	tableViewController = [[RACTestTableViewController alloc] initWithStyle:UITableViewStylePlain];
+	expect(tableViewController).notTo.beNil();
+
+	RACAppDelegate.delegate.window.rootViewController = tableViewController;
+	expect(tableViewController.tableView.visibleCells.count).will.beGreaterThan(0);
+});
+
+it(@"should send on rac_prepareForReuseSignal", ^{
+	UITableViewCell *cell = tableViewController.tableView.visibleCells[0];
+	
+	__block NSUInteger invocationCount = 0;
+	[cell.rac_prepareForReuseSignal subscribeNext:^(id value) {
+		expect(value).to.equal(RACUnit.defaultUnit);
+		invocationCount++;
+	}];
+
+	expect(invocationCount).to.equal(0);
+
+	[tableViewController.tableView reloadData];
+	expect(invocationCount).will.equal(1);
+
+	[tableViewController.tableView reloadData];
+	expect(invocationCount).will.equal(2);
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/UITableViewHeaderFooterViewRACSupportSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/UITableViewHeaderFooterViewRACSupportSpec.m
new file mode 100644
index 0000000..4658ae9
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/UITableViewHeaderFooterViewRACSupportSpec.m
@@ -0,0 +1,51 @@
+//
+//  UITableViewHeaderFooterViewRACSupportSpec.m
+//  ReactiveCocoa
+//
+//  Created by Syo Ikeda on 12/30/13.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACAppDelegate.h"
+#import "RACTestTableViewController.h"
+
+#import "RACSignal.h"
+#import "RACUnit.h"
+#import "UITableViewHeaderFooterView+RACSignalSupport.h"
+
+SpecBegin(UITableViewHeaderFooterViewRACSupportSpec)
+
+__block RACTestTableViewController *tableViewController;
+
+beforeEach(^{
+	tableViewController = [[RACTestTableViewController alloc] initWithStyle:UITableViewStylePlain];
+	expect(tableViewController).notTo.beNil();
+
+	RACAppDelegate.delegate.window.rootViewController = tableViewController;
+	expect([tableViewController.tableView headerViewForSection:0]).notTo.beNil();
+});
+
+it(@"should send on rac_prepareForReuseSignal", ^{
+	UITableViewHeaderFooterView *headerView = [tableViewController.tableView headerViewForSection:0];
+
+	__block NSUInteger invocationCount = 0;
+	[headerView.rac_prepareForReuseSignal subscribeNext:^(id value) {
+		expect(value).to.equal(RACUnit.defaultUnit);
+		invocationCount++;
+	}];
+
+	expect(invocationCount).to.equal(0);
+
+	void (^scrollToSectionForReuse)(NSInteger) = ^(NSInteger section) {
+		NSIndexPath *indexPath = [NSIndexPath indexPathForRow:0 inSection:section];
+		[tableViewController.tableView scrollToRowAtIndexPath:indexPath atScrollPosition:UITableViewScrollPositionTop animated:NO];
+	};
+
+	scrollToSectionForReuse(tableViewController.tableView.numberOfSections - 1);
+	expect(invocationCount).will.equal(1);
+
+	scrollToSectionForReuse(0);
+	expect(invocationCount).will.equal(2);
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/UITextFieldRACSupportSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/UITextFieldRACSupportSpec.m
new file mode 100644
index 0000000..0aeb49c
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/UITextFieldRACSupportSpec.m
@@ -0,0 +1,53 @@
+//
+//  UITextFieldRACSupportSpec.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-06-22.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSignal.h"
+#import "RACSignal+Operations.h"
+#import "UITextField+RACSignalSupport.h"
+
+SpecBegin(UITextFieldRACSupport)
+
+describe(@"-rac_textSignal", ^{
+	__block UITextField *textField;
+
+	beforeEach(^{
+		textField = [[UITextField alloc] initWithFrame:CGRectMake(0, 0, 100, 20)];
+		expect(textField).notTo.beNil();
+	});
+
+	it(@"should start with the initial text", ^{
+		textField.text = @"foo";
+
+		RACSignal *textSignal = textField.rac_textSignal;
+		expect([textSignal first]).to.equal(@"foo");
+
+		textField.text = @"bar";
+		expect([textSignal first]).to.equal(@"bar");
+	});
+
+	it(@"should clear text upon editing", ^{
+		textField.text = @"foo";
+		textField.clearsOnBeginEditing = YES;
+
+		UIWindow *win = [UIWindow new];
+		[win addSubview:textField];
+
+		__block NSString *str = @"bar";
+
+		RACSignal *textSignal = textField.rac_textSignal;
+		[textSignal subscribeNext:^(id x) {
+			str = x;
+		}];
+		expect(str).to.equal(@"foo");
+
+		[textField becomeFirstResponder];
+		expect(str).to.equal(@"");
+	});
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/UITextViewRACSupportSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/UITextViewRACSupportSpec.m
new file mode 100644
index 0000000..f46e17a
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/UITextViewRACSupportSpec.m
@@ -0,0 +1,34 @@
+//
+//  UITextViewRACSupportSpec.m
+//  ReactiveCocoa
+//
+//  Created by Justin Spahr-Summers on 2013-06-22.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "RACSignal.h"
+#import "RACSignal+Operations.h"
+#import "UITextView+RACSignalSupport.h"
+
+SpecBegin(UITextViewRACSupport)
+
+describe(@"-rac_textSignal", ^{
+	__block UITextView *textView;
+
+	beforeEach(^{
+		textView = [[UITextView alloc] initWithFrame:CGRectMake(0, 0, 100, 20)];
+		expect(textView).notTo.beNil();
+	});
+
+	it(@"should start with the initial text", ^{
+		textView.text = @"foo";
+
+		RACSignal *textSignal = textView.rac_textSignal;
+		expect([textSignal first]).to.equal(@"foo");
+
+		textView.text = @"bar";
+		expect([textSignal first]).to.equal(@"bar");
+	});
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/en.lproj/InfoPlist.strings b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/en.lproj/InfoPlist.strings
new file mode 100644
index 0000000..477b28f
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/en.lproj/InfoPlist.strings
@@ -0,0 +1,2 @@
+/* Localized versions of Info.plist keys */
+
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIRefreshControlRACSupportSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/UIRefreshControlRACSupportSpec.m
new file mode 100644
index 0000000..0a9b651
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIRefreshControlRACSupportSpec.m
@@ -0,0 +1,68 @@
+//
+//  UIRefreshControlRACSupportSpec.m
+//  ReactiveCocoa
+//
+//  Created by Dave Lee on 2013-10-17.
+//  Copyright (c) 2013 GitHub, Inc. All rights reserved.
+//
+
+#import "UIRefreshControl+RACCommandSupport.h"
+#import "NSObject+RACSelectorSignal.h"
+#import "RACControlCommandExamples.h"
+#import "RACCommand.h"
+#import "RACSignal.h"
+
+SpecBegin(UIRefreshControlRACSupport)
+
+describe(@"UIRefreshControl", ^{
+	__block UIRefreshControl *refreshControl;
+
+	beforeEach(^{
+		refreshControl = [[UIRefreshControl alloc] init];
+		expect(refreshControl).notTo.beNil();
+	});
+
+	itShouldBehaveLike(RACControlCommandExamples, ^{
+		return @{
+			RACControlCommandExampleControl: refreshControl,
+			RACControlCommandExampleActivateBlock: ^(UIRefreshControl *refreshControl) {
+				[refreshControl sendActionsForControlEvents:UIControlEventValueChanged];
+			}
+		};
+	});
+
+	describe(@"finishing", ^{
+		__block RACSignal *commandSignal;
+		__block BOOL refreshingEnded;
+
+		beforeEach(^{
+			refreshControl.rac_command = [[RACCommand alloc] initWithSignalBlock:^(id _) {
+				return commandSignal;
+			}];
+
+			// Just -rac_signalForSelector: posing as a mock.
+			refreshingEnded = NO;
+			[[refreshControl
+				rac_signalForSelector:@selector(endRefreshing)]
+				subscribeNext:^(id _) {
+					refreshingEnded = YES;
+				}];
+		});
+
+		it(@"should call -endRefreshing upon completion", ^{
+			commandSignal = [RACSignal empty];
+
+			[refreshControl sendActionsForControlEvents:UIControlEventValueChanged];
+			expect(refreshingEnded).will.beTruthy();
+		});
+
+		it(@"should call -endRefreshing upon error", ^{
+			commandSignal = [RACSignal error:[NSError errorWithDomain:@"" code:1 userInfo:nil]];
+
+			[refreshControl sendActionsForControlEvents:UIControlEventValueChanged];
+			expect(refreshingEnded).will.beTruthy();
+		});
+	});
+});
+
+SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/en.lproj/InfoPlist.strings b/ReactiveCocoaFramework/ReactiveCocoaTests/en.lproj/InfoPlist.strings
new file mode 100644
index 0000000..477b28f
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/en.lproj/InfoPlist.strings
@@ -0,0 +1,2 @@
+/* Localized versions of Info.plist keys */
+
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/test-data.json b/ReactiveCocoaFramework/ReactiveCocoaTests/test-data.json
new file mode 100644
index 0000000..0599ee5
--- /dev/null
+++ b/ReactiveCocoaFramework/ReactiveCocoaTests/test-data.json
@@ -0,0 +1,5 @@
+[
+  { "item": 1 },
+  { "item": 2 },
+  { "item": 3 }
+]
diff --git a/script/LICENSE.md b/script/LICENSE.md
new file mode 100644
index 0000000..8d92384
--- /dev/null
+++ b/script/LICENSE.md
@@ -0,0 +1,18 @@
+**Copyright (c) 2013 Justin Spahr-Summers**
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/script/README.md b/script/README.md
new file mode 100644
index 0000000..f66206f
--- /dev/null
+++ b/script/README.md
@@ -0,0 +1,82 @@
+# objc-build-scripts
+
+This project is a collection of scripts created with two goals:
+
+ 1. To standardize how Objective-C projects are bootstrapped after cloning
+ 1. To easily build Objective-C projects on continuous integration servers
+
+## Scripts
+
+Right now, there are two important scripts: [`bootstrap`](#bootstrap) and
+[`cibuild`](#cibuild). Both are Bash scripts, to maximize compatibility and
+eliminate pesky system configuration issues (like setting up a working Ruby
+environment).
+
+The structure of the scripts on disk is meant to follow that of a typical Ruby
+project:
+
+```
+script/
+    bootstrap
+    cibuild
+```
+
+### bootstrap
+
+This script is responsible for bootstrapping (initializing) your project after
+it's been checked out. Here, you should install or clone any dependencies that
+are required for a working build and development environment.
+
+By default, the script will verify that [xctool][] is installed, then initialize
+and update submodules recursively. If any submodules contain `script/bootstrap`,
+that will be run as well.
+
+To check that other tools are installed, you can set the `REQUIRED_TOOLS`
+environment variable before running `script/bootstrap`, or edit it within the
+script directly. Note that no installation is performed automatically, though
+this can always be added within your specific project.
+
+### cibuild
+
+This script is responsible for building the project, as you would want it built
+for continuous integration. This is preferable to putting the logic on the CI
+server itself, since it ensures that any changes are versioned along with the
+source.
+
+By default, the script will run [`bootstrap`](#bootstrap), look for any Xcode
+workspace or project in the working directory, then build all targets/schemes
+(as found by `xcodebuild -list`) using [xctool][].
+
+You can also specify the schemes to build by passing them into the script:
+
+```sh
+script/cibuild ReactiveCocoa-Mac ReactiveCocoa-iOS
+```
+
+As with the `bootstrap` script, there are several environment variables that can
+be used to customize behavior. They can be set on the command line before
+invoking the script, or the defaults changed within the script directly.
+
+## Getting Started
+
+To add the scripts to your project, read the contents of this repository into
+a `script` folder:
+
+```
+$ git remote add objc-build-scripts https://github.com/jspahrsummers/objc-build-scripts.git
+$ git fetch objc-build-scripts
+$ git read-tree --prefix=script/ -u objc-build-scripts/master
+```
+
+Then commit the changes, to incorporate the scripts into your own repository's
+history. You can also freely tweak the scripts for your specific project's
+needs.
+
+To merge in upstream changes later:
+
+```
+$ git fetch -p objc-build-scripts
+$ git merge --ff --squash -Xsubtree=script objc-build-scripts/master
+```
+
+[xctool]: https://github.com/facebook/xctool
diff --git a/script/bootstrap b/script/bootstrap
new file mode 100755
index 0000000..89cbb8e
--- /dev/null
+++ b/script/bootstrap
@@ -0,0 +1,80 @@
+#!/bin/bash
+
+export SCRIPT_DIR=$(dirname "$0")
+
+##
+## Configuration Variables
+##
+
+config ()
+{
+    # A whitespace-separated list of executables that must be present and locatable.
+    : ${REQUIRED_TOOLS="xctool"}
+    
+    export REQUIRED_TOOLS
+}
+
+##
+## Bootstrap Process
+##
+
+main ()
+{
+    config
+
+    if [ -n "$REQUIRED_TOOLS" ]
+    then
+        echo "*** Checking dependencies..."
+        check_deps
+    fi
+
+    local submodules=$(git submodule status)
+    local result=$?
+
+    if [ "$result" -ne "0" ]
+    then
+        exit $result
+    fi
+
+    if [ -n "$submodules" ]
+    then
+        echo "*** Updating submodules..."
+        update_submodules
+    fi
+}
+
+check_deps ()
+{
+    for tool in $REQUIRED_TOOLS
+    do
+        which -s "$tool"
+        if [ "$?" -ne "0" ]
+        then
+            echo "*** Error: $tool not found. Please install it and bootstrap again."
+            exit 1
+        fi
+    done
+}
+
+bootstrap_submodule ()
+{
+    local bootstrap="script/bootstrap"
+
+    if [ -e "$bootstrap" ]
+    then
+        echo "*** Bootstrapping $name..."
+        "$bootstrap" >/dev/null
+    else
+        update_submodules
+    fi
+}
+
+update_submodules ()
+{
+    git submodule sync --quiet && git submodule update --init && git submodule foreach --quiet bootstrap_submodule
+}
+
+export -f bootstrap_submodule
+export -f update_submodules
+
+main
diff --git a/script/cibuild b/script/cibuild
new file mode 100755
index 0000000..a604019
--- /dev/null
+++ b/script/cibuild
@@ -0,0 +1,156 @@
+#!/bin/bash
+
+export SCRIPT_DIR=$(dirname "$0")
+
+##
+## Configuration Variables
+##
+
+SCHEMES="$@"
+
+config ()
+{
+    # The workspace to build.
+    #
+    # If not set and no workspace is found, the -workspace flag will not be passed
+    # to `xctool`.
+    #
+    # Only one of `XCWORKSPACE` and `XCODEPROJ` needs to be set. The former will
+    # take precedence.
+    : ${XCWORKSPACE=}
+
+    # The project to build.
+    #
+    # If not set and no project is found, the -project flag will not be passed
+    # to `xctool`.
+    #
+    # Only one of `XCWORKSPACE` and `XCODEPROJ` needs to be set. The former will
+    # take precedence.
+    : ${XCODEPROJ="ReactiveCocoaFramework/ReactiveCocoa.xcodeproj"}
+
+    # A bootstrap script to run before building.
+    #
+    # If this file does not exist, it is not considered an error.
+    : ${BOOTSTRAP="$SCRIPT_DIR/bootstrap"}
+
+    # Extra options to pass to xctool.
+    : ${XCTOOL_OPTIONS="RUN_CLANG_STATIC_ANALYZER=NO"}
+
+    # A whitespace-separated list of default schemes to build.
+    #
+    # Individual names can be quoted to avoid word splitting.
+    : ${SCHEMES:=$(xcodebuild -list -project "$XCODEPROJ" 2>/dev/null | awk -f "$SCRIPT_DIR/schemes.awk")}
+    
+    export XCWORKSPACE
+    export XCODEPROJ
+    export BOOTSTRAP
+    export XCTOOL_OPTIONS
+    export SCHEMES
+}
+
+##
+## Build Process
+##
+
+main ()
+{
+    config
+
+    if [ -f "$BOOTSTRAP" ]
+    then
+        echo "*** Bootstrapping..."
+        "$BOOTSTRAP" || exit $?
+    fi
+
+    echo "*** The following schemes will be built:"
+    echo "$SCHEMES" | xargs -n 1 echo "  "
+    echo
+
+    echo "$SCHEMES" | xargs -n 1 | (
+        local status=0
+
+        while read scheme
+        do
+            build_scheme "$scheme" || status=1
+        done
+
+        exit $status
+    )
+}
+
+find_pattern ()
+{
+    ls -d $1 2>/dev/null | head -n 1
+}
+
+run_xctool ()
+{
+    if [ -n "$XCWORKSPACE" ]
+    then
+        xctool -workspace "$XCWORKSPACE" $XCTOOL_OPTIONS "$@" 2>&1
+    elif [ -n "$XCODEPROJ" ]
+    then
+        xctool -project "$XCODEPROJ" $XCTOOL_OPTIONS "$@" 2>&1
+    else
+        echo "*** No workspace or project file found."
+        exit 1
+    fi
+}
+
+parse_build ()
+{
+    awk -f "$SCRIPT_DIR/xctool.awk" 2>&1 >/dev/null
+}
+
+build_scheme ()
+{
+    local scheme=$1
+
+    echo "*** Cleaning $scheme..."
+    run_xctool -scheme "$scheme" clean >/dev/null || exit $?
+
+    echo "*** Building and testing $scheme..."
+    echo
+
+    local sdkflag=
+    local action=test
+
+    # Determine whether we can run unit tests for this target.
+    run_xctool -scheme "$scheme" run-tests | parse_build
+
+    local awkstatus=$?
+
+    if [ "$awkstatus" -ne "0" ]
+    then
+        # Unit tests aren't supported.
+        action=build
+    fi
+
+    if [ "$awkstatus" -eq "1" ]
+    then
+        # Build for iOS.
+        sdkflag="-sdk iphonesimulator"
+    fi
+
+    run_xctool $sdkflag -scheme "$scheme" $action | awk '{ print; } /Failed to query the list of test cases in the test bundle/ { exit 1; }'
+
+    local awkstatus=$?
+    local result=${PIPESTATUS[0]}
+
+    if [ "$awkstatus" -eq "1" ]
+    then
+        echo
+        echo "*** Mac application tests are currently buggy, so they have been skipped."
+        echo "*** See https://github.com/facebook/xctool/issues/243 for more information."
+        echo
+        return 0
+    fi
+
+    return $result
+}
+
+export -f build_scheme
+export -f run_xctool
+export -f parse_build
+
+main
diff --git a/script/schemes.awk b/script/schemes.awk
new file mode 100644
index 0000000..d101b4f
--- /dev/null
+++ b/script/schemes.awk
@@ -0,0 +1,12 @@
+BEGIN {
+    FS = "\n";
+}
+
+/Targets:/ {
+    while (getline && $0 != "") {
+        if ($0 ~ /Test/) continue;
+
+        sub(/^ +/, "");
+        print "'" $0 "'";
+    }
+}
diff --git a/script/targets.awk b/script/targets.awk
new file mode 100644
index 0000000..117660d
--- /dev/null
+++ b/script/targets.awk
@@ -0,0 +1,12 @@
+BEGIN {
+    FS = "\n";
+}
+
+/Targets:/ {
+    while (getline && $0 != "") {
+        if ($0 ~ /Tests/) continue;
+
+        sub(/^ +/, "");
+        print "'" $0 "'";
+    }
+}
diff --git a/script/xcodebuild.awk b/script/xcodebuild.awk
new file mode 100644
index 0000000..c746b09
--- /dev/null
+++ b/script/xcodebuild.awk
@@ -0,0 +1,35 @@
+# Exit statuses:
+#
+# 0 - No errors found.
+# 1 - Build or test failure. Errors will be logged automatically.
+# 2 - Untestable target. Retry with the "build" action.
+
+BEGIN {
+    status = 0;
+}
+
+{
+    print;
+    fflush(stdout);
+}
+
+/is not valid for Testing/ {
+    exit 2;
+}
+
+/[0-9]+: (error|warning):/ {
+    errors = errors $0 "\n";
+}
+
+/(TEST|BUILD) FAILED/ {
+    status = 1;
+}
+
+END {
+    if (length(errors) > 0) {
+        print "\n*** All errors:\n" errors;
+    }
+
+    fflush(stdout);
+    exit status;
+}
diff --git a/script/xctool.awk b/script/xctool.awk
new file mode 100644
index 0000000..f613258
--- /dev/null
+++ b/script/xctool.awk
@@ -0,0 +1,25 @@
+# Exit statuses:
+#
+# 0 - No errors found.
+# 1 - Wrong SDK. Retry with SDK `iphonesimulator`.
+# 2 - Missing target.
+
+BEGIN {
+    status = 0;
+}
+
+{
+    print;
+}
+
+/Testing with the '(.+)' SDK is not yet supported/ {
+    status = 1;
+}
+
+/does not contain a target named/ {
+    status = 2;
+}
+
+END {
+    exit status;
+}