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);

open System.Linq

let query = (seq { 1 .. 10 }).Where(fun x -> x % 2 = 0).Select((*) 2)

C>чем не нравиться,только из-за чистоты, уж не думаю, что там производительность просядет, или что немцу хорошо то русскому смерть?

let func = (+)
let deleg = System.Func<_,_>(func)

[Serializable]
internal class func@7 : OptimizedClosures.FSharpFunc<int, int, int>
{
    internal func@7() { }

    public override int Invoke(int x, int y)
    {
        return (x + y);
    }
}

public static void main@()
{
    FSharpFunc<int, FSharpFunc<int, int>> func = func@7 = new File2.func@7();
    Func<int, int, int> deleg = deleg@9 = new Func<int, int, int>(new File2.deleg@9().Invoke);
}

Creating a delegate pointing to generic virtual method time is 1000x.

C>чем не нравиться,только из-за чистоты, уж не думаю, что там производительность просядет, или что немцу хорошо то русскому смерть?

Delegate creation time (10000000 iterations) results:

Test #1 Interface method: 00:00:00.9326484 (932 ms)
Test #2  Virtual generic: 00:00:00.8832418 (883 ms)
Test #3  Instance method: 00:00:00.3833311 (383 ms)
Test #4    Static method: 00:00:00.2927472 (292 ms)