callback : 'T -> unit

The function to call when the event is triggered.

sourceEvent : IEvent<'Del, 'T>

The input event.

Example

 open System

 let createTimer interval =
     let timer = new Timers.Timer(interval)
     timer.AutoReset <- true
     timer.Enabled <- true
     timer.Elapsed

 let timer = createTimer 1000

 Event.add (fun (event: Timers.ElapsedEventArgs) -> printfn $"{event.SignalTime} ")  timer

 Console.ReadLine() |> ignore

chooser : 'T -> 'U option

The function to select and transform event values to pass on.

sourceEvent : IEvent<'Del, 'T>

The input event.

Returns: IEvent<'U>

An event that fires only when the chooser returns Some.

Example

 open System

 let createTimer interval =
     let timer = new Timers.Timer(interval)
     timer.AutoReset <- true
     timer.Enabled <- true
     timer.Elapsed

 let timer = createTimer 1000

 let getEvenSeconds (number: Timers.ElapsedEventArgs) =
     match number with
     | _ when number.SignalTime.Second % 2 = 0 -> Some number.SignalTime
     | _ -> None

 let evenSecondsEvent = Event.choose getEvenSeconds timer

 evenSecondsEvent.Subscribe(fun x -> printfn $"{x} ")
 |> ignore

 Console.ReadLine() |> ignore

predicate : 'T -> bool

The function to determine which triggers from the event to propagate.

sourceEvent : IEvent<'Del, 'T>

The input event.

Returns: IEvent<'T>

An event that only passes values that pass the predicate.

Example

 open System

 let createTimer interval =
     let timer = new Timers.Timer(interval)
     timer.AutoReset <- true
     timer.Enabled <- true
     timer.Elapsed

 let timer = createTimer 1000

 let getEvenSeconds (number: Timers.ElapsedEventArgs) =
     match number with
     | _ when number.SignalTime.Second % 2 = 0 -> true
     | _ -> false

 let evenSecondsEvent = Event.filter getEvenSeconds timer

 evenSecondsEvent.Subscribe(fun x -> printfn $"{x} ")
 |> ignore

 Console.ReadLine() |> ignore

mapping : 'T -> 'U

The function to transform event values.

sourceEvent : IEvent<'Del, 'T>

The input event.

Returns: IEvent<'U>

An event that passes the transformed values.

Example

 open System

 let createTimer interval =
     let timer = new Timers.Timer(interval)
     timer.AutoReset <- true
     timer.Enabled <- true
     timer.Elapsed

 let timer = createTimer 1000

 let transformSeconds (number: Timers.ElapsedEventArgs) =
     match number with
     | _ when number.SignalTime.Second % 2 = 0 -> 100
     | _ -> -500

 let evenSecondsEvent = Event.map transformSeconds timer

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

 Console.ReadLine() |> ignore

event1 : IEvent<'Del1, 'T>

The first input event.

event2 : IEvent<'Del2, 'T>

The second input event.

Returns: IEvent<'T>

An event that fires when either of the input events fire.

Example

 open System.Reactive.Linq
 open System
 let createTimer interval =
     let timer = new Timers.Timer(interval)
     timer.AutoReset <- true
     timer.Enabled <- true
     timer.Elapsed

 let oneSecondTimer = createTimer 1000
 let fiveSecondsTimer = createTimer 5000

 let result = Event.merge oneSecondTimer fiveSecondsTimer

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

 Console.ReadLine() |> ignore

sourceEvent : IEvent<'Del, 'T>

The input event.

Returns: IEvent<'T * 'T>

An event that triggers on pairs of consecutive values passed from the source event.

Example

 open System

 let createTimer interval =
     let timer = new Timers.Timer(interval)
     timer.AutoReset <- true
     timer.Enabled <- true
     timer.Elapsed

 let timer = createTimer 1000

 let pairWise = Event.pairwise timer

 let extractPair (pair: Timers.ElapsedEventArgs * Timers.ElapsedEventArgs) =
     let leftPair, rightPair = pair
     printfn $"(Left): {leftPair.SignalTime} (Right): {rightPair.SignalTime}"

 pairWise.Subscribe(extractPair) |> ignore

 Console.ReadLine() |> ignore

predicate : 'T -> bool

The function to determine which output event to trigger.

sourceEvent : IEvent<'Del, 'T>

The input event.

Returns: IEvent<'T> * IEvent<'T>

A tuple of events. The first is triggered when the predicate evaluates to true and the second when the predicate evaluates to false.

Example

 open System

 let createTimer interval =
     let timer = new Timers.Timer(interval)
     timer.AutoReset <- true
     timer.Enabled <- true
     timer.Elapsed

 let timer = createTimer 1000

 let getEvenSeconds (number: Timers.ElapsedEventArgs) =
     match number with
     | _ when number.SignalTime.Second % 2 = 0 -> true
     | _ -> false

 let leftPartition, rightPartition = Event.partition getEvenSeconds timer

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

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

 Console.ReadLine() |> ignore

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

The function to update the state with each event value.

state : 'U

The initial state.

sourceEvent : IEvent<'Del, 'T>

The input event.

Returns: IEvent<'U>

An event that fires on the updated state values.

Example

 open System

 let createTimer interval =
     let timer = new Timers.Timer(interval)
     timer.AutoReset <- true
     timer.Enabled <- true
     timer.Elapsed

 let timer = createTimer 1000

 let multiplyBy number =
     fun (timerEvent: Timers.ElapsedEventArgs) -> number * timerEvent.SignalTime./// Second

 let initialState = 2

 let scan = Event.scan multiplyBy initialState timer

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

 Console.ReadLine() |> ignore

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

The function to transform event values into one of two types.

sourceEvent : IEvent<'Del, 'T>

The input event.

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

A tuple of events. The first fires whenever splitter evaluates to Choice1of1 and the second fires whenever splitter evaluates to Choice2of2.

Example

 open System

 let createTimer interval =
     let timer = new Timers.Timer(interval)
     timer.AutoReset <- true
     timer.Enabled <- true
     timer.Elapsed

 let timer = createTimer 1000

 let bySeconds (timerEvent: Timers.ElapsedEventArgs) =
     match timerEvent.SignalTime.Second % 2 = 0 with
     | true -> Choice1Of2 timerEvent.SignalTime.Second
     | false -> Choice2Of2 $"{timerEvent.SignalTime.Second} is not an even num ber"

 let evenSplit, printOddNumbers = Event.split bySeconds timer

 let printOutput event functionName =
     Event.add (fun output -> printfn $"{functionName} - Split output: {output}. /// Type: {output.GetType()}") event

 printOutput evenSplit (nameof evenSplit) |> ignore

 printOutput printOddNumbers (nameof printOddNumbers)
 |> ignore

 Console.ReadLine() |> ignore