// NOTE: Works with discreet intervals.  Needs refactoring to work with rolling/continuous intervals.
        public static IObservable <T> LimitTo <T, TPeriod>(
            this IObservable <T> source,
            int count,
            IObservable <TPeriod> periodSource,
            IScheduler scheduler = null)
        {
            return(Observable.Create <T>(o =>
            {
                scheduler = scheduler ?? Scheduler.Default;
                var sem = new SemaphoreSlim(0, count);
                var queue = new ConcurrentQueue <T>();
                var queueComplete = new Subject <Unit>();
                bool isSourceComplete = false;
                IConnectableObservable <T> publishedSource = source.Publish();

                IDisposable sourceSub = publishedSource
                                        .Finally(() => isSourceComplete = true)
                                        .Subscribe(Ignore, o.OnError);

                IObservable <Unit> timer = periodSource
                                           .TakeUntil(queueComplete)
                                           .Select(_ =>
                {
                    sem.ReleaseMax(count);
                    return (Unit.Default);
                });

                bool GetNext(out T value)
                {
                    value = default(T);

                    if (queue.IsEmpty)
                    {
                        if (isSourceComplete)
                        {
                            queueComplete.OnNext(Unit.Default);
                        }

                        return false;
                    }

                    return sem.Wait(0) && queue.TryDequeue(out value);
                }

                IEnumerable <T> GetQueueValues(Unit dummy)
                {
                    while (GetNext(out T value))
                    {
                        yield return value;
                    }
                }

                IDisposable sub = publishedSource
                                  .Select(x =>
                {
                    queue.Enqueue(x);
                    return Unit.Default;
                })
                                  .Merge(timer, scheduler)
                                  .SelectMany(GetQueueValues)
                                  .Subscribe(o);

                return new CompositeDisposable(sub, sourceSub, publishedSource.Connect(), queueComplete, sem);
            }));
        }