FSharp.Control.Reactive


Observable

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

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

Functions and values

Function or valueDescription
aggregate accumulator source
Signature: accumulator:('?8104 -> '?8104 -> '?8104) -> source:IObservable<'?8104> -> IObservable<'?8104>
Type parameters: '?8104

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:('?8106 -> bool) -> source:IObservable<'?8106> -> IObservable<bool>
Type parameters: '?8106

Determines whether all elements of an observable satisfy a predicate

amb second first
Signature: second:IObservable<'?8108> -> first:IObservable<'?8108> -> IObservable<'?8108>
Type parameters: '?8108

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<('?8121 -> '?8122)> -> m:IObservable<'?8121> -> IObservable<'?8122>
Type parameters: '?8121, '?8122

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<'?8124> -> first:IObservable<'?8125> -> Pattern<'?8125,'?8124>
Type parameters: '?8124, '?8125

Matches when both observable sequences have an available value

buffer bufferClosingSelector source
Signature: bufferClosingSelector:IObservable<'BufferClosing> -> source:IObservable<'?8128> -> IObservable<IList<'?8128>>
Type parameters: 'BufferClosing, '?8128
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<'?8133> -> IObservable<IList<'?8133>>
Type parameters: '?8133

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<'?8135> -> IObservable<IList<'?8135>>
Type parameters: '?8135

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<'?8147> -> IObservable<IList<'?8147>>
Type parameters: 'BufferOpening, 'T, '?8147

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<'?8137> -> IObservable<IList<'?8137>>
Type parameters: '?8137

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<'?8141> -> IObservable<IList<'?8141>>
Type parameters: '?8141

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<'?8143> -> IObservable<IList<'?8143>>
Type parameters: '?8143

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<'?8139> -> IObservable<IList<'?8139>>
Type parameters: '?8139

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<'?8149> -> IObservable<IList<'?8149>>
Type parameters: '?8149

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<'?8151> -> IObservable<IList<'?8151>>
Type parameters: '?8151

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 -> '?8155) -> sources:IDictionary<'?8155,IObservable<'?8156>> -> IObservable<'?8156>
Type parameters: '?8155, '?8156

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<'?8161> -> sources:IDictionary<'?8161,IObservable<'?8162>> -> IObservable<'?8162>
Type parameters: '?8161, '?8162

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<'?8166> -> IObservable<'?8166 option>
Type parameters: '?8166

Continues an observable sequence that is terminated by an exception with an optional as result type.

catchResult handler source
Signature: handler:('?8168 -> IObservable<'?8169>) -> source:IObservable<'?8170> -> IObservable<Result<'?8170,'?8169>>
Type parameters: '?8168, '?8169, '?8170

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:('?8172 -> IObservable<'?8173>) -> source:IObservable<'?8173> -> IObservable<'?8173>
Type parameters: '?8172, '?8173

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:('?8889 -> '?8890 option) -> source:IObservable<'?8889> -> IObservable<'?8890>
Type parameters: '?8889, '?8890

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 -> '?8184) -> merge:('?8184 -> '?8185 -> '?8184) -> source:IObservable<'?8185> -> IEnumerable<'?8184>
Type parameters: '?8184, '?8185

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 -> '?8187) -> merge:('?8187 -> '?8188 -> '?8187) -> getNewCollector:('?8187 -> '?8187) -> source:IObservable<'?8188> -> IEnumerable<'?8187>
Type parameters: '?8187, '?8188

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<'?8210> -> IDisposable
Type parameters: '?8210

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<'?8919> -> source:IObservable<'?8920> -> IObservable<'?8919>
Type parameters: '?8919, '?8920

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:('?8925 -> '?8926 option) -> source:IObservable<'?8925> -> IObservable<'?8926>
Type parameters: '?8925, '?8926

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:('?8922 -> '?8923 option) -> source:IObservable<'?8922> -> IObservable<'?8923>
Type parameters: '?8922, '?8923

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:'?8212 -> source:IObservable<'?8212> -> IObservable<bool>
Type parameters: '?8212

