The installer ships the following dlls:

System.CoreEx, api used by both System.Reactive and System.Interactive:

* Additional Action<,> and Func<,> types (for .NET 3.5 SP1 only, matches types in .NET 4)
* TimeInterval<T> & TimeStamped<T> adds time information to a value.
* IEvent<TEventArgs> wraps existing .NET event values.
* Notification<T> to materialize next/error/completed notifications.
* SynchronizationContexts provides access to common SynchronizationContexts.
* Unit, represents void for use in generics.
* BooleanSignal, a boolean state locking mechanism wrapping Semaphore.
* Semaphore adds the semaphore functionality to Silverlight 3.

System.Reactive, api related to IObservable & IObserver.

* IObservable<T> & IObserver<T>, the base interfaces for Reactive (lives in mscorlib.dll for .NET 4).
* Numerous Observable & Observer sequence operators:

o Standard LINQ operaturs such as: Select, Where, GroupBy, SelectMany
o combining operations such as Zip Repeat, Merge, Amb, Concat and StartWith.
o caching operations such as: Share, Memoize, MemoizeAll and Publish.
o creation operators such as: Return, Throw, Repeat and Generate.
o threading operators such as: Asynchronous, Synchronize, SubscribeOn, ObserveOn.
o exception handling operators such as: Catch, Finally, Retry and OnErrorResumeNext.
o evaluation operators such as: Run & Do.
o stream manipulation operators such as: Scan and Aggregate
o time based operators: Timestamp, Interval, Delay,
o remoting operator: Remotable

* Various Subjects, publish & subscribe (pub/sub) for Reactive with different caching policies.
* System.Joins.*, implements join-calculus on top of Rx.

System.Interactive, backport of Observable sequence operators that apply to IEnumerable as well.

* combining operations such as Zip (for .NET 3.5 SP1 and Silverlight 3), Repeat, Merge, Amb, Concat and StartWith.
* caching operations such as: Share, Memoize, MemoizeAll and Publish.
* creation operators such as: Return, Throw, Repeat and Generate.
* threading operators such as: Asynchronous & Synchronize.
* exception handling operators such as: Catch, Finally, Retry and OnErrorResumeNext.
* evaluation operators such as: Run & Do.
* stream manipulation operators such as: Scan.
* remoting operator: Remotable.

static void Main()
{
  var ob = Observable
    .Range(0, 20)
    .SelectMany(x => Observable.Return(x).Delay(x * 500));

  ob.Subscribe(
    x  => Console.WriteLine("OnNext:  {0}", x),
    e  => Console.WriteLine("OnError: {0}", e),
    () => Console.WriteLine("OnCompleted")
    );

  Thread.Sleep(-1);
}

static void Main()
{
  var service1 =
    Observable.Return("Service1 answer #1").Delay(1000).Merge(
    Observable.Return("Service1 answer #2").Delay(4000));

  var service2 =
    Observable.Return("Service2 answer #1").Delay(500).Merge(
    Observable.Return("Service2 answer #2").Delay(1500).Merge(
    Observable.Return("Service2 answer #3").Delay(2000)));

  var ob = service1.Zip(service2, (s1, s2) => new { s1, s2 });

  ob.Subscribe(
    x  => Console.WriteLine("OnNext:  {0}",  x),
    ex => Console.WriteLine("OnError: {0}", ex),
    () => Console.WriteLine("OnCompleted")
    );

  Thread.Sleep(-1);
}

OnNext: { s1 = Service1 answer #1, s2 = Service2 answer #1 }
OnNext: { s1 = Service1 answer #2, s2 = Service2 answer #2 }
OnCompleted

FORK/JOIN
The patterns employed for delightfully parallel loops are really a subset of a larger set of patterns centered around “fork/join.” In fork/join patterns, work is “forked” such that several pieces of work are launched asynchronously. That forked work is later joined with in order to ensure that all of the processing has completed, and potentially to retrieve the results of that processing if it wasn’t utilized entirely for side-effecting behavior.

var ob = Observable
    .Range(10, 10)
    .Zip(
        Observable.Return(new Unit()).Delay(1000).Repeat(),
        (value, tick) => value);

А>var ob = Observable
А>    .Range(10, 10)
А>    .Zip(
А>        Observable.Return(new Unit()).Delay(1000).Repeat(),
А>        (value, tick) => value);
А>

var ob = Observable.Generate(
    10,
    x => x < 20,
    x => x,
    x => TimeSpan.FromSeconds(1),
    x => x + 1
    );

   return leftSource.Zip<TLeftSource, TRightSource, TResult>(rightSource, selector).Take<TResult>(1);

А>   return leftSource.Zip<TLeftSource, TRightSource, TResult>(rightSource, selector).Take<TResult>(1);
А>

Observable.Join(observable1.And(observable2).And(observable3).Then(Tuple.Create))

А>var ob = Observable
А>    .Range(10, 10)
А>    .Zip(
А>        Observable.Return(new Unit()).Delay(1000).Repeat(),
А>        (value, tick) => value);
А>

var ob = Observable.Range(0, 10).Zip(Observable.Interval(100), (i, _) => i);