F# FormattingObservable
Functions and values
| Function or value | Description |
asUpdates input
Signature: input:IObservable<'T> -> IObservable<ObservableUpdate<'T>>
Type parameters: 'T |
Turns observable into an observable that only calls OnNext method of the observer, but gives it a discriminated union that represents different kinds of events (error, next, completed) |
bufferWithTimeOrCount (...)
Signature: timeSpan:TimeSpan -> count:int -> source:IObservable<'T> -> IObservable<seq<'T>>
Type parameters: 'T |
|
combineLatest left right
Signature: left:IObservable<'TLeft> -> right:IObservable<'TRight> -> IObservable<'TLeft * 'TRight>
Type parameters: 'TLeft, 'TRight |
|
create f
Signature: f:(IObserver<'?22257> -> unit -> unit) -> IObservable<'?22257>
Type parameters: '?22257 |
|
createWithDisposable f
Signature: f:(IObserver<'?22259> -> IDisposable) -> IObservable<'?22259>
Type parameters: '?22259 |
|
delay milliseconds observable
Signature: milliseconds:int -> observable:IObservable<'T> -> IObservable<'T>
Type parameters: 'T |
Delay execution of Observer function |
error e
Signature: e:exn -> IObservable<'?22261>
Type parameters: '?22261 |
|
FromEvent (...)
Signature: (conversion:Func<Action<'TEventArgs>,'TDelegate> * addHandler:Action<'TDelegate> * removeHandler:Action<'TDelegate>) -> IObservable<'TEventArgs>
Type parameters: 'TEventArgs, 'TDelegate |
|
FromEventHandler (...)
Signature: (addHandler:Action<EventHandler<obj>> * removeHandler:Action<EventHandler<obj>>) -> IObservable<obj>
Type parameters: 'TEventArgs |
|
guard f e
Signature: f:(unit -> unit) -> e: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. |
invoke f w
Signature: f:((unit -> unit) -> unit) -> w:IObservable<'?22304> -> IObservable<'?22304>
Type parameters: '?22304 |
Invoke Observer function through specified function |
mapi f source
Signature: f:(int -> 'TSource -> 'TResult) -> source:IObservable<'TSource> -> IObservable<'TResult>
Type parameters: 'TSource, 'TResult |
|
ofSeq items
Signature: items:seq<'TItem> -> IObservable<'TItem>
Type parameters: 'TItem |
|
result x
Signature: x:'?22255 -> IObservable<'?22255>
Type parameters: '?22255 |
|
synchronize f
Signature: f:(((unit -> unit) -> unit) -> '?22308) -> '?22308
Type parameters: '?22308 |
Helper that can be used for writing CPS-style code that resumes on the same thread where the operation was started. |
takeWhile f source
Signature: f:('TSource -> bool) -> source:IObservable<'TSource> -> IObservable<'TSource>
Type parameters: 'TSource |
|
throttle milliseconds source
Signature: milliseconds:int -> source:IObservable<'T> -> IObservable<'T>
Type parameters: 'T |
|
windowed size input
Signature: size:int -> input:IObservable<'T> -> IObservable<'T []>
Type parameters: 'T |
Returns an observable that yields sliding windows of containing elements drawn from the input observable. Each window is returned as a fresh array. |
zip left right
Signature: left:IObservable<'TLeft> -> right:IObservable<'TRight> -> IObservable<'TLeft * 'TRight>
Type parameters: 'TLeft, 'TRight |
|
Type extensions
| Type extension | Description |
AwaitObservable(observable)
Signature: observable:IObservable<'T1> -> Async<'T1>
Type parameters: 'T1 |
Creates an asynchronous workflow that will be resumed when the specified observables produces a value. The workflow will return the value produced by the observable. |
AwaitObservable(ev1, ev2)
Signature: (ev1:IObservable<'T1> * ev2:IObservable<'T2>) -> Async<Choice<'T1,'T2>>
Type parameters: 'T1, 'T2 |
Creates an asynchronous workflow that will be resumed when the first of the specified two observables produces a value. The workflow will return a Choice value that can be used to identify the observable that produced the value. |
AwaitObservable(ev1, ev2, ev3)
Signature: (ev1:IObservable<'T1> * ev2:IObservable<'T2> * ev3:IObservable<'T3>) -> Async<Choice<'T1,'T2,'T3>>
Type parameters: 'T1, 'T2, 'T3 |
Creates an asynchronous workflow that will be resumed when the first of the specified three observables produces a value. The workflow will return a Choice value that can be used to identify the observable that produced the value. |
AwaitObservable(ev1, ev2, ev3, ev4)
Signature: (ev1:IObservable<'T1> * ev2:IObservable<'T2> * ev3:IObservable<'T3> * ev4:IObservable<'T4>) -> Async<Choice<'T1,'T2,'T3,'T4>>
Type parameters: 'T1, 'T2, 'T3, 'T4 |
Creates an asynchronous workflow that will be resumed when the first of the specified four observables produces a value. The workflow will return a Choice value that can be used to identify the observable that produced the value. |
GuardedAwaitObservable(...)
Signature: ev1:IObservable<'T1> -> (guardFunction:(unit -> unit)) -> Async<'T1>
Type parameters: 'T1 |
Behaves like AwaitObservable, but calls the specified guarding function after a subscriber is registered with the observable. |
popFront()
Signature: unit -> 'T
|
|
pushBack(x)
Signature: x:'T -> unit
|
|
