Rx is a pattern for "functional reactive programming" that started at
Microsoft in C#, and has been reimplemented in various languages, notably
RxJava for JVM languages.

It is basically the plural of Futures (a la Wangle).

```
                    singular              |            plural
        +---------------------------------+-----------------------------------
  sync  |  Foo getData()                  |  std::vector<Foo> getData()
  async |  wangle::Future<Foo> getData()  |  wangle::Observable<Foo> getData()
```

For more on Rx, I recommend these resources:

- Netflix blog post (RxJava): http://techblog.netflix.com/2013/02/rxjava-netflix-api.html
- Introduction to Rx eBook (C#): http://www.introtorx.com/content/v1.0.10621.0/01_WhyRx.html
- The RxJava wiki: https://github.com/Netflix/RxJava/wiki
- Netflix QCon presentation: http://www.infoq.com/presentations/netflix-functional-rx
- https://rx.codeplex.com/

There are open source C++ implementations, I haven't looked at them. They
might be the best way to go rather than writing it NIH-style. I mostly did it
as an exercise, to think through how closely we might want to integrate
something like this with Wangle, and to get a feel for how it works in C++.

I haven't even tried to support move-only data in this version. I'm on the
fence about the usage of shared_ptr. Subject is underdeveloped. A whole rich
set of operations is obviously missing. I haven't decided how to handle
subscriptions (and therefore cancellation), but I'm pretty sure C#'s
"Disposable" is thoroughly un-C++ (opposite of RAII). So for now subscribe
returns nothing at all and you can't cancel anything ever. The whole thing is
probably riddled with lifetime corner case bugs that will come out like a
swarm of angry bees as soon as someone tries an infinite sequence, or tries to
partially observe a long sequence. I'm pretty sure subscribeOn has a bug that
I haven't tracked down yet.
