1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
20: 
21: 
22: 
23: 
24: 
25: 
26: 
27: 
28: 
29: 
30: 
31: 
32: 
33: 
34: 
35: 
36: 
37: 
38: 
39: 
40: 
41: 
42: 
43: 
44: 
45: 
46: 
47: 
48: 
49: 
50: 
51: 
52: 
53: 
54: 
55: 

// ----------------------------------------------------------------------------
// F# async extensions (AsyncSeqObservable.fsx)
// (c) Tomas Petricek, 2011, Available under Apache 2.0 license.
// ----------------------------------------------------------------------------

// This example demonstrates how to convert IObservable<'T> to AsyncSeq<'T>

#r @"../../bin/v4.0/FSharpx.Extras.dll"

open FSharpx.Control
open System.Windows.Forms
open System.Threading

// Create simple winforms user interface with a button and multiline text box
let frm = new Form(Visible=true, TopMost=true, Width=440)
let btn = new Button(Left=10, Top=10, Width=150, Text="Async Operation")
let out = new TextBox(Left=10, Top=40, Width=400, Height=200, Multiline=true)
frm.Controls.Add(btn)
frm.Controls.Add(out)

// Prints message to the displayed text box
let wprint fmt = 
  Printf.kprintf (fun s -> out.Text <- out.Text + s) fmt


// The sample demonstrates two ways of converting IObservable<_> values to 
// asynchronous sequences. When using 'AsyncSeq.ofObservable', values that are
// emitted when the asynchronous sequence is blocked are discarded. When you 
// click on the 'Async Operation' button, the following workflow starts
// processing and drops all clicks until the body of the for loop completes
let discarding =
  async {
    for click in btn.Click |> AsyncSeq.ofObservable do
      wprint "Sleeping (and discarding clicks)...\r\n"
      do! Async.Sleep(1000)
      wprint "Done (listening again)\r\n" }

let ctsd = new CancellationTokenSource()
Async.Start(discarding, ctsd.Token)
ctsd.Cancel()


// When using 'AsyncSeq.ofObservableBuffered', the values emitted by the 
// observable while the asynchronous sequence is blocked are stored in a 
// buffer (and will be returned as next elements). 
let buffering =
  async {
    for click in btn.Click |> AsyncSeq.ofObservableBuffered do
      wprint "Sleeping (and buffering clicks)...\r\n"
      do! Async.Sleep(1000)
      wprint "Done (ready for next value)\r\n" }

let ctsb = new CancellationTokenSource()
Async.Start(buffering, ctsb.Token)
ctsb.Cancel()

namespace Microsoft.FSharp.Control

namespace System

namespace System.Windows

namespace System.Windows.Forms

namespace System.Threading

val frm : Form

Full name: AsyncSeqObservable.frm

Multiple items
type Form =
  inherit ContainerControl
  new : unit -> Form
  member AcceptButton : IButtonControl with get, set
  member Activate : unit -> unit
  member ActiveMdiChild : Form
  member AddOwnedForm : ownedForm:Form -> unit
  member AllowTransparency : bool with get, set
  member AutoScale : bool with get, set
  member AutoScaleBaseSize : Size with get, set
  member AutoScroll : bool with get, set
  member AutoSize : bool with get, set
  ...
  nested type ControlCollection

Full name: System.Windows.Forms.Form

--------------------
Form() : unit

val btn : Button

Full name: AsyncSeqObservable.btn

Multiple items
type Button =
  inherit ButtonBase
  new : unit -> Button
  member AutoSizeMode : AutoSizeMode with get, set
  member DialogResult : DialogResult with get, set
  member NotifyDefault : value:bool -> unit
  member PerformClick : unit -> unit
  member ToString : unit -> string
  event DoubleClick : EventHandler
  event MouseDoubleClick : MouseEventHandler

Full name: System.Windows.Forms.Button

--------------------
Button() : unit

val out : TextBox

Full name: AsyncSeqObservable.out

Multiple items
type TextBox =
  inherit TextBoxBase
  new : unit -> TextBox
  member AcceptsReturn : bool with get, set
  member AutoCompleteCustomSource : AutoCompleteStringCollection with get, set
  member AutoCompleteMode : AutoCompleteMode with get, set
  member AutoCompleteSource : AutoCompleteSource with get, set
  member CharacterCasing : CharacterCasing with get, set
  member Multiline : bool with get, set
  member PasswordChar : char with get, set
  member Paste : text:string -> unit
  member ScrollBars : ScrollBars with get, set
  ...

Full name: System.Windows.Forms.TextBox

--------------------
TextBox() : unit

property Control.Controls: Control.ControlCollection

