This might be too vague for SO. I need a simple example of a class that is both an `IObserver<T>` and an `IOservable<T>`. T are actually the same type.

`OnNext` will create an `IOBservable<T>` sequence itself. Although, `this` should be prevented from observing itself. In essence the observer part is subscribing to multiple observables, and aggregating their values and then in turn serving that aggregation to other subscribers of it.

Is it as simple as inheriting/implementing both `IObserver<T>` and `IOservable<T>` Or am I thinking of composability in the wrong way here ?

```
public struct T
{
}

public class ObserverAndObservable : IObserver<T>, IObservable<T>
{
}

```

What I would like to achieve is something like this. Imagine I have a list of oribiting satellites, each are owned by different nations of the world. I would like to subscribe to say, the US ones(or whatever combination is useful) then compute their average GPS positions. 

```
//Satellites are constantly emiting realtime data
List<Satellite> satellites;
IOBserver<Satellite> observer = satellites.ToObservable();

IDisposable observable = observer.Where(x => string.Equals(x.Name, "USSatellite")).Subscribe();

//Now, compute the GPS average of the Satellites.

//This is not very fluent. There is probably a way to compose these
//functions using a lambda at the end to do the computation, which in turn
//can be subscribed to by other IOBservers...

```