Observable

Namespace: FSharp.Control.Reactive
Attributes:
[<CompilationRepresentation(4)>]

The Reactive module provides operators for working with IObservable<_> in F#.

Functions and values

Function or value	Description
`aggregate accumulator source` Signature: accumulator:('?8063 -> '?8063 -> '?8063) -> source:IObservable<'?8063> -> IObservable<'?8063> Type parameters: '?8063	Applies an accumulator function over an observable sequence, returning the result of the aggregation as a single element in the result sequence
`all pred source` Signature: pred:('?8065 -> bool) -> source:IObservable<'?8065> -> IObservable<bool> Type parameters: '?8065	Determines whether all elements of an observable satisfy a predicate
`amb second first` Signature: second:IObservable<'?8067> -> first:IObservable<'?8067> -> IObservable<'?8067> Type parameters: '?8067	Returns the observable sequence that reacts first
`ambArray(source)` Signature: source:IObservable<'T> [] -> IObservable<'T> Type parameters: 'T	Propagates the observable sequence that reacts first
`ambSeq(source)` Signature: source:seq<IObservable<'T>> -> IObservable<'T> Type parameters: 'T	Propagates the observable sequence that reacts first
`any(source)` Signature: source:IObservable<'Source> -> IObservable<bool> Type parameters: 'Source	Determines whether an observable sequence contains any elements
`apply f m` Signature: f:IObservable<('?8080 -> '?8081)> -> m:IObservable<'?8080> -> IObservable<'?8081> Type parameters: '?8080, '?8081	Lifts the values of f and m and applies f to m, returning an IObservable of the result.
`asObservable(source)` Signature: source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Hides the identy of an observable sequence
`bind f m` Signature: f:('T -> IObservable<'TNext>) -> m:IObservable<'T> -> IObservable<'TNext> Type parameters: 'T, 'TNext	Binds an observable to generate a subsequent observable.
`both second first` Signature: second:IObservable<'?8083> -> first:IObservable<'?8084> -> Pattern<'?8084,'?8083> Type parameters: '?8083, '?8084	Matches when both observable sequences have an available value
`buffer bufferClosingSelector source` Signature: bufferClosingSelector:IObservable<'BufferClosing> -> source:IObservable<'?8087> -> IObservable<IList<'?8087>> Type parameters: 'BufferClosing, '?8087
`bufferBounded boundaries source` Signature: boundaries:IObservable<'BufferClosing> -> source:IObservable<'T> -> IObservable<IList<'T>> Type parameters: 'BufferClosing, 'T	Projects each element of an observable sequence into consequtive non-overlapping buffers based on a sequence of boundary markers
`bufferCount count source` Signature: count:int -> source:IObservable<'?8092> -> IObservable<IList<'?8092>> Type parameters: '?8092	Projects each element of an observable sequence into consequtive non-overlapping buffers produced based on count information
`bufferCountSkip count skip source` Signature: count:int -> skip:int -> source:IObservable<'?8094> -> IObservable<IList<'?8094>> Type parameters: '?8094	Projects each element of an observable sequence into zero or more buffers which are produced based on element count information
`bufferFork(...)` Signature: bufferOpenings:IObservable<'BufferOpening> -> bufferClosingSelector:('BufferOpening -> IObservable<'T>) -> source:IObservable<'?8106> -> IObservable<IList<'?8106>> Type parameters: 'BufferOpening, 'T, '?8106	Projects each element of an observable sequence into zero of more buffers. bufferOpenings - observable sequence whose elements denote the opening of each produced buffer bufferClosing - observable sequence whose elements denote the closing of each produced buffer
`bufferSpan timeSpan source` Signature: timeSpan:TimeSpan -> source:IObservable<'?8096> -> IObservable<IList<'?8096>> Type parameters: '?8096	Projects each element of an observable sequence into consequtive non-overlapping buffers produced based on timing information
`bufferSpanCount timeSpan count source` Signature: timeSpan:TimeSpan -> count:int -> source:IObservable<'?8100> -> IObservable<IList<'?8100>> Type parameters: '?8100	Projects each element of an observable sequence into a buffer that goes sent out when either it's full or a specific amount of time has elapsed Analogy - A boat that departs when it's full or at its scheduled time to leave
`bufferSpanCountOn(...)` Signature: scheduler:IScheduler -> timeSpan:TimeSpan -> count:int -> source:IObservable<'?8102> -> IObservable<IList<'?8102>> Type parameters: '?8102	Projects each element of an observable sequence into a buffer that's sent out when either it's full or a given amount of time has elapsed, using the specified scheduler to run timers. Analogy - A ferry leaves the dock when all the seats are taken, or at the scheduled time or departure, whichever event occurs first.
`bufferSpanOn scheduler timeSpan source` Signature: scheduler:IScheduler -> timeSpan:TimeSpan -> source:IObservable<'?8098> -> IObservable<IList<'?8098>> Type parameters: '?8098	Projects each element of an observable sequence into consecutive non-overlapping buffers which are produced based on timing information, using the specified scheduler to run timers.
`bufferSpanShift(...)` Signature: timeSpan:TimeSpan -> timeShift:TimeSpan -> source:IObservable<'?8108> -> IObservable<IList<'?8108>> Type parameters: '?8108	Projects each element of an observable sequence into zero or more buffers produced based on timing information
`bufferSpanShiftOn(...)` Signature: scheduler:IScheduler -> timeSpan:TimeSpan -> timeShift:TimeSpan -> source:IObservable<'?8110> -> IObservable<IList<'?8110>> Type parameters: '?8110	Projects each element of an observable sequence into zero or more buffers which are produced based on timing information, using the specified scheduler to run timers.
`case selector sources` Signature: selector:(unit -> '?8114) -> sources:IDictionary<'?8114,IObservable<'?8115>> -> IObservable<'?8115> Type parameters: '?8114, '?8115	Uses selector to determine which source in sources to return, choosing an empty sequence if no match is found
`caseDefault(...)` Signature: selector:(unit -> 'Value) -> defaulSource:IObservable<'Result> -> sources:IDictionary<'Value,IObservable<'Result>> -> IObservable<'Result> Type parameters: 'Value, 'Result	Uses selector to determine which source in sources to return, choosing defaulSource if no match is found
`caseOn scheduler selector sources` Signature: scheduler:IScheduler -> selector:Func<'?8120> -> sources:IDictionary<'?8120,IObservable<'?8121>> -> IObservable<'?8121> Type parameters: '?8120, '?8121	Uses selector to determine which source in sources to return, choosing an empty sequence on the specified scheduler if no match is found.
`cast(source)` Signature: source:IObservable<obj> -> IObservable<'CastType> Type parameters: 'CastType	Converts the elements of the sequence to the specified type
`catch second first` Signature: second:IObservable<'T> -> first:IObservable<'T> -> IObservable<'T> Type parameters: 'T	Continues an observable sequence that is terminated by an exception with the next observable sequence.
`catchArray(sources)` Signature: sources:IObservable<'T> [] -> IObservable<'T> Type parameters: 'T	Continues an observable sequence that is terminated by an exception with the next observable sequence.
`catchOption(source)` Signature: source:IObservable<'?8125> -> IObservable<'?8125 option> Type parameters: '?8125	Continues an observable sequence that is terminated by an exception with an optional as result type.
`catchResult handler source` Signature: handler:('?8127 -> IObservable<'?8128>) -> source:IObservable<'?8129> -> IObservable<Result<'?8129,'?8128>> Type parameters: '?8127, '?8128, '?8129	Continues an observable sequence that is terminated by an exception of the specified type with the observable sequence produced by the handler, wrapped in a 'Result' type.
`catchSeq(sources)` Signature: sources:seq<IObservable<'T>> -> IObservable<'T> Type parameters: 'T	Continues an observable sequence that is terminated by an exception with the next observable sequence.
`catchWith handler source` Signature: handler:('?8131 -> IObservable<'?8132>) -> source:IObservable<'?8132> -> IObservable<'?8132> Type parameters: '?8131, '?8132	Continues an observable sequence that is terminated by an exception of the specified type with the observable sequence produced by the handler.
`choose f source` Signature: f:('?8850 -> '?8851 option) -> source:IObservable<'?8850> -> IObservable<'?8851> Type parameters: '?8850, '?8851	Description Applies the given function to each value of the given source Observable comprimised of the results x for each element for which the function returns `Some(x)`. Parameters - `f` - Accepts a chooser function to only pick a subset of emits. - `source` - The source observable to take a subset from.
`chunkify(source)` Signature: source:IObservable<'Source> -> seq<IList<'Source>> Type parameters: 'Source	Produces an enumerable sequence of consequtive (possibly empty) chunks of the source observable
`collect map source` Signature: map:('Source -> IObservable<'Result>) -> source:seq<'Source> -> IObservable<'Result> Type parameters: 'Source, 'Result	Concatenates the observable sequences obtained by applying the map for each element in the given enumerable
`collectMerge newCollector merge source` Signature: newCollector:(unit -> '?8143) -> merge:('?8143 -> '?8144 -> '?8143) -> source:IObservable<'?8144> -> IEnumerable<'?8143> Type parameters: '?8143, '?8144	Produces an enumerable sequence that returns elements collected/aggregated from the source sequence between consecutive iterations. merge - Merges a sequence element with the current collector newCollector - Factory to create a new collector object.
`collectMergeInit(...)` Signature: getInitialCollector:(unit -> '?8146) -> merge:('?8146 -> '?8147 -> '?8146) -> getNewCollector:('?8146 -> '?8146) -> source:IObservable<'?8147> -> IEnumerable<'?8146> Type parameters: '?8146, '?8147	Produces an enumerable sequence that returns elements collected/aggregated from the source sequence between consecutive iterations. merge - Merges a sequence element with the current collector getNewCollector - Factory to replace the current collector by a new collector getInitialCollector - Factory to create the initial collector object.
`combineLatest source1 source2` Signature: source1:IObservable<'T1> -> source2:IObservable<'T2> -> IObservable<'T1 * 'T2> Type parameters: 'T1, 'T2	Merges the specified observable sequences into one observable sequence whenever either of the observable sequences produces an element.
`combineLatestArray(source)` Signature: source:IObservable<'T> [] -> IObservable<IList<'T>> Type parameters: 'T	Merges the specified observable sequences into one observable sequence by applying the map whenever any of the observable sequences produces an element.
`combineLatestSeq(source)` Signature: source:seq<IObservable<'T>> -> IObservable<IList<'T>> Type parameters: 'T	Merges the specified observable sequences into one observable sequence by emmiting a list with the latest source elements of whenever any of the observable sequences produces an element.
`combineLatestSeqMap map source` Signature: map:(IList<'T> -> 'Result) -> source:seq<IObservable<'T>> -> IObservable<'Result> Type parameters: 'T, 'Result	Merges the specified observable sequences into one observable sequence by applying the map whenever any of the observable sequences produces an element.
`concat second first` Signature: second:IObservable<'T> -> first:IObservable<'T> -> IObservable<'T> Type parameters: 'T	Concatenates the second observable sequence to the first observable sequence upn the successful termination of the first
`concatArray(sources)` Signature: sources:IObservable<'T> [] -> IObservable<'T> Type parameters: 'T	Concatenates all of the specified observable sequences as long as the previous observable sequence terminated successfully
`concatInner(sources)` Signature: sources:IObservable<IObservable<'T>> -> IObservable<'T> Type parameters: 'T	Concatenates all of the inner observable sequences as long as the previous observable sequence terminated successfully
`concatSeq(sources)` Signature: sources:seq<IObservable<'T>> -> IObservable<'T> Type parameters: 'T	Concatenates all observable sequences within the sequence as long as the previous observable sequence terminated successfully
`concatTasks(sources)` Signature: sources:IObservable<Task<'T>> -> IObservable<'T> Type parameters: 'T	Concatenates all task results as long as the previous taskterminated successfully
`connect(source)` Signature: source:IConnectableObservable<'?8169> -> IDisposable Type parameters: '?8169	Connects the observable wrapper to its source. All subscribed observers will recieve values from the underlying observable sequence as long as the connection is established. ( publish an Observable to get a ConnectableObservable )
`consume consumer source` Signature: consumer:IObservable<'?8879> -> source:IObservable<'?8880> -> IObservable<'?8879> Type parameters: '?8879, '?8880	Generates a sequence using the producer/consumer pattern. The purpose of the source sequence is simply to notify the consumer when out-of-band data becomes available. The data in the source sequence provides additional information to the function, but it does not have to be the actual data being produced. The function is not necessarily called for every value in the source sequence. It is only called if the previous consumer's observable has completed; otherwise, the current notification is ignored. This ensures that only one consumer is active at any given time, but it also means that the function is not guaranteed to receive every value in the source sequence; therefore, the function must read data from out-of-band storage instead; e.g., from a shared stream or queue. The function may also be called when data is not available. For example, if the current consuming observable completes and additional notifications from the source were received, then the function is called again to check whether new data was missed. This avoids a race condition between the source sequence and the consuming observable's completion notification. If no data is available when function is called, then an empty sequence should be returned and the function will not be called again until another notification is observed from the source. Producers and the single active consumer are intended to access shared objects concurrently, yet it remains their responsibility to ensure thread-safety. The consume operator cannot do so without breaking concurrency. For example, a producer/consumer implementation that uses an in-memory queue must manually ensure that reads and writes to the queue are thread-safe. Multiple producers are supported. Simply create an observable sequence for each producer that notifies when data is generated, merge them together using the merge operator, and use the merged observable as the source argument in the consume operator. Multiple consumers are supported by calling consume once and then calling subscribe multiple times on the cold observable that is returned. Just be sure that the source sequence is hot so that each subscription will consume based on the same producers' notifications. Parameters `f` - A function that generates an observable sequence from out-of-band data. `source` - Indicates when data becomes available from one or more producers. Returns An observable sequence that is the concatenation of all subscriptions to the consumer observable.
`consumeMap f source` Signature: f:('a -> IObservable<'b>) -> source:IObservable<'a> -> IObservable<'b> Type parameters: 'a, 'b	Generates a sequence using the producer/consumer pattern. The purpose of the source sequence is simply to notify the consumer when out-of-band data becomes available. The data in the source sequence provides additional information to the function, but it does not have to be the actual data being produced. The function is not necessarily called for every value in the source sequence. It is only called if the previous consumer's observable has completed; otherwise, the current notification is ignored. This ensures that only one consumer is active at any given time, but it also means that the function is not guaranteed to receive every value in the source sequence; therefore, the function must read data from out-of-band storage instead; e.g., from a shared stream or queue. The function may also be called when data is not available. For example, if the current consuming observable completes and additional notifications from the source were received, then the function is called again to check whether new data was missed. This avoids a race condition between the source sequence and the consuming observable's completion notification. If no data is available when function is called, then an empty sequence should be returned and the function will not be called again until another notification is observed from the source. Producers and the single active consumer are intended to access shared objects concurrently, yet it remains their responsibility to ensure thread-safety. The consume operator cannot do so without breaking concurrency. For example, a producer/consumer implementation that uses an in-memory queue must manually ensure that reads and writes to the queue are thread-safe. Multiple producers are supported. Simply create an observable sequence for each producer that notifies when data is generated, merge them together using the merge operator, and use the merged observable as the source argument in the consume operator. Multiple consumers are supported by calling consume once and then calling subscribe multiple times on the cold observable that is returned. Just be sure that the source sequence is hot so that each subscription will consume based on the same producers' notifications. Parameters `f` - A function that generates an observable sequence from out-of-band data. `source` - Indicates when data becomes available from one or more producers. Returns An observable sequence that is the concatenation of all subscriptions to the consumer observable.
`consumeNext f source` Signature: f:('?8885 -> '?8886 option) -> source:IObservable<'?8885> -> IObservable<'?8886> Type parameters: '?8885, '?8886	Generates a sequence using the producer/consumer pattern. The purpose of the source sequence is simply to notify the consumer when out-of-band data becomes available. The data in the source sequence provides additional information to the function, but it does not have to be the actual data being produced. The function is not necessarily called for every value in the source sequence. It is only called if the previous consumer's observable has completed; otherwise, the current notification is ignored. This ensures that only one consumer is active at any given time, but it also means that the function is not guaranteed to receive every value in the source sequence; therefore, the function must read data from out-of-band storage instead; e.g., from a shared stream or queue. The function may also be called when data is not available. For example, if the current consuming observable completes and additional notifications from the source were received, then the function is called again to check whether new data was missed. This avoids a race condition between the source sequence and the consuming observable's completion notification. If no data is available when function is called, then an empty sequence should be returned and the function will not be called again until another notification is observed from the source. Producers and the single active consumer are intended to access shared objects concurrently, yet it remains their responsibility to ensure thread-safety. The consume operator cannot do so without breaking concurrency. For example, a producer/consumer implementation that uses an in-memory queue must manually ensure that reads and writes to the queue are thread-safe. Multiple producers are supported. Simply create an observable sequence for each producer that notifies when data is generated, merge them together using the merge operator, and use the merged observable as the source argument in the consume operator. Multiple consumers are supported by calling consume once and then calling subscribe multiple times on the cold observable that is returned. Just be sure that the source sequence is hot so that each subscription will consume based on the same producers' notifications. Parameters `f` - A function that is called iteratively to generate values from out-of-band data. `source` - Indicates when data becomes available from one or more producers. Returns An observable sequence that is the concatenation of the values returned by the consumeNext function.
`consumeNextOn sch f source` Signature: sch:IScheduler -> f:('?8882 -> '?8883 option) -> source:IObservable<'?8882> -> IObservable<'?8883> Type parameters: '?8882, '?8883	Generates a sequence using the producer/consumer pattern. The purpose of the source sequence is simply to notify the consumer when out-of-band data becomes available. The data in the source sequence provides additional information to the function, but it does not have to be the actual data being produced. The function is not necessarily called for every value in the source sequence. It is only called if the previous consumer's observable has completed; otherwise, the current notification is ignored. This ensures that only one consumer is active at any given time, but it also means that the function is not guaranteed to receive every value in the source sequence; therefore, the function must read data from out-of-band storage instead; e.g., from a shared stream or queue. The function may also be called when data is not available. For example, if the current consuming observable completes and additional notifications from the source were received, then the function is called again to check whether new data was missed. This avoids a race condition between the source sequence and the consuming observable's completion notification. If no data is available when function is called, then an empty sequence should be returned and the function will not be called again until another notification is observed from the source. Producers and the single active consumer are intended to access shared objects concurrently, yet it remains their responsibility to ensure thread-safety. The consume operator cannot do so without breaking concurrency. For example, a producer/consumer implementation that uses an in-memory queue must manually ensure that reads and writes to the queue are thread-safe. Multiple producers are supported. Simply create an observable sequence for each producer that notifies when data is generated, merge them together using the merge operator, and use the merged observable as the source argument in the consume operator. Multiple consumers are supported by calling consume once and then calling subscribe multiple times on the cold observable that is returned. Just be sure that the source sequence is hot so that each subscription will consume based on the same producers' notifications. Parameters `f` - A function that is called iteratively to generate values from out-of-band data. `source` - Indicates when data becomes available from one or more producers. Returns An observable sequence that is the concatenation of the values returned by the consumeNext function.
`contains value source` Signature: value:'?8171 -> source:IObservable<'?8171> -> IObservable<bool> Type parameters: '?8171	Determines whether an observable sequence contains a specified element by using the default equality comparer.
`containsCompare comparer value source` Signature: comparer:IEqualityComparer<'?8173> -> value:'?8173 -> source:IObservable<'?8173> -> IObservable<bool> Type parameters: '?8173	Determines whether an observable sequence contains a specified element by using a specified EqualityComparer
`count(source)` Signature: source:IObservable<'?8175> -> IObservable<int> Type parameters: '?8175	Counts the elements
`countSatisfy predicate source` Signature: predicate:('?8177 -> bool) -> source:IObservable<'?8177> -> IObservable<int> Type parameters: '?8177	Returns an observable sequence containing an int that represents how many elements in the specified observable sequence satisfy a condition.
`defaultIfEmpty(source)` Signature: source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Returns the elements of the specified sequence or the type parameter's default value in a singleton sequence if the sequence is empty.
`defaultIfEmptyIs defaultValue source` Signature: defaultValue:'Source -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Returns the elements of the specified sequence or the specified value in a singleton sequence if the sequence is empty.
`defer(observableFactory)` Signature: observableFactory:(unit -> IObservable<'Result>) -> IObservable<'Result> Type parameters: 'Result	Returns an observable sequence that invokes the specified factory function whenever a new observer subscribes.
`delay dueTime source` Signature: dueTime:TimeSpan -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Time shifts the observable sequence by the specified relative time duration. The relative time intervals between the values are preserved.
`delayMap delayDurationSelector source` Signature: delayDurationSelector:('Source -> IObservable<'TDelay>) -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source, 'TDelay	Time shifts the observable sequence based on a delay selector function for each element.
`delayMapFilter(...)` Signature: delayDurationSelector:('Source -> IObservable<'TDelay>) -> subscriptionDelay:IObservable<'TDelay> -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source, 'TDelay	Time shifts the observable sequence based on a subscription delay and a delay selector function for each element.
`delayOn scheduler dueTime source` Signature: scheduler:IScheduler -> dueTime:TimeSpan -> source:IObservable<'?8187> -> IObservable<'?8187> Type parameters: '?8187	Time shifts the observable sequence by the specified relative time duration, using the specified scheduler to run timers. The relative time intervals between the values are preserved.
`delaySubscription dueTime source` Signature: dueTime:TimeSpan -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Time shifts the observable sequence by delaying the subscription with the specified relative time duration.
`delaySubscriptionOn(...)` Signature: scheduler:IScheduler -> dueTime:TimeSpan -> source:IObservable<'?8201> -> IObservable<'?8201> Type parameters: '?8201	Time shifts the observable sequence by delaying the subscription with the specified relative time duration, using the specified scheduler to run timers.
`delaySubscriptionUntil dueTime source` Signature: dueTime:DateTimeOffset -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Time shifts the observable sequence by delaying the subscription to the specified absolute time.
`delaySubscriptionUntilOn(...)` Signature: scheduler:IScheduler -> dueTime:DateTimeOffset -> source:IObservable<'?8205> -> IObservable<'?8205> Type parameters: '?8205	Time shifts the observable sequence by delaying the subscription to the specified absolute time, using the specified scheduler to run timers.
`delayUntil source dueTime` Signature: source:IObservable<'Source> -> dueTime:DateTimeOffset -> IObservable<'Source> Type parameters: 'Source	Time shifts the observable sequence to start propagating notifications at the specified absolute time. The relative time intervals between the values are preserved.
`delayUntilOn scheduler dueTime source` Signature: scheduler:IScheduler -> dueTime:DateTimeOffset -> source:IObservable<'?8191> -> IObservable<'?8191> Type parameters: '?8191	Time shifts the observable sequence to start propagating notifications at the specified absolute time, using the specified scheduler to run timers. The relative time intervals between the values are preserved.
`dematerialize(source)` Signature: source:IObservable<Notification<'?8207>> -> IObservable<'?8207> Type parameters: '?8207	Dematerializes the explicit notification values of an observable sequence as implicit notifications.
`distinct(source)` Signature: source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Returns an observable sequence that only contains distinct elements
`distinctCompare comparer source` Signature: comparer:IEqualityComparer<'Source> -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Returns an observable sequence that contains only distinct elements according to the comparer.
`distinctKey keySelector source` Signature: keySelector:('Source -> 'Key) -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source, 'Key	Returns an observable sequence that contains only distinct elements according to the keySelector.
`distinctKeyCompare(...)` Signature: keySelector:('Source -> 'Key) -> comparer:IEqualityComparer<'Key> -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source, 'Key	Returns an observable sequence that contains only distinct elements according to the keySelector and the comparer.
`distinctUntilChanged(source)` Signature: source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Returns an observable sequence that only contains distinct contiguous elements
`distinctUntilChangedCompare(...)` Signature: comparer:IEqualityComparer<'Source> -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Returns an observable sequence that contains only distinct contiguous elements according to the comparer.
`distinctUntilChangedKey(...)` Signature: keySelector:('Source -> 'Key) -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source, 'Key	Returns an observable sequence that contains only distinct contiguous elements according to the keySelector.
`distinctUntilChangedKeyCompare(...)` Signature: keySelector:('Source -> 'Key) -> comparer:IEqualityComparer<'Key> -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source, 'Key	Returns an observable sequence that contains only distinct contiguous elements according to the keySelector and the comparer.
`elementAt index source` Signature: index:int -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Returns the element at a specified index in a sequence.
`elementAtOrDefault index source` Signature: index:int -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Returns the element at a specified index in a sequence or a default value if the index is out of range
`empty` Signature: IObservable<'T> Type parameters: 'T	Returns an empty observable
`emptyCompleted(scheduler)` Signature: scheduler:IScheduler -> IObservable<'?8239> Type parameters: '?8239	Returns an empty sequence, using the specified scheduler to send out the single OnCompleted message.
`emptyCompletedWitness scheduler witness` Signature: scheduler:IScheduler -> witness:'?8241 -> IObservable<'?8241> Type parameters: '?8241	Returns an empty sequence, using the specified scheduler to send out the single OnCompleted message.
`emptyWitness(witness)` Signature: witness:'T -> IObservable<'T> Type parameters: 'T	Returns an empty Observable sequence
`equals first second` Signature: first:IObservable<'Source> -> second:IObservable<'Source> -> IObservable<bool> Type parameters: 'Source	Determines whether two sequences are equal by comparing the elements pairwise.
`equalsComparer comparer first second` Signature: comparer:IEqualityComparer<'Source> -> first:IObservable<'Source> -> second:IObservable<'Source> -> IObservable<bool> Type parameters: 'Source	Determines whether two sequences are equal by comparing the elements pairwise using a specified equality comparer.
`equalsSeq first second` Signature: first:IObservable<'Source> -> second:seq<'Source> -> IObservable<bool> Type parameters: 'Source	Determines whether an observable and enumerable sequence are equal by comparing the elements pairwise.
`equalsSeqComparer comparer first second` Signature: comparer:IEqualityComparer<'Source> -> first:IObservable<'Source> -> second:seq<'Source> -> IObservable<bool> Type parameters: 'Source	Determines whether an observable and enumerable sequence are equal by comparing the elements pairwise using a specified equality comparer.
`error(e)` Signature: e:exn -> IObservable<'?8251> Type parameters: '?8251
`exhaustMap f source` Signature: f:('?8856 -> '?8857) -> source:IObservable<'?8856> -> IObservable<'?8858> Type parameters: '?8856, '?8857, '?8858	Returns Returns an Observable that emits items based on applying a function that you supply to each item emitted by the source Observable, where that function returns an (so-called "inner") Observable. When it projects a source value to an Observable, the output Observable begins emitting the items emitted by that projected Observable. However, `exhaustMap` ignores every new projected Observable if the previous projected Observable has not yet completed. Once that one completes, it will accept and flatten the next projected Observable and repeat this process.
`exists predicate source` Signature: predicate:('?8253 -> bool) -> source:IObservable<'?8253> -> IObservable<bool> Type parameters: '?8253	Determines whether an observable sequence contains a specified value which satisfies the given predicate
`filter predicate source` Signature: predicate:('T -> bool) -> source:IObservable<'T> -> IObservable<'T> Type parameters: 'T	Filters the observable elements of a sequence based on a predicate
`filteri predicate source` Signature: predicate:(int -> 'T -> bool) -> source:IObservable<'T> -> IObservable<'T> Type parameters: 'T	Filters the observable elements of a sequence based on a predicate by incorporating the element's index
`finallyDo finallyAction source` Signature: finallyAction:(unit -> unit) -> source:IObservable<'?8259> -> IObservable<'?8259> Type parameters: '?8259	Invokes a specified action after the source observable sequence terminates gracefully or exceptionally
`first(source)` Signature: source:IObservable<'T> -> IObservable<'T> Type parameters: 'T	Returns the first element of an observable sequence
`firstIf predicate source` Signature: predicate:('T -> bool) -> source:IObservable<'T> -> IObservable<'T> Type parameters: 'T	Returns the first element of an observable sequence if it satisfies the predicate
`flatmap map source` Signature: map:('S -> IObservable<'R>) -> source:IObservable<'S> -> IObservable<'R> Type parameters: 'S, 'R	Projects each element of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequenc
`flatmapAsync asyncOperation source` Signature: asyncOperation:('Source -> Async<'?8283>) -> source:IObservable<'Source> -> IObservable<'?8283> Type parameters: 'Source, '?8283	Projects each element of an observable sequence to a async workflow and merges all of the async worksflow results into one observable sequence.
`flatmapOther other source` Signature: other:IObservable<'Other> -> source:IObservable<'Source> -> IObservable<'Other> Type parameters: 'Other, 'Source	Projects each element of the source observable sequence to the other observable sequence and merges the resulting observable sequences into one observable sequence.
`flatmapSeq map source` Signature: map:('Source -> seq<'Result>) -> source:IObservable<'Source> -> IObservable<'Result> Type parameters: 'Source, 'Result	Projects each element of an observable sequence to an enumerable sequence and concatenates the resulting enumerable sequences into one observable sequence.
`flatmapTask map source` Signature: map:('Source -> Task<'Result>) -> source:IObservable<'Source> -> IObservable<'Result> Type parameters: 'Source, 'Result	Projects each element of an observable sequence to a task and merges all of the task results into one observable sequence.
`fold accumulator init source` Signature: accumulator:('?8285 -> '?8286 -> '?8285) -> init:'?8285 -> source:IObservable<'?8286> -> IObservable<'?8285> Type parameters: '?8285, '?8286	Applies an accumulator function over an observable sequence, returning the result of the fold as a single element in the result sequence init is the initial accumulator value
`foldMap accumulator init map source` Signature: accumulator:('?8288 -> '?8289 -> '?8288) -> init:'?8288 -> map:('?8288 -> '?8290) -> source:IObservable<'?8289> -> IObservable<'?8290> Type parameters: '?8288, '?8289, '?8290	Applies an accumulator function over an observable sequence, returning the result of the fold as a single element in the result sequence init is the initial accumulator value, map is performed after the fold
`fromEvent addHandler removeHandler` Signature: addHandler:('Delegate -> unit) -> removeHandler:('Delegate -> unit) -> IObservable<unit> Type parameters: 'Delegate	Converts an Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead.
`fromEventConversion(...)` Signature: conversion:(('EventArgs -> unit) -> 'Delegate) -> addHandler:('Delegate -> unit) -> removeHandler:('Delegate -> unit) -> IObservable<'EventArgs> Type parameters: 'EventArgs, 'Delegate	Converts a .NET event to an observable sequence, using a conversion function to obtain the event delegate. Each event invocation is surfaced through an OnNext message in the resulting sequence. For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern functions instead.
`fromEventConversionOn(...)` Signature: scheduler:IScheduler -> conversion:(EventHandler<'TEventArgs> -> 'TDelegate) -> addHandler:('TDelegate -> unit) -> removeHandler:('TDelegate -> unit) -> IObservable<EventPattern<'TEventArgs>> Type parameters: 'TEventArgs, 'TDelegate	Converts a .NET event to an observable sequence, using a conversion function to obtain the event delegate, using a specified scheduler to run timers. Each event invocation is surfaced through an OnNext message in the resulting sequence. For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern functions instead.
`fromEventGeneric(...)` Signature: addHandler:(('TEventArgs -> unit) -> unit) -> removeHandler:(('TEventArgs -> unit) -> unit) -> IObservable<'TEventArgs> Type parameters: 'TEventArgs	Converts an generic Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead.
`fromEventGenericOn(...)` Signature: scheduler:IScheduler -> addHandler:(('TEventArgs -> unit) -> unit) -> removeHandler:(('TEventArgs -> unit) -> unit) -> IObservable<'?8298> Type parameters: 'TEventArgs, '?8298	Converts an generic Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead.
`fromEventHandler(...)` Signature: addHandler:(EventHandler<'EventArgs> -> unit) -> removeHandler:(EventHandler<'EventArgs> -> unit) -> IObservable<'EventArgs> Type parameters: 'EventArgs	Converts a .NET event to an observable sequence, using a supplied event delegate type. Each event invocation is surfaced through an OnNext message in the resulting sequence.
`fromEventHandlerOn(...)` Signature: scheduler:IScheduler -> addHandler:(EventHandler<'EventArgs> -> unit) -> removeHandler:(EventHandler<'EventArgs> -> unit) -> IObservable<EventPattern<'EventArgs>> Type parameters: 'EventArgs	Converts a .NET event to an observable sequence, using a supplied event delegate type on a specified scheduler. Each event invocation is surfaced through an OnNext message in the resulting sequence.
`fromEventOn(...)` Signature: scheduler:IScheduler -> addHandler:(Action -> unit) -> removeHandler:(Action -> unit) -> IObservable<Unit>	Converts an Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead.
`fromEventPattern eventName target` Signature: eventName:string -> target:obj -> IObservable<EventPattern<obj>>	Generates an observable from an IEvent<_> as an EventPattern.
`generate(...)` Signature: initialState:'State -> condition:('State -> bool) -> iterator:('State -> 'State) -> resultMap:('State -> 'Result) -> IObservable<'Result> Type parameters: 'State, 'Result	Generates an observable sequence by running a state-driven loop producing the sequence's elements.
`generateOn(...)` Signature: scheduler:IScheduler -> initialState:'State -> condition:('State -> bool) -> iterator:('State -> 'State) -> resultMap:('State -> 'TResult) -> IObservable<'TResult> Type parameters: 'State, 'TResult	Generates an observable sequence by running a state-driven loop producing the sequence's elements.
`generateTimed(...)` Signature: initialState:'State -> condition:('State -> bool) -> iterate:('State -> 'State) -> resultMap:('State -> 'Result) -> timeSelector:('State -> DateTimeOffset) -> IObservable<'Result> Type parameters: 'State, 'Result	Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements.
`generateTimedOn(...)` Signature: scheduler:IScheduler -> initialState:'State -> condition:('State -> bool) -> iterate:('State -> 'State) -> resultMap:('State -> 'Result) -> timeSelector:('State -> DateTimeOffset) -> IObservable<'Result> Type parameters: 'State, 'Result	Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements, using a specified scheduler to run timers and to send out observer messages.
`generateTimeSpan(...)` Signature: initialState:'State -> condition:('State -> bool) -> iterate:('State -> 'State) -> resultMap:('State -> 'Result) -> genTime:('State -> TimeSpan) -> IObservable<'Result> Type parameters: 'State, 'Result	Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements.
`generateTimeSpanOn(...)` Signature: scheduler:IScheduler -> initialState:'State -> condition:('State -> bool) -> iterate:('State -> 'State) -> resultMap:('State -> 'Result) -> genTime:('State -> TimeSpan) -> IObservable<'Result> Type parameters: 'State, 'Result	Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements, using a specified scheduler to run timers and to send out observer messages.
`getEnumerator(source)` Signature: source:IObservable<'?8329> -> IEnumerator<'?8329> Type parameters: '?8329	Returns an enumerator that enumerates all values of the observable sequence.
`groupBy keySelector source` Signature: keySelector:('Source -> 'Key) -> source:IObservable<'Source> -> IObservable<IGroupedObservable<'Key,'Source>> Type parameters: 'Source, 'Key	Groups the elements of an observable sequence according to a specified key selector function.
`groupByCapacityElement(...)` Signature: keySelector:('Source -> 'Key) -> capacity:int -> elementSelector:('Source -> 'Element) -> source:IObservable<'Source> -> IObservable<IGroupedObservable<'Key,'Element>> Type parameters: 'Source, 'Key, 'Element	Groups the elements of an observable sequence with the specified initial capacity and selects the resulting elements by using a specified function.
`groupByCompare(...)` Signature: keySelector:('?8334 -> '?8335) -> comparer:IEqualityComparer<'?8335> -> source:IObservable<'?8334> -> IObservable<IGroupedObservable<'?8335,'?8334>> Type parameters: '?8334, '?8335	Groups the elements of an observable sequence according to a specified key selector function and comparer.
`groupByCompareElement(...)` Signature: keySelector:('Source -> 'Key) -> comparer:IEqualityComparer<'Key> -> elementSelector:('Source -> 'Element) -> source:IObservable<'Source> -> IObservable<IGroupedObservable<'Key,'Element>> Type parameters: 'Source, 'Key, 'Element	Groups the elements of an observable sequence according to a specified key selector function and comparer and selects the resulting elements by using a specified function.
`groupByComparerElementUntil(...)` Signature: keySelector:('Source -> 'Key) -> comparer:IEqualityComparer<'Key> -> elementSelector:('Source -> 'Element) -> durationSelector:(IGroupedObservable<'Key,'Element> -> IObservable<'TDuration>) -> source:IObservable<'Source> -> IObservable<IGroupedObservable<'Key,'Element>> Type parameters: 'Source, 'Key, 'Element, 'TDuration	Groups the elements of an observable sequence according to a specified key selector function and comparer and selects the resulting elements by using a specified function. A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same key value as a reclaimed group occurs, the group will be reborn with a new lifetime request.
`groupByComparerUntil(...)` Signature: keySelector:('Source -> 'Key) -> comparer:IEqualityComparer<'Key> -> durationSelector:(IGroupedObservable<'Key,'Source> -> IObservable<'TDuration>) -> source:IObservable<'Source> -> IObservable<IGroupedObservable<'Key,'Source>> Type parameters: 'Source, 'Key, 'TDuration	Groups the elements of an observable sequence according to a specified key selector function and comparer. A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same key value as a reclaimed group occurs, the group will be reborn with a new lifetime request.
`groupByElement(...)` Signature: keySelector:('Source -> 'Key) -> elementSelector:('Source -> 'Element) -> source:IObservable<'Source> -> IObservable<IGroupedObservable<'Key,'Element>> Type parameters: 'Source, 'Key, 'Element	Groups the elements of an observable sequence and selects the resulting elements by using a specified function.
`groupByElementUntil(...)` Signature: keySelector:('Source -> 'Key) -> elementSelector:('Source -> 'Element) -> durationSelector:(IGroupedObservable<'Key,'Element> -> IObservable<'TDuration>) -> source:IObservable<'Source> -> IObservable<IGroupedObservable<'Key,'Element>> Type parameters: 'Source, 'Key, 'Element, 'TDuration	Groups the elements of an observable sequence according to a specified key selector function and selects the resulting elements by using a specified function. A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same key value as a reclaimed group occurs, the group will be reborn with a new lifetime request.
`groupByUntil(...)` Signature: keySelector:('Source -> 'Key) -> durationSelector:(IGroupedObservable<'Key,'Source> -> IObservable<'TDuration>) -> source:IObservable<'Source> -> IObservable<IGroupedObservable<'Key,'Source>> Type parameters: 'Source, 'Key, 'TDuration	Groups the elements of an observable sequence according to a specified key selector function. A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same key value as a reclaimed group occurs, the group will be reborn with a new lifetime request.
`groupJoin(...)` Signature: left:IObservable<'Left> -> right:IObservable<'Right> -> leftselect:('Left -> IObservable<'a>) -> rightselect:('Right -> IObservable<'b>) -> resultselect:('Left -> IObservable<'Right> -> 'Result) -> IObservable<'Result> Type parameters: 'Left, 'Right, 'a, 'b, 'Result	Correlates the elements of two sequences based on overlapping durations and groups the results
`guard f source` Signature: f:(unit -> unit) -> source:IObservable<'Args> -> IObservable<'Args> Type parameters: 'Args	Creates an observable that calls the specified function (each time) after an observer is attached to the observable. This is useful to make sure that events triggered by the function are handled.
`head(obs)` Signature: obs:IObservable<'?8375> -> IObservable<'?8375> Type parameters: '?8375	Takes the first element of the observable sequence
`ignoreElements(source)` Signature: source:IObservable<'?8233> -> IObservable<'?8233> Type parameters: '?8233	Ignores all elements in an observable sequence leaving only the completed/error notifications
`infinite()` Signature: unit -> IObservable<'?8467> Type parameters: '?8467	Returns a non-terminating observable sequence, which can be used to denote an infinite duration (e.g. when using reactive joins).
`interval(period)` Signature: period:TimeSpan -> IObservable<int64>	Returns an observable sequence that produces a value after each period
`intervalOn scheduler period` Signature: scheduler:IScheduler -> period:TimeSpan -> IObservable<int64>	Returns an observable sequence that produces a value on the specified scheduler after each period
`isEmpty(source)` Signature: source:IObservable<'?8379> -> IObservable<bool> Type parameters: '?8379	IsEmpty returns an Observable that emits true if and only if the source Observable completes without emitting any items.
`iter onNext source` Signature: onNext:('Source -> unit) -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Invokes an action for each element in the observable sequence, and propagates all observer messages through the result sequence. This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline.
`iterEnd onNext onCompleted source` Signature: onNext:('Source -> unit) -> onCompleted:(unit -> unit) -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Invokes an action for each element in the observable sequence and invokes an action upon graceful termination of the observable sequence. This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline.
`iterError onNext onError source` Signature: onNext:('Source -> unit) -> onError:(exn -> unit) -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Invokes an action for each element in the observable sequence and invokes an action upon exceptional termination of the observable sequence. This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline.
`iterErrorEnd(...)` Signature: onNext:('Source -> unit) -> onError:(exn -> unit) -> onCompleted:(unit -> unit) -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Invokes an action for each element in the observable sequence and invokes an action upon graceful or exceptional termination of the observable sequence. This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline.
`iterObserver observer source` Signature: observer:IObserver<'Source> -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Invokes the observer's methods for each message in the source sequence. This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline.
`join right f left` Signature: right:IObservable<'?8391> -> f:('?8392 -> '?8391 -> '?8393) -> left:IObservable<'?8392> -> IObservable<'?8393> Type parameters: '?8391, '?8392, '?8393	Correlates the elements of two sequences based on overlapping durations.
`joinMap right fLeft fRight fResult left` Signature: right:IObservable<'?8395> -> fLeft:('?8396 -> IObservable<'?8397>) -> fRight:('?8395 -> IObservable<'?8398>) -> fResult:('?8396 -> '?8395 -> '?8399) -> left:IObservable<'?8396> -> IObservable<'?8399> Type parameters: '?8395, '?8396, '?8397, '?8398, '?8399	Correlates the elements of two sequences based on overlapping durations.
`joinWhen(plans)` Signature: plans:seq<Plan<'T>> -> IObservable<'T> Type parameters: 'T	Joins together the results from several patterns
`last(source)` Signature: source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Returns the last element of an observable sequence.
`lastIf predicate source` Signature: predicate:('Source -> bool) -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Returns the last element of an observable sequence that satisfies the condition in the predicate
`latest(source)` Signature: source:IObservable<'?8407> -> IEnumerable<'?8407> Type parameters: '?8407	Returns an enumerable sequence whose enumeration returns the latest observed element in the source observable sequence. Enumerators on the resulting sequence will never produce the same element repeatedly, and will block until the next element becomes available.
`liftAsync(asyncOperation)` Signature: asyncOperation:('?8279 -> Async<'?8280>) -> '?8279 -> IObservable<'?8280> Type parameters: '?8279, '?8280	Helper function for turning async workflows into observables
`log prefix source` Signature: prefix:string -> source:IObservable<'?8493> -> IObservable<'?8493> Type parameters: '?8493	Logs the incoming emits with a given prefix to the console.
`logTo prefix f source` Signature: prefix:string -> f:(string -> unit) -> source:IObservable<'?8491> -> IObservable<'?8491> Type parameters: '?8491	Logs the incoming emits with a given prefix to a specified target.
`longCount(source)` Signature: source:IObservable<'?8409> -> IObservable<int64> Type parameters: '?8409	Returns an observable sequence containing a int64 that represents the total number of elements in an observable sequence
`longCountSatisfy predicate source` Signature: predicate:('?8411 -> bool) -> source:IObservable<'?8411> -> IObservable<int64> Type parameters: '?8411	Returns an observable sequence containing an int that represents how many elements in the specified observable sequence satisfy a condition.
`map f source` Signature: f:('?8413 -> '?8414) -> source:IObservable<'?8413> -> IObservable<'?8414> Type parameters: '?8413, '?8414	Maps the given observable with the given function
`map2 f a b` Signature: f:IObservable<('?8419 -> '?8420 -> '?8421)> -> a:IObservable<'?8419> -> b:IObservable<'?8420> -> IObservable<'?8421> Type parameters: '?8419, '?8420, '?8421	Maps two observables to the specified function.
`mapFold f init source` Signature: f:('TState -> 'T -> 'TResult * 'TState) -> init:'TState -> source:IObservable<'T> -> IObservable<'TResult list * 'TState> Type parameters: 'TState, 'T, 'TResult	Combines 'map' and 'fold'. Builds an observable whose emits are the result of applying the given function to each of the emits of the source observable. The function is also used to accumulate a final value.
`mapi f source` Signature: f:(int -> 'Source -> 'Result) -> source:IObservable<'Source> -> IObservable<'Result> Type parameters: 'Source, 'Result	Maps the given observable with the given function and the index of the element
`mapTo x source` Signature: x:'?8427 -> source:IObservable<'T> -> IObservable<'?8427> Type parameters: '?8427, 'T	Maps every emission to a constant value.
`mapToLazy xLazy source` Signature: xLazy:Lazy<'T> -> source:IObservable<'T> -> IObservable<'T> Type parameters: 'T	Maps every emission to a constant lazy value.
`materialize(source)` Signature: source:IObservable<'?8432> -> IObservable<Notification<'?8432>> Type parameters: '?8432	Materializes the implicit notifications of an observable sequence as explicit notification values
`maxOf(source)` Signature: source:IObservable<'T> -> IObservable<'T> Type parameters: 'T	Returns the maximum element in an observable sequence.
`merge second first` Signature: second:IObservable<'T> -> first:IObservable<'T> -> IObservable<'T> Type parameters: 'T	Merges the two observables
`mergeArray(sources)` Signature: sources:IObservable<'T> [] -> IObservable<'T> Type parameters: 'T	Merges all the observable sequences into a single observable sequence.
`mergeArrayOn scheduler sources` Signature: scheduler:IScheduler -> sources:IObservable<'T> [] -> IObservable<'T> Type parameters: 'T	Merges all the observable sequences into a single observable sequence, using a specified scheduler for enumeration of and subscription to the sources.
`mergeInner(sources)` Signature: sources:IObservable<IObservable<'T>> -> IObservable<'T> Type parameters: 'T	Merges elements from all inner observable sequences into a single observable sequence.
`mergeInnerMax maxConcurrent sources` Signature: maxConcurrent:int -> sources:IObservable<IObservable<'T>> -> IObservable<'T> Type parameters: 'T	Merges elements from all inner observable sequences into a single observable sequence limiting the number of concurrent subscriptions to inner sequences
`mergeOn scheduler second first` Signature: scheduler:IScheduler -> second:IObservable<'T> -> first:IObservable<'T> -> IObservable<'T> Type parameters: 'T	Merges the two observables, using a specified scheduler for enumeration of and subscription to the sources.
`mergeSeq(sources)` Signature: sources:seq<IObservable<'T>> -> IObservable<'T> Type parameters: 'T	Merges an enumerable sequence of observable sequences into a single observable sequence.
`mergeSeqMax maxConcurrent sources` Signature: maxConcurrent:int -> sources:seq<IObservable<'T>> -> IObservable<'T> Type parameters: 'T	Merges an enumerable sequence of observable sequences into an observable sequence, limiting the number of concurrent subscriptions to inner sequences.
`mergeSeqMaxOn(...)` Signature: scheduler:IScheduler -> maxConcurrent:int -> sources:seq<IObservable<'T>> -> IObservable<'T> Type parameters: 'T	Merges an enumerable sequence of observable sequences into an observable sequence, limiting the number of concurrent subscriptions to inner sequences, using a specified scheduler for enumeration of and subscription to the sources.
`mergeSeqOn scheduler sources` Signature: scheduler:IScheduler -> sources:seq<IObservable<'T>> -> IObservable<'T> Type parameters: 'T	Merges an enumerable sequence of observable sequences into a single observable sequence, using a specified scheduler for enumeration of and subscription to the sources.
`mergeTasks(sources)` Signature: sources:IObservable<Task<'T>> -> IObservable<'T> Type parameters: 'T	Merge results from all source tasks into a single observable sequence
`mostRecent initialVal source` Signature: initialVal:'?8458 -> source:IObservable<'?8458> -> IEnumerable<'?8458> Type parameters: '?8458	Returns an enumerable sequence whose sequence whose enumeration returns the most recently observed element in the source observable sequence, using the specified
`multicast subject source` Signature: subject:ISubject<'?8460,'?8461> -> source:IObservable<'?8460> -> IConnectableObservable<'?8461> Type parameters: '?8460, '?8461	Multicasts the source sequence notifications through the specified subject to the resulting connectable observable. Upon connection of the connectable observable, the subject is subscribed to the source exactly one, and messages are forwarded to the observers registered with the connectable observable. For specializations with fixed subject types, see Publish, PublishLast, and Replay.
`multicastMap(...)` Signature: subjectSelector:(unit -> ISubject<'?8463,'?8464>) -> selector:(IObservable<'?8464> -> IObservable<'?8465>) -> source:IObservable<'?8463> -> IObservable<'?8465> Type parameters: '?8463, '?8464, '?8465	Multicasts the source sequence notifications through an instantiated subject into all uses of the sequence within a selector function. Each subscription to the resulting sequence causes a separate multicast invocation, exposing the sequence resulting from the selector function's invocation. For specializations with fixed subject types, see Publish, PublishLast, and Replay.
`neverWitness(witness)` Signature: witness:'?8469 -> IObservable<'?8469> Type parameters: '?8469	Returns a non-terminating observable sequence, which can be used to denote an infinite duration (e.g. when using reactive joins).
`next(source)` Signature: source:IObservable<'?8471> -> IEnumerable<'?8471> Type parameters: '?8471	Returns an observable sequence whose enumeration blocks until the next element in the source observable sequence becomes available. Enumerators on the resulting sequence will block until the next element becomes available.
`observeOn scheduler source` Signature: scheduler:IScheduler -> source:IObservable<'?8477> -> IObservable<'?8477> Type parameters: '?8477	Wraps the source sequence in order to run its observer callbacks on the specified scheduler.
`observeOnContext context source` Signature: context:SynchronizationContext -> source:IObservable<'?8479> -> IObservable<'?8479> Type parameters: '?8479	Wraps the source sequence in order to run its observer callbacks on the specified synchronization context.
`ofAsync(asyncOperation)` Signature: asyncOperation:Async<'?8277> -> IObservable<'?8277> Type parameters: '?8277	Turns an F# async workflow into an observable
`ofSeq(items)` Signature: items:seq<'Item> -> IObservable<'Item> Type parameters: 'Item	Returns the sequence as an observable
`ofSeqOn scheduler items` Signature: scheduler:IScheduler -> items:seq<'Item> -> IObservable<'Item> Type parameters: 'Item	Returns the sequence as an observable, using the specified scheduler to run the enumeration loop
`ofType(source)` Signature: source:IObservable<obj> -> IObservable<'?8481> Type parameters: '?8481	Filters the elements of an observable sequence based on the specified type
`onErrorConcat second first` Signature: second:IObservable<'Source> -> first:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Concatenates the second observable sequence to the first observable sequence upon successful or exceptional termination of the first.
`onErrorConcatArray(sources)` Signature: sources:IObservable<'Source> [] -> IObservable<'Source> Type parameters: 'Source	Concatenates all of the specified observable sequences, even if the previous observable sequence terminated exceptionally.
`onErrorConcatSeq(sources)` Signature: sources:seq<IObservable<'Source>> -> IObservable<'Source> Type parameters: 'Source	Concatenates all observable sequences in the given enumerable sequence, even if the previous observable sequence terminated exceptionally.
`perform f source` Signature: f:('?8489 -> unit) -> source:IObservable<'?8489> -> IObservable<'?8489> Type parameters: '?8489	Iterates through the observable and performs the given side-effect
`performFinally f source` Signature: f:(unit -> unit) -> source:IObservable<'?8495> -> IObservable<'?8495> Type parameters: '?8495	Invokes the finally action after source observable sequence terminates normally or by an exception.
`poll period source` Signature: period:DateTimeOffset -> source:IObservable<Result<'?8847,'?8848>> -> IObservable<Result<'?8847,'?8848>> Type parameters: '?8847, '?8848	Description Periodically repeats the observable sequence exposing a responses or failures. Using the `Scheduler.Default` on which the polling period should run. Parameters - `period` - Accepts the period in which the polling should happen. - `source` - The source observable on which the polling happen.
`pollOn sch period source` Signature: sch:IScheduler -> period:DateTimeOffset -> source:IObservable<Result<'?8844,'?8845>> -> IObservable<Result<'?8844,'?8845>> Type parameters: '?8844, '?8845	Description Periodically repeats the observable sequence exposing a responses or failures. Parameters - `sch` - Accepts the scheduler on which the polling period should be run. - `period` - Accepts the period in which the polling should happen. - `source` - The source observable on which the polling happen.
`publish(source)` Signature: source:IObservable<'?8497> -> IConnectableObservable<'?8497> Type parameters: '?8497	Returns a connectable observable sequence (IConnectableObsevable) that shares a single subscription to the underlying sequence. This operator is a specialization of Multicast using a regular Subject
`publishInitial initial source` Signature: initial:'Source -> source:IObservable<'Source> -> IConnectableObservable<'Source> Type parameters: 'Source	Returns a connectable observable sequence (IConnectableObsevable) that shares a single subscription to the underlying sequence and starts with the value initial. This operator is a specialization of Multicast using a regular Subject
`publishInitialMap initial map source` Signature: initial:'Source -> map:(IObservable<'Source> -> IObservable<'Result>) -> source:IObservable<'Source> -> IObservable<'Result> Type parameters: 'Source, 'Result	Returns an observable sequence that is the result of the map on a connectable observable sequence that shares a a single subscription to the underlying sequence. This operator is a specialization of Multicast using a regular Subject
`publishLast(source)` Signature: source:IObservable<'?8507> -> IConnectableObservable<'?8507> Type parameters: '?8507	Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence containing only the last notification This operator is a specialization of Multicast using a regular Subject
`publishLastMap map source` Signature: map:(IObservable<'Source> -> IObservable<'Result>) -> source:IObservable<'Source> -> IObservable<'Result> Type parameters: 'Source, 'Result	Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a a single subscription to the underlying sequence. This operator is a specialization of Multicast using a regular Subject
`publishMap map source` Signature: map:(IObservable<'Source> -> IObservable<'Result>) -> source:IObservable<'Source> -> IObservable<'Result> Type parameters: 'Source, 'Result	Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a a single subscription to the underlying sequence. This operator is a specialization of Multicast using a regular Subject
`range start count` Signature: start:int -> count:int -> IObservable<int>	Creates a range as an observable
`rangeOn scheduler start count` Signature: scheduler:IScheduler -> start:int -> count:int -> IObservable<int>	Creates a range as an observable, using the specified scheduler to send out observer messages.
`reduce f source` Signature: f:('?8514 -> '?8514 -> '?8514) -> source:IObservable<'?8514> -> IObservable<'?8514> Type parameters: '?8514	Reduces the observable
`refCount(source)` Signature: source:IConnectableObservable<'?8516> -> IObservable<'?8516> Type parameters: '?8516	Returns an observable that remains connected to the source as long as there is at least one subscription to the observable sequence ( publish an Observable to get a ConnectableObservable )
`repeat(source)` Signature: source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Repeats the observable sequence indefinitely.
`repeatCount repeatCount value` Signature: repeatCount:int -> value:'Result -> IObservable<'Result> Type parameters: 'Result	Repeats the observable sequence a specified number of times.
`repeatValue(value)` Signature: value:'Result -> IObservable<'Result> Type parameters: 'Result	Generates an observable sequence that repeats the given element infinitely.
`repeatWhile condition source` Signature: condition:(unit -> bool) -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Repeats the given observable sequence as long as the specified condition holds, where the condition is evaluated after each repeated source is completed.
`replay(source)` Signature: source:IObservable<'Source> -> IConnectableObservable<'Source> Type parameters: 'Source	Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications.
`replayBuffer bufferSize source` Signature: bufferSize:int -> source:IObservable<'Source> -> IConnectableObservable<'Source> Type parameters: 'Source	Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum element count for the replay buffer.
`replayBufferWindow(...)` Signature: bufferSize:int -> window:TimeSpan -> source:IObservable<'Source> -> IConnectableObservable<'Source> Type parameters: 'Source	Returns a connectable observable sequence that shares a single subscription to the underlying sequence
`replayBufferWindowOn(...)` Signature: scheduler:IScheduler -> bufferSize:int -> window:TimeSpan -> source:IObservable<'Source> -> IConnectableObservable<'Source> Type parameters: 'Source	Returns a connectable observable sequence that shares a single subscription to the underlying sequence
`replayMap map source` Signature: map:(IObservable<'Source> -> IObservable<'Result>) -> source:IObservable<'Source> -> IObservable<'Result> Type parameters: 'Source, 'Result	Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications.
`replayMapBuffer map bufferSize source` Signature: map:(IObservable<'Source> -> IObservable<'Result>) -> bufferSize:int -> source:IObservable<'Source> -> IObservable<'Result> Type parameters: 'Source, 'Result	Returns an observable sequence that is the result of apply a map to a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum element count for the replay buffer.
`replayMapBufferWindow(...)` Signature: map:(IObservable<'Source> -> IObservable<'Result>) -> bufferSize:int -> window:TimeSpan -> source:IObservable<'Source> -> IObservable<'Result> Type parameters: 'Source, 'Result	Returns an observable sequence that is the result of apply a map to a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer.
`replayMapBufferWindowOn(...)` Signature: scheduler:IScheduler -> map:(IObservable<'Source> -> IObservable<'Result>) -> bufferSize:int -> window:TimeSpan -> source:IObservable<'Source> -> IObservable<'Result> Type parameters: 'Source, 'Result	Returns an observable sequence that is the result of apply a map to a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer.
`replayMapWindow map window source` Signature: map:(IObservable<'Source> -> IObservable<'Result>) -> window:TimeSpan -> source:IObservable<'Source> -> IObservable<'Result> Type parameters: 'Source, 'Result	Returns an observable sequence that is the result of apply a map to a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length.
`replayMapWindowOn(...)` Signature: scheduler:IScheduler -> map:(IObservable<'Source> -> IObservable<'Result>) -> window:TimeSpan -> source:IObservable<'Source> -> IObservable<'Result> Type parameters: 'Source, 'Result	Returns an observable sequence that is the result of apply a map to a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length.
`replayOn sch source` Signature: sch:IScheduler -> source:IObservable<'?8528> -> IConnectableObservable<'?8528> Type parameters: '?8528	Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications.
`replayWindow window source` Signature: window:TimeSpan -> source:IObservable<'Source> -> IConnectableObservable<'Source> Type parameters: 'Source	Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer.
`replayWindowOn scheduler window source` Signature: scheduler:IScheduler -> window:TimeSpan -> source:IObservable<'Source> -> IConnectableObservable<'Source> Type parameters: 'Source	Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer.
`result(x)` Signature: x:'?8562 -> IObservable<'?8562> Type parameters: '?8562
`retry(source)` Signature: source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Repeats the source observable sequence until it successfully terminates.
`retryCount count source` Signature: count:int -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Repeats the source observable sequence the specified number of times or until it successfully terminates.
`sample interval source` Signature: interval:TimeSpan -> source:IObservable<'?8564> -> IObservable<'?8564> Type parameters: '?8564	Samples the observable at the given interval
`sampleOn scheduler interval source` Signature: scheduler:IScheduler -> interval:TimeSpan -> source:IObservable<'?8566> -> IObservable<'?8566> Type parameters: '?8566	Samples the observable sequence at each interval, using the specified scheduler to run sampling timers. Upon each sampling tick, the latest element (if any) in the source sequence during the last sampling interval is sent to the resulting sequence.
`sampleWith sampler source` Signature: sampler:IObservable<'Sample> -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Sample, 'Source	Samples the source observable sequence using a samper observable sequence producing sampling ticks. Upon each sampling tick, the latest element (if any) in the source sequence during the last sampling interval is sent to the resulting sequence.
`scan accumulator source` Signature: accumulator:('a -> 'a -> 'a) -> source:IObservable<'a> -> IObservable<'a> Type parameters: 'a	Applies an accumulator function over an observable sequence and returns each intermediate result.
`scanInit init accumulator source` Signature: init:'TAccumulate -> accumulator:('TAccumulate -> 'Source -> 'TAccumulate) -> source:IObservable<'Source> -> IObservable<'TAccumulate> Type parameters: 'TAccumulate, 'Source	Applies an accumulator function over an observable sequence and returns each intermediate result. The specified init value is used as the initial accumulator value.
`selectIf condition thenSource` Signature: condition:(unit -> bool) -> thenSource:IObservable<'?8576> -> IObservable<'?8576> Type parameters: '?8576	If the condition evaluates true, select the "thenSource" sequence. Otherwise, return an empty sequence.
`selectIfElse(...)` Signature: condition:(unit -> bool) -> elseSource:IObservable<'Result> -> thenSource:IObservable<'Result> -> IObservable<'Result> Type parameters: 'Result	If the condition evaluates true, select the "thenSource" sequence. Otherwise, select the else source
`selectIfOn(...)` Signature: scheduler:IScheduler -> condition:(unit -> bool) -> thenSource:IObservable<'?8578> -> IObservable<'?8578> Type parameters: '?8578	If the condition evaluates true, select the "thenSource" sequence. Otherwise, return an empty sequence generated on the specified scheduler.
`serve max sourceFactory` Signature: max:int -> sourceFactory:(unit -> '?8873) -> IObservable<'?8874> Type parameters: '?8873, '?8874	Description Concurrently invokes the specified factory to create observables as fast and often as possible and subscribes to all of them up to the default maximum concurrency. Parameters - `max` - The maximum number of observables to be subscribed simultaneously. - `sourceFactory` - Function that returns the observable to invoke concurrently.
`serveCustomOn(...)` Signature: sch:IScheduler -> max:int -> callOnError:(exn -> bool) -> sourceFactory:(unit -> '?8867) -> IObservable<'?8868> Type parameters: '?8867, '?8868	Description Concurrently invokes the specified factory to create observables as fast and often as possible and subscribes to all of them up to the default maximum concurrency. Parameters - `sch` - The scheduler on which the invocation should happen. - `max` - The maximum number of observables to be subscribed simultaneously. - `callOnError` - Function to determine whether or not the given exception should call the `OnError`. - `sourceFactory` - Function that returns the observable to invoke concurrently.
`serveGateCustomOn(...)` Signature: sch:IScheduler -> gate:'?8863 -> max:int -> callOnError:(exn -> bool) -> sourceFactory:(unit -> '?8864) -> IObservable<'?8865> Type parameters: '?8863, '?8864, '?8865	Description Concurrently invokes the specified factory to create observables as fast and often as possible and subscribes to all of them up to the default maximum concurrency. Parameters - `sch` - The scheduler on which the invocation should happen. - `gate` - Common gate on which the synchronization should happen. - `max` - The maximum number of observables to be subscribed simultaneously. - `callOnError` - Function to determine whether or not the given exception should call the `OnError`. - `sourceFactory` - Function that returns the observable to invoke concurrently.
`serveOn sch max sourceFactory` Signature: sch:IScheduler -> max:int -> sourceFactory:(unit -> '?8870) -> IObservable<'?8871> Type parameters: '?8870, '?8871	Description Concurrently invokes the specified factory to create observables as fast and often as possible and subscribes to all of them up to the default maximum concurrency. Parameters - `sch` - The scheduler on which the invocation should happen. - `gate` - Common gate on which the synchronization should happen. - `max` - The maximum number of observables to be subscribed simultaneously. - `sourceFactory` - Function that returns the observable to invoke concurrently.
`single(value)` Signature: value:'Result -> IObservable<'Result> Type parameters: 'Result	Returns an observable sequence that contains a single element.
`singleOn scheduler value` Signature: scheduler:IScheduler -> value:'?8584 -> IObservable<'?8584> Type parameters: '?8584	Returns an observable sequence that contains a single element, using a specified scheduler to send out observer messages.
`skip count source` Signature: count:int -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Bypasses a specified number of elements in an observable sequence and then returns the remaining elements.
`skipLast count source` Signature: count:int -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Bypasses a specified number of elements at the end of an observable sequence.
`skipLastSpan duration source` Signature: duration:TimeSpan -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Skips elements for the specified duration from the end of the observable source sequence.
`skipLastSpanOn scheduler duration source` Signature: scheduler:IScheduler -> duration:TimeSpan -> source:IObservable<'?8596> -> IObservable<'?8596> Type parameters: '?8596	Skips elements for the specified duration from the end of the observable source sequence, using the specified scheduler to run timers.
`skipSpan duration source` Signature: duration:TimeSpan -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Skips elements for the specified duration from the start of the observable source sequence.
`skipSpanOn scheduler duration source` Signature: scheduler:IScheduler -> duration:TimeSpan -> source:IObservable<'?8590> -> IObservable<'?8590> Type parameters: '?8590	Skips elements for the specified duration from the start of the observable source sequence, using a specified scheduler to run timers.
`skipUntil startTime source` Signature: startTime:DateTimeOffset -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Skips elements from the observable source sequence until the specified start time.
`skipUntilOn scheduler startTime source` Signature: scheduler:IScheduler -> startTime:DateTimeOffset -> source:IObservable<'?8600> -> IObservable<'?8600> Type parameters: '?8600	Skips elements from the observable source sequence until the specified start time, using the specified scheduler to run timers.
`skipUntilOther other source` Signature: other:IObservable<'Other> -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Other, 'Source	Returns the elements from the source observable sequence only after the other observable sequence produces an element.
`skipWhile predicate source` Signature: predicate:('Source -> bool) -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Bypasses elements in an observable sequence as long as a specified condition is true and then returns the remaining elements.
`skipWhilei predicate source` Signature: predicate:('Source -> int -> bool) -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Bypasses elements in an observable sequence as long as a specified condition is true and then returns the remaining elements. The element's index is used in the logic of the predicate functio
`startWith values source` Signature: values:'?8609 -> source:IObservable<'T> -> IObservable<'T> Type parameters: '?8609, 'T	Prepends a sequence of values to an observable sequence.
`startWithOn scheduler values source` Signature: scheduler:IScheduler -> values:'?8612 -> source:IObservable<'T> -> IObservable<'T> Type parameters: '?8612, 'T	Prepends a sequence of values to an observable sequence.
`subscribe onNext observable` Signature: onNext:('T -> unit) -> observable:IObservable<'T> -> IDisposable Type parameters: 'T	Subscribes to the Observable with a next fuction.
`subscribeObserver observer observable` Signature: observer:IObserver<'T> -> observable:IObservable<'T> -> IDisposable Type parameters: 'T	Subscribes to the observable with the given observer
`subscribeOn scheduler source` Signature: scheduler:IScheduler -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Wraps the source sequence in order to run its subscription and unsubscription logic on the specified scheduler. This operation is not commonly used; This only performs the side-effects of subscription and unsubscription on the specified scheduler. In order to invoke observer callbacks on a scheduler, use 'observeOn'
`subscribeOnContext context source` Signature: context:SynchronizationContext -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Wraps the source sequence in order to run its subscription and unsubscription logic on the specified SynchronizationContext. This operation is not commonly used; This only performs the side-effects of subscription and unsubscription on the specified scheduler. In order to invoke observer callbacks on a scheduler, use 'observeOn'
`subscribeSafe onNext source` Signature: onNext:('?8629 -> unit) -> source:IObservable<'?8629> -> IDisposable Type parameters: '?8629	Subscribes to the specified source, re-routing synchronous exceptions during invocation of the Subscribe function to the observer's 'OnError channel. This function is typically used to write query operators.
`subscribeSafeObserver observer source` Signature: observer:IObserver<'?8636> -> source:IObservable<'?8636> -> IDisposable Type parameters: '?8636	Subscribes to the specified source, re-routing synchronous exceptions during invocation of the Subscribe function to the observer's 'OnError channel. This function is typically used to write query operators.
`subscribeSafeWithCallbacks(...)` Signature: onNext:('?8638 -> unit) -> onError:(exn -> unit) -> onCompleted:(unit -> unit) -> source:IObservable<'?8638> -> IDisposable Type parameters: '?8638	Subscribes to the specified source, re-routing synchronous exceptions during invocation of the Subscribe function to the observer's 'OnError channel. This function is typically used to write query operators.
`subscribeSafeWithCompletion(...)` Signature: onNext:('?8633 -> unit) -> onCompleted:'?8634 -> source:IObservable<'?8633> -> IDisposable Type parameters: '?8633, '?8634	Subscribes to the specified source, re-routing synchronous exceptions during invocation of the Subscribe function to the observer's 'OnError channel. This function is typically used to write query operators.
`subscribeSafeWithError(...)` Signature: onNext:('?8631 -> unit) -> onError:(exn -> unit) -> source:IObservable<'?8631> -> IDisposable Type parameters: '?8631	Subscribes to the specified source, re-routing synchronous exceptions during invocation of the Subscribe function to the observer's 'OnError channel. This function is typically used to write query operators.
`subscribeWithCallbacks(...)` Signature: onNext:('T -> unit) -> onError:(exn -> unit) -> onCompleted:(unit -> unit) -> observable:IObservable<'T> -> IDisposable Type parameters: 'T	Subscribes to the observable with all three callbacks
`subscribeWithCompletion(...)` Signature: onNext:('T -> unit) -> onCompleted:(unit -> unit) -> observable:IObservable<'T> -> IDisposable Type parameters: 'T	Subscribes to the Observable with a next and a completion callback.
`subscribeWithError(...)` Signature: onNext:('T -> unit) -> onError:(exn -> unit) -> observable:IObservable<'T> -> IDisposable Type parameters: 'T	Subscribes to the Observable with a next and an error-function.
`switch(sources)` Signature: sources:IObservable<IObservable<'Source>> -> IObservable<'Source> Type parameters: 'Source	Transforms an observable sequence of observable sequences into an observable sequence producing values only from the most recent observable sequence.Each time a new inner observable sequnce is recieved, unsubscribe from the previous inner sequence
`switchAsync(sources)` Signature: sources:IObservable<Async<'?8644>> -> IObservable<'?8644> Type parameters: '?8644	Transforms an observable sequence of tasks into an observable sequence producing values only from the most recent observable sequence. Each time a new task is received, the previous task's result is ignored.
`switchMap f source` Signature: f:('?8853 -> IObservable<'?8854>) -> source:IObservable<'?8853> -> IObservable<'?8854> Type parameters: '?8853, '?8854	Description Projects each source value to an Observable which is merged in the output Observable, emitting values only from the most recently projected Observable. Equivalent to a map followed by a switch. Returns Returns an Observable that emits items based on applying a function that you supply to each item emitted by the source Observable, where that function returns an (so-called "inner") Observable. Each time it observes one of these inner Observables, the output Observable begins emitting the items emitted by that inner Observable. When a new inner Observable is emitted, `switchMap` stops emitting items from the earlier-emitted inner Observable and begins emitting items from the new one. It continues to behave like this for subsequent inner Observables.
`switchTask(sources)` Signature: sources:IObservable<Task<'Source>> -> IObservable<'Source> Type parameters: 'Source	Transforms an observable sequence of tasks into an observable sequence producing values only from the most recent observable sequence. Each time a new task is received, the previous task's result is ignored.
`synchronize(source)` Signature: source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Synchronizes the observable sequence so that notifications cannot be delivered concurrently this overload is useful to "fix" an observable sequence that exhibits concurrent callbacks on individual observers, which is invalid behavior for the query processor
`synchronizeGate gate source` Signature: gate:obj -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Synchronizes the observable sequence such that observer notifications cannot be delivered concurrently, using the specified gate object.This overload is useful when writing n-ary query operators, in order to prevent concurrent callbacks from different sources by synchronizing on a common gate object.
`tail(source)` Signature: source:IObservable<'?8650> -> IObservable<'?8650> Type parameters: '?8650	Bypasses the first element in an observable sequence and then returns the remaining elements.
`take n source` Signature: n:int -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Takes n elements (from the beginning of an observable sequence? )
`takeLast count source` Signature: count:int -> source:IObservable<'?8660> -> IObservable<'?8660> Type parameters: '?8660	Returns a specified number of contiguous elements from the end of an obserable sequence
`takeLastBuffer duration source` Signature: duration:TimeSpan -> source:IObservable<'Source> -> IObservable<IList<'Source>> Type parameters: 'Source	Returns a list with the elements within the specified duration from the end of the observable source sequence.
`takeLastBufferCount count source` Signature: count:int -> source:IObservable<'Source> -> IObservable<IList<'Source>> Type parameters: 'Source	Returns a list with the specified number of contiguous elements from the end of an observable sequence.
`takeLastBufferOn(...)` Signature: scheduler:IScheduler -> duration:TimeSpan -> source:IObservable<'?8670> -> IObservable<IList<'?8670>> Type parameters: '?8670	Returns a list with the elements within the specified duration from the end of the observable source sequence, using the specified scheduler to run timers.
`takeLastOn scheduler count source` Signature: scheduler:IScheduler -> count:int -> source:IObservable<'?8662> -> IObservable<'?8662> Type parameters: '?8662	Returns a specified number of contiguous elements from the end of an obserable sequence, using the specified scheduler to drain the queue.
`takeLastSpan duration source` Signature: duration:TimeSpan -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Returns elements within the specified duration from the end of the observable source sequence.
`takeLastSpanOn scheduler duration source` Signature: scheduler:IScheduler -> duration:TimeSpan -> source:IObservable<'?8666> -> IObservable<'?8666> Type parameters: '?8666	Returns elements within the specified duration from the end of the observable source sequence, using the specified scheduler to run timers.
`takeOn scheduler n source` Signature: scheduler:IScheduler -> n:int -> source:IObservable<'?8654> -> IObservable<'?8654> Type parameters: '?8654	Returns a specified number of contiguous elemenents from the start of an observable sequence, using the specified scheduler for the edge case of take(0).
`takeSpan duration source` Signature: duration:TimeSpan -> source:IObservable<'?8656> -> IObservable<'?8656> Type parameters: '?8656	Takes elements for a specified duration from the start of the observable source sequence.
`takeSpanOn scheduler duration source` Signature: scheduler:IScheduler -> duration:TimeSpan -> source:IObservable<'?8658> -> IObservable<'?8658> Type parameters: '?8658	Takes elements for a specified duration from the start of the observable source sequence, using the specified scheduler to run timers.
`takeUntilOther other source` Signature: other:IObservable<'Other> -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Other, 'Source	Returns the elements from the source observable sequence until the other produces and element
`takeUntilTime endtime source` Signature: endtime:DateTimeOffset -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Returns the elements from the source observable until the specified time
`takeUntilTimeOn scheduler endtime source` Signature: scheduler:IScheduler -> endtime:DateTimeOffset -> source:IObservable<'?8679> -> IObservable<'?8679> Type parameters: '?8679	Returns the elements from the source observable until the specified time, using the specified scheduler to run timers.
`takeWhile predicate source` Signature: predicate:('Source -> bool) -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Returns elements from an observable sequence as long as a specified condition is true.
`takeWhilei predicate source` Signature: predicate:('Source -> int -> bool) -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Returns elements from an observable sequence as long as a specified condition is true. The element's index is used in the logic of the predicate functi
`thenMap map source` Signature: map:('Source -> 'Result) -> source:IObservable<'Source> -> Plan<'Result> Type parameters: 'Source, 'Result	matches when the observable sequence has an available element and applies the map
`throttle dueTime source` Signature: dueTime:TimeSpan -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Ignores elements from an observable sequence which are followed by another element within a specified relative time duration.
`throttleComputed(...)` Signature: throttleDurationSelector:('Source -> IObservable<'Throttle>) -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source, 'Throttle	Ignores elements from an observable sequence which are followed by another value within a computed throttle duration
`throttleOn scheduler dueTime source` Signature: scheduler:IScheduler -> dueTime:TimeSpan -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Ignores elements from an observable sequence which are followed by another element within a specified relative time duration.
`throw(except)` Signature: except:exn -> IObservable<'Result> Type parameters: 'Result	Returns an observable sequence that terminates with an exception.
`throwOn scheduler ex` Signature: scheduler:IScheduler -> ex:exn -> IObservable<'?8696> Type parameters: '?8696	Returns an observable sequence that terminates with an exception, using the specified scheduler to send out the single OnError message.
`throwWitness witness ex` Signature: witness:'?8694 -> ex:exn -> IObservable<'?8694> Type parameters: '?8694	Returns an observable sequence that terminates with an exception.
`throwWitnessOn scheduler witeness ex` Signature: scheduler:'?8698 -> witeness:IScheduler -> ex:exn -> IObservable<'?8698> Type parameters: '?8698	Returns an observable sequence that terminates with an exception, using the specified scheduler to send out the single OnError message.
`timeInterval(source)` Signature: source:IObservable<'Source> -> IObservable<TimeInterval<'Source>> Type parameters: 'Source	Records the time interval between consecutive elements in an observable sequence.
`timeIntervalOn scheduler source` Signature: scheduler:IScheduler -> source:IObservable<'?8705> -> IObservable<TimeInterval<'?8705>> Type parameters: '?8705	Records the time interval between consecutive elements in an observable sequence, using the specified scheduler to compute time intervals.
`timeout timeout source` Signature: timeout:DateTimeOffset -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Applies a timeout policy to the observable sequence based on an absolute time. If the sequence doesn't terminate before the specified absolute due time, a TimeoutException is propagated to the observer.
`timeout2Duration(...)` Signature: timeout:IObservable<'Timeout> -> durationSelector:('Source -> IObservable<'Timeout>) -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Timeout, 'Source	Applies a timeout policy to the observable sequence based on an initial timeout duration for the first element, and a timeout duration computed for each subsequent element. If the next element isn't received within the computed duration starting from its predecessor, a TimeoutException is propagated to the observer.
`timeout2DurationOther(...)` Signature: timeout:IObservable<'Timeout> -> durationSelector:('Source -> IObservable<'Timeout>) -> other:IObservable<'Source> -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Timeout, 'Source	Applies a timeout policy to the observable sequence based on an initial timeout duration for the first element, and a timeout duration computed for each subsequent element. If the next element isn't received within the computed duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on.
`timeoutDuration durationSelector source` Signature: durationSelector:('Source -> IObservable<'Timeout>) -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source, 'Timeout	Applies a timeout policy to the observable sequence based on a timeout duration computed for each element. If the next element isn't received within the computed duration starting from its predecessor, a TimeoutException is propagated to the observer.
`timeoutOn scheduler timeout source` Signature: scheduler:IScheduler -> timeout:DateTimeOffset -> source:IObservable<'?8709> -> IObservable<'?8709> Type parameters: '?8709	Applies a timeout policy to the observable sequence based on an absolute time, using the specified scheduler to run timeout timers. If the sequence doesn't terminate before the specified absolute due time, a TimeoutException is propagated to the observer.
`timeoutOther timeout other source` Signature: timeout:DateTimeOffset -> other:IObservable<'Source> -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Applies a timeout policy to the observable sequence based on an absolute time. If the sequence doesn't terminate before the specified absolute due time, the other observable sequence is used to produce future messages from that point on.
`timeoutOtherOn(...)` Signature: scheduler:IScheduler -> timeout:DateTimeOffset -> other:IObservable<'?8713> -> source:IObservable<'?8713> -> IObservable<'?8713> Type parameters: '?8713	Applies a timeout policy to the observable sequence based on an absolute time, using the specified scheduler to run timeout timers. If the sequence doesn't terminate before the specified absolute due time, the other observable sequence is used to produce future messages from that point on.
`timeoutSpan timeout source` Signature: timeout:TimeSpan -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Applies a timeout policy for each element in the observable sequence. If the next element isn't received within the specified timeout duration starting from its predecessor, a TimeoutException is propagated to the observer.
`timeoutSpanOn scheduler timeout source` Signature: scheduler:IScheduler -> timeout:TimeSpan -> source:IObservable<'?8717> -> IObservable<'?8717> Type parameters: '?8717	Applies a timeout policy for each element in the observable sequence, using the specified scheduler to run timeout timers. If the next element isn't received within the specified timeout duration starting from its predecessor, a TimeoutException is propagated to the observer.
`timeoutSpanOther timeout other source` Signature: timeout:TimeSpan -> other:IObservable<'Source> -> source:IObservable<'Source> -> IObservable<'Source> Type parameters: 'Source	Applies a timeout policy for each element in the observable sequence. If the next element isn't received within the specified timeout duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on.
`timeoutSpanOtherOn(...)` Signature: scheduler:IScheduler -> timeout:TimeSpan -> other:IObservable<'?8721> -> source:IObservable<'?8721> -> IObservable<'?8721> Type parameters: '?8721	Applies a timeout policy for each element in the observable sequence, using the specified scheduler to run timeout timers. If the next element isn't received within the specified timeout duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on.
`timer(dueTime)` Signature: dueTime:DateTimeOffset -> IObservable<int64>	Returns an observable sequence that produces a single value at the specified absolute due time.
`timerOn scheduler dueTime` Signature: scheduler:IScheduler -> dueTime:DateTimeOffset -> IObservable<int64>	Returns an observable sequence that produces a single value at the specified absolute due time, using the specified scheduler to run the timer.
`timerPeriod dueTime period` Signature: dueTime:DateTimeOffset -> period:TimeSpan -> IObservable<int64>	Returns an observable sequence that periodically produces a value starting at the specified initial absolute due time.
`timerSpan(dueTime)` Signature: dueTime:TimeSpan -> IObservable<int64>	Returns an observable sequence that produces a single value after the specified relative due time has elapsed.
`timerSpanOn scheduler dueTime` Signature: scheduler:IScheduler -> dueTime:TimeSpan -> IObservable<int64>	Returns an observable sequence that produces a single value after the specified relative due time has elapsed, using the specified scheduler to run the timer.
`timerSpanPeriod(dueTime, period)` Signature: (dueTime:TimeSpan * period:TimeSpan) -> IObservable<int64>	Returns an observable sequence that periodically produces a value after the specified initial relative due time has elapsed.
`timerSpanPeriodOn(...)` Signature: scheduler:IScheduler -> dueTime:TimeSpan -> period:TimeSpan -> IObservable<int64>	Returns an observable sequence that periodically produces a value after the specified initial relative due time has elapsed, using the specified scheduler to run the timer.
`timestamp(source)` Signature: source:IObservable<'Source> -> IObservable<Timestamped<'Source>> Type parameters: 'Source	Timestamps each element in an observable sequence using the local system clock.
`timestampOn scheduler source` Signature: scheduler:IScheduler -> source:IObservable<'Source> -> IObservable<Timestamped<'Source>> Type parameters: 'Source	Timestamps each element in an observable sequence using the supplied scheduler.
`toArray(source)` Signature: source:IObservable<'?8745> -> IObservable<'?8745 []> Type parameters: '?8745	Creates an array from an observable sequence.
`toDictionary keySelector source` Signature: keySelector:('?8747 -> '?8748) -> source:IObservable<'?8747> -> IObservable<IDictionary<'?8748,'?8747>> Type parameters: '?8747, '?8748	Creates an observable sequence according to a specified key selector function
`toDictionaryCompareElements(...)` Signature: keySelector:('Source -> 'Key) -> elementSelector:('Source -> 'Elm) -> comparer:'Key -> source:'Source -> IObservable<IDictionary<'Key,'Elm>> Type parameters: 'Source, 'Key, 'Elm	Creates an observable sequence according to a specified key selector function
`toDictionaryComparer(...)` Signature: keySelector:('Source -> 'Key) -> comparer:'Key -> source:'Source -> IObservable<IDictionary<'Key,'Source>> Type parameters: 'Source, 'Key	Creates an observable sequence according to a specified key selector function and an a comparer
`toDictionaryElements(...)` Signature: keySelector:('Source -> 'Key) -> elementSelector:('Source -> 'Elm) -> source:'Source -> IObservable<IDictionary<'Key,'Elm>> Type parameters: 'Source, 'Key, 'Elm	Creates an observable sequence according to a specified key selector function
`toEnumerable(source)` Signature: source:IObservable<'T> -> IEnumerable<'T> Type parameters: 'T	Converts an observable into a seq
`toEvent(source)` Signature: source:IObservable<unit> -> IEventSource<unit>	Exposes an observable sequence as an object with an Action based .NET event
`toEventType(source)` Signature: source:IObservable<'Source> -> IEventSource<'Source> Type parameters: 'Source	Exposes an observable sequence as an object with an Action<'Source> based .NET event.
`toList(source)` Signature: source:IObservable<'?8764> -> IObservable<IList<'?8764>> Type parameters: '?8764	Creates a list from an observable sequence
`toLookup keySelector source` Signature: keySelector:('Source -> 'Key) -> source:IObservable<'Source> -> IObservable<ILookup<'Key,'Source>> Type parameters: 'Source, 'Key	Creates a lookup from an observable sequence according to a specified key selector function.
`toLookupCompare(...)` Signature: keySelector:('Source -> 'Key) -> comparer:IEqualityComparer<'Key> -> source:IObservable<'Source> -> IObservable<ILookup<'Key,'Source>> Type parameters: 'Source, 'Key	Creates a lookup from an observable sequence according to a specified key selector function, and a comparer.
`toLookupCompareElement(...)` Signature: keySelector:('Source -> 'Key) -> elementSelector:('Source -> 'Element) -> source:IObservable<'Source> -> IObservable<ILookup<'Key,'Element>> Type parameters: 'Source, 'Key, 'Element	Creates a lookup from an observable sequence according to a specified key selector function, and an element selector function.
`toLookupElement(...)` Signature: keySelector:('Source -> 'Key) -> elementSelector:('Source -> 'Element) -> comparer:IEqualityComparer<'Key> -> source:IObservable<'Source> -> IObservable<ILookup<'Key,'Element>> Type parameters: 'Source, 'Key, 'Element	Creates a lookup from an observable sequence according to a specified key selector function, and an element selector function.
`toObservable(source)` Signature: source:seq<'T> -> IObservable<'T> Type parameters: 'T	Converts a seq into an observable
`using resourceFactory observableFactory` Signature: resourceFactory:(unit -> 'TResource) -> observableFactory:('TResource -> IObservable<'Result>) -> IObservable<'Result> Type parameters: 'TResource, 'Result	Constructs an observable sequence that depends on a resource object, whose lifetime is tied to the resulting observable sequence's lifetime.
`usingAsync(...)` Signature: resourceFactory:(CancellationToken -> Async<'?8785>) -> observableFactory:('?8785 -> CancellationToken -> Async<IObservable<'?8786>>) -> IObservable<'?8786> Type parameters: '?8785, '?8786	Constructs an observable sequence that depends on a resource object, whose lifetime is tied to the resulting observable sequence's lifetime. The resource is obtained and used through asynchronous functions. The cancellation token passed to the asyncrhonous functions is tied to the returned disposable subscription, allowing best-effor cancellation at any stage of the resource acquisition or usage.
`wait(source)` Signature: source:IObservable<'?8788> -> '?8788 Type parameters: '?8788	waits for the observable sequence to complete and returns the last element of the sequence. If the sequence terminates with OnError notification, the exception is thrown
`whileLoop condition source` Signature: condition:(unit -> bool) -> source:IObservable<'?8790> -> IObservable<'?8790> Type parameters: '?8790	Repeats the given function as long as the specified condition holds where the condition is evaluated before each repeated source is subscribed to
`window windowClosingSelector source` Signature: windowClosingSelector:(unit -> IObservable<'WindowClosing>) -> source:IObservable<'Source> -> IObservable<IObservable<'Source>> Type parameters: 'WindowClosing, 'Source	Projects each element of an observable sequence into consecutive non-overlapping windows. windowClosingSelector - A function invoked to define the boundaries of the produced windows. A new window is started when the previous one is closed
`windowBounded windowBoundaries source` Signature: windowBoundaries:IObservable<'WindowBoundary> -> source:IObservable<'Source> -> IObservable<IObservable<'Source>> Type parameters: 'WindowBoundary, 'Source	Projects each element of an observable sequence into consecutive non-overlapping windows windowBoundaries - Sequence of window boundary markers. The current window is closed and a new window is opened upon receiving a boundary marker
`windowCount count source` Signature: count:int -> source:IObservable<'Source> -> IObservable<IObservable<'Source>> Type parameters: 'Source	Projects each element of an observable sequence into consecutive non-overlapping windows which are produced based on element count information.
`windowCountSkip count skip source` Signature: count:int -> skip:int -> source:IObservable<'Source> -> IObservable<IObservable<'Source>> Type parameters: 'Source	Projects each element of an observable sequence into zero or more windows which are produced based on element count information
`windowOpenClose(...)` Signature: windowOpenings:IObservable<'WinOpen> -> windowClosingSelector:('WinOpen -> IObservable<'WinClose>) -> source:IObservable<'Source> -> IObservable<IObservable<'Source>> Type parameters: 'WinOpen, 'WinClose, 'Source	Projects each element of an observable sequence into zero or more windows. windowOpenings - Observable sequence whose elements denote the creation of new windows. windowClosingSelector - A function invoked to define the closing of each produced window.
`windowTimeCount timeSpan count source` Signature: timeSpan:TimeSpan -> count:int -> source:IObservable<'Source> -> IObservable<IObservable<'Source>> Type parameters: 'Source	Projects each element of an observable sequence into a window that is completed when either it's full or a given amount of time has elapsed. A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first
`windowTimeCountOn(...)` Signature: scheduler:IScheduler -> timeSpan:TimeSpan -> count:int -> source:IObservable<'?8816> -> IObservable<IObservable<'?8816>> Type parameters: '?8816	Projects each element of an observable sequence into a window that is completed when either it's full or a given amount of time has elapsed, using the specified scheduler to run timers. A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first
`windowTimeShift(...)` Signature: timeSpan:TimeSpan -> timeShift:TimeSpan -> source:IObservable<'Source> -> IObservable<IObservable<'Source>> Type parameters: 'Source	Projects each element of an observable sequence into consecutive non-overlapping windows. windowBoundaries - Sequence of window boundary markers. The current window is closed and a new window is opened upon receiving a boundary marker.
`windowTimeShiftOn(...)` Signature: scheduler:IScheduler -> timeSpan:TimeSpan -> timeShift:TimeSpan -> source:IObservable<'?8805> -> IObservable<IObservable<'?8805>> Type parameters: '?8805	Projects each element of an observable sequence into consecutive non-overlapping windows, using the specified scheduler to run timers. windowBoundaries - Sequence of window boundary markers. The current window is closed and a new window is opened upon receiving a boundary marker.
`windowTimeSpan timeSpan source` Signature: timeSpan:TimeSpan -> source:IObservable<'Source> -> IObservable<IObservable<'Source>> Type parameters: 'Source	Projects each element of an observable sequence into consecutive non-overlapping windows which are produced based on timing information.
`windowTimeSpanOn(...)` Signature: scheduler:IScheduler -> timeSpan:TimeSpan -> source:IObservable<'?8797> -> IObservable<IObservable<'?8797>> Type parameters: '?8797	Projects each element of an observable sequence into consecutive non-overlapping windows which are produced based on timing information, using the specified scheduler to run timers.
`withLatestFrom(...)` Signature: resultSelector:('?8818 -> '?8819 -> '?8820) -> second:IObservable<'?8819> -> first:IObservable<'?8818> -> IObservable<'?8820> Type parameters: '?8818, '?8819, '?8820	Merges the specified observable sequences into one observable sequence by using the selector function only when the first observable sequence produces an element and there was some element produced by the second observable sequence
`zip first second` Signature: first:IObservable<'Source1> -> second:IObservable<'Source2> -> IObservable<'Source1 * 'Source2> Type parameters: 'Source1, 'Source2	Merges two observable sequences into one observable sequence of pairs.
`zip3 first second third` Signature: first:IObservable<'Source1> -> second:IObservable<'Source2> -> third:IObservable<'Source3> -> IObservable<'Source1 * 'Source2 * 'Source3> Type parameters: 'Source1, 'Source2, 'Source3	Merges three observable sequences into one observable sequence of triples.
`zipArray(sources)` Signature: sources:IObservable<'Source> [] -> IObservable<IList<'Source>> Type parameters: 'Source	Merges the specified observable sequences into one observable sequence by emitting a list with the elements of the observable sequences at corresponding indexe
`zipSeq(sources)` Signature: sources:seq<IObservable<'Source>> -> IObservable<IList<'Source>> Type parameters: 'Source	Merges the specified observable sequences into one observable sequence by emitting a list with the elements of the observable sequences at corresponding indexes.
`zipSeqMap resultSelector sources` Signature: resultSelector:(IList<'S> -> 'R) -> sources:seq<IObservable<'S>> -> IObservable<'R> Type parameters: 'S, 'R	Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.
`zipWith resultSelector first second` Signature: resultSelector:('Source1 -> 'Source2 -> 'Result) -> first:IObservable<'Source1> -> second:IObservable<'Source2> -> IObservable<'Result> Type parameters: 'Source1, 'Source2, 'Result	Merges two observable sequences into one observable sequence by combining their elements through a projection function.
`zipWithSeq resultSelector second first` Signature: resultSelector:('Source1 -> 'Source2 -> 'Result) -> second:seq<'Source2> -> first:IObservable<'Source1> -> IObservable<'Result> Type parameters: 'Source1, 'Source2, 'Result	Merges an observable sequence and an enumerable sequence into one observable sequence by using the selector function.

Type extensions

Type extension	Description
`Observer.Create(onNext)` Signature: (onNext:('?8042 -> unit)) -> IObserver<'?8042> Type parameters: '?8042	Creates an observer from the specified onNext function. CompiledName: `Observer.Create.Static`
`Observer.Create(onNext, onError)` Signature: (onNext:('?8044 -> unit) * onError:(exn -> unit)) -> IObserver<'?8044> Type parameters: '?8044	Creates an observer from the specified onNext and onError functions. CompiledName: `Observer.Create.Static`
`Observer.Create(onNext, onCompleted)` Signature: (onNext:('?8046 -> unit) * onCompleted:(unit -> unit)) -> IObserver<'?8046> Type parameters: '?8046	Creates an observer from the specified onNext and onCompleted functions. CompiledName: `Observer.Create.Static`
`Observer.Create(...)` Signature: (onNext:('?8048 -> unit) * onError:(exn -> unit) * onCompleted:(unit -> unit)) -> IObserver<'?8048> Type parameters: '?8048	Creates an observer from the specified onNext, onError, and onCompleted functions. CompiledName: `Observer.Create.Static`
`Observable.Create(subscribe)` Signature: (subscribe:(IObserver<'T> -> unit -> unit)) -> IObservable<'T> Type parameters: 'T	Creates an observable sequence from the specified Subscribe method implementation. CompiledName: `Observable.Create.Static`
`Observable.CreateAsync(subscribe)` Signature: (subscribe:(IObserver<'T> -> Async<IDisposable>)) -> IObservable<'T> Type parameters: 'T	Creates an observable sequence from the specified asynchronous Subscribe method implementation. CompiledName: `Observable.CreateAsync.Static`
`Observer.Empty` Signature: IObserver<obj>	Creates an observer that ignores the incoming emits from 'OnNext', 'OnError', and 'OnCompleted'. CompiledName: `Observer.get_Empty.Static`
`Observer.Empty` Signature: IObserver<obj>	Creates an observer that ignores the incoming emits from 'OnNext', 'OnError', and 'OnCompleted'. CompiledName: `Observer.get_Empty.Static`
`x.Subscribe(onNext)` Signature: (onNext:('T -> unit)) -> IDisposable	Subscribes to the Observable with just a next-function. CompiledName: IObservable`1.Subscribe
`x.Subscribe(onNext, onError)` Signature: (onNext:('T -> unit) * onError:(exn -> unit)) -> IDisposable	Subscribes to the Observable with a next and an error-function. CompiledName: IObservable`1.Subscribe
`x.Subscribe(onNext, onCompleted)` Signature: (onNext:('T -> unit) * onCompleted:(unit -> unit)) -> IDisposable	Subscribes to the Observable with a next and a completion callback. CompiledName: IObservable`1.Subscribe
`x.Subscribe(...)` Signature: (onNext:('T -> unit) * onError:(exn -> unit) * onCompleted:(unit -> unit)) -> IDisposable	Subscribes to the Observable with all 3 callbacks. CompiledName: IObservable`1.Subscribe

FSharp.Control.Reactive

Observable

Functions and values

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Type extensions