Determines whether an observable sequence contains a specified element by using the default equality comparer.

containsCompare comparer value source
Signature: comparer:IEqualityComparer<'?8214> -> value:'?8214 -> source:IObservable<'?8214> -> IObservable<bool>
Type parameters: '?8214

Determines whether an observable sequence contains a specified element by using a specified EqualityComparer

count source
Signature: source:IObservable<'?8216> -> IObservable<int>
Type parameters: '?8216

Counts the elements

countSatisfy predicate source
Signature: predicate:('?8218 -> bool) -> source:IObservable<'?8218> -> IObservable<int>
Type parameters: '?8218

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<'?8228> -> IObservable<'?8228>
Type parameters: '?8228

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<'?8242> -> IObservable<'?8242>
Type parameters: '?8242

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<'?8246> -> IObservable<'?8246>
Type parameters: '?8246

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<'?8232> -> IObservable<'?8232>
Type parameters: '?8232

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<'?8248>> -> IObservable<'?8248>
Type parameters: '?8248

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<'?8278>
Type parameters: '?8278

Returns an empty sequence, using the specified scheduler to send out the single OnCompleted message.

emptyCompletedWitness scheduler witness
Signature: scheduler:IScheduler -> witness:'?8280 -> IObservable<'?8280>
Type parameters: '?8280

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<'?8290>
Type parameters: '?8290
exhaustMap f source
Signature: f:('?8896 -> '?8897) -> source:IObservable<'?8896> -> IObservable<'?8898>
Type parameters: '?8896, '?8897, '?8898

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:('?8292 -> bool) -> source:IObservable<'?8292> -> IObservable<bool>
Type parameters: '?8292

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<'?8298> -> IObservable<'?8298>
Type parameters: '?8298

Invokes a specified action after the source observable sequence terminates gracefully of 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<'?8322>) -> source:IObservable<'Source> -> IObservable<'?8322>
Type parameters: 'Source, '?8322

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:('?8324 -> '?8325 -> '?8324) -> init:'?8324 -> source:IObservable<'?8325> -> IObservable<'?8324>
Type parameters: '?8324, '?8325

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:('?8327 -> '?8328 -> '?8327) -> init:'?8327 -> map:('?8327 -> '?8329) -> source:IObservable<'?8328> -> IObservable<'?8329>
Type parameters: '?8327, '?8328, '?8329

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<'?8337>
Type parameters: 'TEventArgs, '?8337

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<obj> -> unit) -> removeHandler:(EventHandler<obj> -> unit) -> IObservable<obj>
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<'?8368> -> IEnumerator<'?8368>
Type parameters: '?8368

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:('?8373 -> '?8374) -> comparer:IEqualityComparer<'?8374> -> source:IObservable<'?8373> -> IObservable<IGroupedObservable<'?8374,'?8373>>
Type parameters: '?8373, '?8374

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<'?8414> -> IObservable<'?8414>
Type parameters: '?8414

Takes the first element of the observable sequence

infinite ()
Signature: unit -> IObservable<'?8506>
Type parameters: '?8506

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<'?8418> -> IObservable<bool>
Type parameters: '?8418

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<'?8430> -> f:('?8431 -> '?8430 -> '?8432) -> left:IObservable<'?8431> -> IObservable<'?8432>
Type parameters: '?8430, '?8431, '?8432

Correlates the elements of two sequences based on overlapping durations.

joinMap right fLeft fRight fResult left
Signature: right:IObservable<'?8434> -> fLeft:('?8435 -> IObservable<'?8436>) -> fRight:('?8434 -> IObservable<'?8437>) -> fResult:('?8435 -> '?8434 -> '?8438) -> left:IObservable<'?8435> -> IObservable<'?8438>
Type parameters: '?8434, '?8435, '?8436, '?8437, '?8438

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<'?8446> -> IEnumerable<'?8446>
Type parameters: '?8446

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:('?8318 -> Async<'?8319>) -> '?8318 -> IObservable<'?8319>
Type parameters: '?8318, '?8319

Helper function for turning async workflows into observables

log prefix source
Signature: prefix:string -> source:IObservable<'?8532> -> IObservable<'?8532>
Type parameters: '?8532

Logs the incoming emits with a given prefix to the console.

logTo prefix f source
Signature: prefix:string -> f:(string -> unit) -> source:IObservable<'?8530> -> IObservable<'?8530>
Type parameters: '?8530

Logs the incoming emits with a given prefix to a specified target.

longCount source
Signature: source:IObservable<'?8448> -> IObservable<int64>
Type parameters: '?8448

Returns an observable sequence containing a int64 that represents the total number of elements in an observable sequence

longCountSatisfy predicate source
Signature: predicate:('?8450 -> bool) -> source:IObservable<'?8450> -> IObservable<int64>
Type parameters: '?8450

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:('?8452 -> '?8453) -> source:IObservable<'?8452> -> IObservable<'?8453>
Type parameters: '?8452, '?8453

Maps the given observable with the given function

map2 f a b
Signature: f:IObservable<('?8458 -> '?8459 -> '?8460)> -> a:IObservable<'?8458> -> b:IObservable<'?8459> -> IObservable<'?8460>
Type parameters: '?8458, '?8459, '?8460

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:'?8466 -> source:IObservable<'T> -> IObservable<'?8466>
Type parameters: '?8466, '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<'?8471> -> IObservable<Notification<'?8471>>
Type parameters: '?8471

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:'?8497 -> source:IObservable<'?8497> -> IEnumerable<'?8497>
Type parameters: '?8497

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<'?8499,'?8500> -> source:IObservable<'?8499> -> IConnectableObservable<'?8500>
Type parameters: '?8499, '?8500

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<'?8502,'?8503>) -> selector:(IObservable<'?8503> -> IObservable<'?8504>) -> source:IObservable<'?8502> -> IObservable<'?8504>
Type parameters: '?8502, '?8503, '?8504

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:'?8508 -> IObservable<'?8508>
Type parameters: '?8508

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<'?8510> -> IEnumerable<'?8510>
Type parameters: '?8510

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<'?8516> -> IObservable<'?8516>
Type parameters: '?8516

Wraps the source sequence in order to run its observer callbacks on the specified scheduler.

observeOnContext context source
Signature: context:SynchronizationContext -> source:IObservable<'?8518> -> IObservable<'?8518>
Type parameters: '?8518

Wraps the source sequence in order to run its observer callbacks on the specified synchronization context.

ofAsync asyncOperation
Signature: asyncOperation:Async<'?8316> -> IObservable<'?8316>
Type parameters: '?8316

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<'?8520>
Type parameters: '?8520

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:('?8528 -> unit) -> source:IObservable<'?8528> -> IObservable<'?8528>
Type parameters: '?8528

Iterates through the observable and performs the given side-effect

performFinally f source
Signature: f:(unit -> unit) -> source:IObservable<'?8534> -> IObservable<'?8534>
Type parameters: '?8534

Invokes the finally action after source observable sequence terminates normally or by an exception.

poll period source
Signature: period:DateTimeOffset -> source:IObservable<Result<'?8886,'?8887>> -> IObservable<Result<'?8886,'?8887>>
Type parameters: '?8886, '?8887

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<'?8883,'?8884>> -> IObservable<Result<'?8883,'?8884>>
Type parameters: '?8883, '?8884

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<'?8536> -> IConnectableObservable<'?8536>
Type parameters: '?8536

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<'?8546> -> IConnectableObservable<'?8546>
Type parameters: '?8546

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:('?8553 -> '?8553 -> '?8553) -> source:IObservable<'?8553> -> IObservable<'?8553>
Type parameters: '?8553

Reduces the observable

refCount source
Signature: source:IConnectableObservable<'?8555> -> IObservable<'?8555>
Type parameters: '?8555

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<'?8567> -> IConnectableObservable<'?8567>
Type parameters: '?8567

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:'?8601 -> IObservable<'?8601>
Type parameters: '?8601
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<'?8603> -> IObservable<'?8603>
Type parameters: '?8603

Samples the observable at the given interval

sampleOn scheduler interval source
Signature: scheduler:IScheduler -> interval:TimeSpan -> source:IObservable<'?8605> -> IObservable<'?8605>
Type parameters: '?8605

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<'?8615> -> IObservable<'?8615>
Type parameters: '?8615

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<'?8617> -> IObservable<'?8617>
Type parameters: '?8617

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 -> '?8913) -> IObservable<'?8914>
Type parameters: '?8913, '?8914

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 -> '?8907) -> IObservable<'?8908>
Type parameters: '?8907, '?8908

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:'?8903 -> max:int -> callOnError:(exn -> bool) -> sourceFactory:(unit -> '?8904) -> IObservable<'?8905>
Type parameters: '?8903, '?8904, '?8905

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 -> '?8910) -> IObservable<'?8911>
Type parameters: '?8910, '?8911

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:'?8623 -> IObservable<'?8623>
Type parameters: '?8623

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<'?8635> -> IObservable<'?8635>
Type parameters: '?8635

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<'?8629> -> IObservable<'?8629>
Type parameters: '?8629

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<'?8639> -> IObservable<'?8639>
Type parameters: '?8639

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:'?8648 -> source:IObservable<'T> -> IObservable<'T>
Type parameters: '?8648, 'T

Prepends a sequence of values to an observable sequence.

startWithOn scheduler values source
Signature: scheduler:IScheduler -> values:'?8651 -> source:IObservable<'T> -> IObservable<'T>
Type parameters: '?8651, '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:('?8668 -> unit) -> source:IObservable<'?8668> -> IDisposable
Type parameters: '?8668

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<'?8675> -> source:IObservable<'?8675> -> IDisposable
Type parameters: '?8675

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:('?8677 -> unit) -> onError:(exn -> unit) -> onCompleted:(unit -> unit) -> source:IObservable<'?8677> -> IDisposable
Type parameters: '?8677

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:('?8672 -> unit) -> onCompleted:'?8673 -> source:IObservable<'?8672> -> IDisposable
Type parameters: '?8672, '?8673

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:('?8670 -> unit) -> onError:(exn -> unit) -> source:IObservable<'?8670> -> IDisposable
Type parameters: '?8670

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<'?8683>> -> IObservable<'?8683>
Type parameters: '?8683

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:('?8892 -> '?8893) -> source:IObservable<'?8892> -> IObservable<'?8894>
Type parameters: '?8892, '?8893, '?8894

Description Projects each source value to an Observable which is merged in the output Observable, emitting values only from the most recently projected Observable.

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<'?8689> -> IObservable<'?8689>
Type parameters: '?8689

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<'?8699> -> IObservable<'?8699>
Type parameters: '?8699

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<'?8709> -> IObservable<IList<'?8709>>
Type parameters: '?8709

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<'?8701> -> IObservable<'?8701>
Type parameters: '?8701

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<'?8705> -> IObservable<'?8705>
Type parameters: '?8705

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<'?8693> -> IObservable<'?8693>
Type parameters: '?8693

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<'?8695> -> IObservable<'?8695>
Type parameters: '?8695

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<'?8697> -> IObservable<'?8697>
Type parameters: '?8697

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<'?8718> -> IObservable<'?8718>
Type parameters: '?8718

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<'?8735>
Type parameters: '?8735

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:'?8733 -> ex:exn -> IObservable<'?8733>
Type parameters: '?8733

Returns an observable sequence that terminates with an exception.

throwWitnessOn scheduler witeness ex
Signature: scheduler:'?8737 -> witeness:IScheduler -> ex:exn -> IObservable<'?8737>
Type parameters: '?8737

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<'?8744> -> IObservable<TimeInterval<'?8744>>
Type parameters: '?8744

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<'?8748> -> IObservable<'?8748>
Type parameters: '?8748

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<'?8752> -> source:IObservable<'?8752> -> IObservable<'?8752>
Type parameters: '?8752

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<'?8756> -> IObservable<'?8756>
Type parameters: '?8756

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<'?8760> -> source:IObservable<'?8760> -> IObservable<'?8760>
Type parameters: '?8760

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<'?8784> -> IObservable<'?8784 []>
Type parameters: '?8784

Creates an array from an observable sequence.

toDictionary keySelector source
Signature: keySelector:('?8786 -> '?8787) -> source:IObservable<'?8786> -> IObservable<IDictionary<'?8787,'?8786>>
Type parameters: '?8786, '?8787

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<'?8803> -> IObservable<IList<'?8803>>
Type parameters: '?8803

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<'?8824>) -> observableFactory:('?8824 -> CancellationToken -> Async<IObservable<'?8825>>) -> IObservable<'?8825>
Type parameters: '?8824, '?8825

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<'?8827> -> '?8827
Type parameters: '?8827

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<'?8829> -> IObservable<'?8829>
Type parameters: '?8829

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<'?8855> -> IObservable<IObservable<'?8855>>
Type parameters: '?8855

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<'?8844> -> IObservable<IObservable<'?8844>>
Type parameters: '?8844

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<'?8836> -> IObservable<IObservable<'?8836>>
Type parameters: '?8836

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:('?8857 -> '?8858 -> '?8859) -> second:IObservable<'?8858> -> first:IObservable<'?8857> -> IObservable<'?8859>
Type parameters: '?8857, '?8858, '?8859

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 extensionDescription
Create(onNext)
Signature: (onNext:('?8081 -> unit)) -> IObserver<'?8081>
Type parameters: '?8081

Creates an observer from the specified onNext function.

CompiledName: Observer.Create.Static

Create(onNext, onError)
Signature: (onNext:('?8083 -> unit) * onError:(exn -> unit)) -> IObserver<'?8083>
Type parameters: '?8083

Creates an observer from the specified onNext and onError functions.

CompiledName: Observer.Create.Static

Create(onNext, onCompleted)
Signature: (onNext:('?8085 -> unit) * onCompleted:(unit -> unit)) -> IObserver<'?8085>
Type parameters: '?8085

Creates an observer from the specified onNext and onCompleted functions.

CompiledName: Observer.Create.Static

Create(onNext, onError, onCompleted)
Signature: (onNext:('?8087 -> unit) * onError:(exn -> unit) * onCompleted:(unit -> unit)) -> IObserver<'?8087>
Type parameters: '?8087

Creates an observer from the specified onNext, onError, and onCompleted functions.

CompiledName: Observer.Create.Static

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

Create(subscribe)
Signature: (subscribe:(IObserver<'?8092> -> IDisposable)) -> IObservable<'?8092>
Type parameters: '?8092

Creates an observable sequence from the specified Subscribe method implementation.

CompiledName: Observable.Create.Static

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

Empty
Signature: IObserver<obj>

Creates an observer that ignores the incoming emits from 'OnNext', 'OnError', and 'OnCompleted'.

CompiledName: Observer.get_Empty.Static

Empty
Signature: IObserver<obj>

Creates an observer that ignores the incoming emits from 'OnNext', 'OnError', and 'OnCompleted'.

CompiledName: Observer.get_Empty.Static

Subscribe(onNext)
Signature: (onNext:('T -> unit)) -> IDisposable

Subscribes to the Observable with just a next-function.

CompiledName: IObservable`1.Subscribe

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

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

Subscribe(onNext, onError, onCompleted)
Signature: (onNext:('T -> unit) * onError:(exn -> unit) * onCompleted:(unit -> unit)) -> IDisposable

Subscribes to the Observable with all 3 callbacks.

CompiledName: IObservable`1.Subscribe

Fork me on GitHub