callback : 'T -> unit

The function to be called on each observation.

source : IObservable<'T>

The input Observable.

Example

 open System.Reactive.Linq
 let numbers = seq { 1..5 }
 let observableNumbers = Observable.ToObservable numbers
 let multiplyByTwo = fun number -> printf $"{number * 2} "
 Observable.add multiplyByTwo observableNumbers

chooser : 'T -> 'U option

The function that returns Some for observations to be propagated and None for observations to ignore.

source : IObservable<'T>

The input Observable.

Returns: IObservable<'U>

An Observable that only propagates some of the observations from the source.

Example

 open System.Reactive.Linq
 let numbers = seq { 1..5 }
 let observableNumbers = Observable.ToObservable numbers

 let getOddNumbers number =
     match number with
     | _ when number % 2 = 0 -> None
     | _ -> Some number

 let map = Observable.choose getOddNumbers observableNumbers

 map.Subscribe(fun x -> printf $"{x} ") |> ignore

predicate : 'T -> bool

The function to apply to observations to determine if it should be kept.

source : IObservable<'T>

The input Observable.

Returns: IObservable<'T>

An Observable that filters observations based on filter.

Example

 open System.Reactive.Linq
 let numbers = seq { 1..5 }
 let observableNumbers = Observable.ToObservable numbers

 let getEvenNumbers = fun number -> number % 2 = 0
 let map = Observable.filter multiplyByTwo observableNumbers

 map.Subscribe(fun x -> printf $"{x} ") |> ignore

mapping : 'T -> 'U

The function applied to observations from the source.

source : IObservable<'T>

The input Observable.

Returns: IObservable<'U>

An Observable of the type specified by mapping.

Example

 open System.Reactive.Linq
 let numbers = seq { 1..5 }
 let observableNumbers = Observable.ToObservable numbers

 let multiplyByTwo = fun number -> number * 2
 let map = Observable.map multiplyByTwo observableNumbers

 map.Subscribe(fun x -> printf $"{x} ") |> ignore

For each observer, the registered intermediate observing object is not thread safe. That is, observations arising from the sources must not be triggered concurrently on different threads.

source1 : IObservable<'T>

The first Observable.

source2 : IObservable<'T>

The second Observable.

Returns: IObservable<'T>

An Observable that propagates information from both sources.

Example

 open System.Reactive.Linq
 open System

 let createTimer interval =
     let timer = new Timers.Timer(interval)
     timer.AutoReset <- true
     timer.Enabled <- true
     Observable.Create(fun observer -> timer.Elapsed.Subscribe(observer))

 let observableFirstTimer = createTimer 1000
 let observableSecondTimer = createTimer 3000

 let result = Observable.merge observableFirstTimer observableSecondTimer

 result.Subscribe(fun output -> printfn $"Output - {output.SignalTime} ")
 |> ignore

 Console.ReadLine() |> ignore

For each observer, the registered intermediate observing object is not thread safe. That is, observations arising from the source must not be triggered concurrently on different threads.

source : IObservable<'T>

The input Observable.

Returns: IObservable<'T * 'T>

An Observable that triggers on successive pairs of observations from the input Observable.

Example

 /// open System.Reactive.Linq
 let numbers = seq { 1..5 }
 let observableNumbers = Observable.ToObservable numbers

 let pairWise = Observable.pairwise observableNumbers

 pairWise.Subscribe(fun pair -> printf $"{pair} ")
 |> ignore

predicate : 'T -> bool

The function to determine which output Observable will trigger a particular observation.

source : IObservable<'T>

The input Observable.

Returns: IObservable<'T> * IObservable<'T>

A tuple of Observables. The first triggers when the predicate returns true, and the second triggers when the predicate returns false.

Example

 open System.Reactive.Linq
 let numbers = seq { 1..5 }
 let observableNumbers = Observable.ToObservable numbers

 let isEvenNumber = fun number -> number % 2 = 0

 let leftPartition, rightPartition =
     Observable.partition isEvenNumber observableNumbers

 leftPartition.Subscribe(fun x -> printfn $"Left partition: {x}") |> ignore

 rightPartition.Subscribe(fun x -> printfn $"Right partition: {x}") |> ignore

For each observer, the registered intermediate observing object is not thread safe. That is, observations arising from the source must not be triggered concurrently on different threads.

collector : 'U -> 'T -> 'U

The function to update the state with each observation.

state : 'U

The initial state.

source : IObservable<'T>

The input Observable.

Returns: IObservable<'U>

An Observable that triggers on the updated state values.

Example

 open System.Reactive.Linq
 let numbers = seq { 1..5 }
 let observableNumbers = Observable.ToObservable numbers

 let multiplyBy number = fun y -> number * y
 let initialState = 2
 let scan = Observable.scan multiplyBy initialState observableNumbers

 scan.Subscribe(fun x -> printf "%A " x) |> ignore

splitter : 'T -> Choice<'U1, 'U2>

The function that takes an observation an transforms it into one of the two output Choice types.

source : IObservable<'T>

The input Observable.

Returns: IObservable<'U1> * IObservable<'U2>

A tuple of Observables. The first triggers when splitter returns Choice1of2 and the second triggers when splitter returns Choice2of2.

Example

 open System.Reactive.Linq
 let numbers = seq { 1..5 }
 let observableNumbers = Observable.ToObservable numbers

 let getEvenNumbers number =
     match number % 2 = 0 with
     | true -> Choice1Of2 number
     | false -> Choice2Of2 $"{number} is not an even number"

 let evenSplit, printOddNumbers = Observable.split getEvenNumbers observableNumbers

 let printOutput observable functionName =
     use subscription =
         Observable.subscribe
             (fun output -> printfn $"{functionName} - Split output: {output}. Type: {output.GetType()}")
             observable

     subscription

 printOutput evenSplit (nameof evenSplit) |> ignore
 printOutput printOddNumbers (nameof printOddNumbers) |> ignore

callback : 'T -> unit

The function to be called on each observation.

source : IObservable<'T>

The input Observable.

Returns: IDisposable

An object that will remove the callback if disposed.

Example

 open System.Reactive.Linq
 let numbers = seq { 1..3 }
 let observableNumbers = Observable.ToObservable numbers
 let printOutput observable =
     use subscription = Observable.subscribe (fun x -> printfn "%A" x) observable
     subscription
 printOutput observableNumbers |> ignore