Control.ControlCollection.Add(value: Control) : unit

val wprint : fmt:Printf.StringFormat<'a,unit> -> 'a

Full name: AsyncSeqObservable.wprint

val fmt : Printf.StringFormat<'a,unit>

module Printf

from Microsoft.FSharp.Core

val kprintf : continutation:(string -> 'Result) -> format:Printf.StringFormat<'T,'Result> -> 'T

Full name: Microsoft.FSharp.Core.Printf.kprintf

val s : string

property TextBox.Text: string

val discarding : Async<unit>

Full name: AsyncSeqObservable.discarding

val async : AsyncBuilder

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.async

val click : obj

event Control.Click: IEvent<System.EventHandler,System.EventArgs>

Multiple items
type Async
static member AsBeginEnd : computation:('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit)
static member AwaitEvent : event:IEvent<'Del,'T> * ?cancelAction:(unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate)
static member AwaitIAsyncResult : iar:IAsyncResult * ?millisecondsTimeout:int -> Async<bool>
static member AwaitTask : task:Task -> Async<unit>
static member AwaitTask : task:Task<'T> -> Async<'T>
static member AwaitWaitHandle : waitHandle:WaitHandle * ?millisecondsTimeout:int -> Async<bool>
static member CancelDefaultToken : unit -> unit
static member Catch : computation:Async<'T> -> Async<Choice<'T,exn>>
static member FromBeginEnd : beginAction:(AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
static member FromBeginEnd : arg:'Arg1 * beginAction:('Arg1 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
static member FromBeginEnd : arg1:'Arg1 * arg2:'Arg2 * beginAction:('Arg1 * 'Arg2 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
static member FromBeginEnd : arg1:'Arg1 * arg2:'Arg2 * arg3:'Arg3 * beginAction:('Arg1 * 'Arg2 * 'Arg3 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
static member FromContinuations : callback:(('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T>
static member Ignore : computation:Async<'T> -> Async<unit>
static member OnCancel : interruption:(unit -> unit) -> Async<IDisposable>
static member Parallel : computations:seq<Async<'T>> -> Async<'T []>
static member RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:CancellationToken -> 'T
static member Sleep : millisecondsDueTime:int -> Async<unit>
static member Start : computation:Async<unit> * ?cancellationToken:CancellationToken -> unit
static member StartAsTask : computation:Async<'T> * ?taskCreationOptions:TaskCreationOptions * ?cancellationToken:CancellationToken -> Task<'T>
static member StartChild : computation:Async<'T> * ?millisecondsTimeout:int -> Async<Async<'T>>
static member StartChildAsTask : computation:Async<'T> * ?taskCreationOptions:TaskCreationOptions -> Async<Task<'T>>
static member StartImmediate : computation:Async<unit> * ?cancellationToken:CancellationToken -> unit
static member StartWithContinuations : computation:Async<'T> * continuation:('T -> unit) * exceptionContinuation:(exn -> unit) * cancellationContinuation:(OperationCanceledException -> unit) * ?cancellationToken:CancellationToken -> unit
static member SwitchToContext : syncContext:SynchronizationContext -> Async<unit>
static member SwitchToNewThread : unit -> Async<unit>
static member SwitchToThreadPool : unit -> Async<unit>
static member TryCancelled : computation:Async<'T> * compensation:(OperationCanceledException -> unit) -> Async<'T>
static member CancellationToken : Async<CancellationToken>
static member DefaultCancellationToken : CancellationToken

Full name: Microsoft.FSharp.Control.Async

--------------------
type Async<'T>

Full name: Microsoft.FSharp.Control.Async<_>

static member Async.Sleep : millisecondsDueTime:int -> Async<unit>

val ctsd : CancellationTokenSource

Full name: AsyncSeqObservable.ctsd

Multiple items
type CancellationTokenSource =
  new : unit -> CancellationTokenSource
  member Cancel : unit -> unit + 1 overload
  member Dispose : unit -> unit
  member IsCancellationRequested : bool
  member Token : CancellationToken
  static member CreateLinkedTokenSource : [<ParamArray>] tokens:CancellationToken[] -> CancellationTokenSource + 1 overload

Full name: System.Threading.CancellationTokenSource

--------------------
CancellationTokenSource() : unit

static member Async.Start : computation:Async<unit> * ?cancellationToken:CancellationToken -> unit

property CancellationTokenSource.Token: CancellationToken

CancellationTokenSource.Cancel() : unit
CancellationTokenSource.Cancel(throwOnFirstException: bool) : unit

val buffering : Async<unit>

Full name: AsyncSeqObservable.buffering

val ctsb : CancellationTokenSource

Full name: AsyncSeqObservable.ctsb