Type | Description |
type Async |
A computation, which, when run, will eventually produce a value of the given type, or else
raise an exception. The value and/or exception is not returned to the caller immediately, but
is rather passed to a continuation or exception continuation.
Async computations are normally specified using the F# 'workflow' syntax for building computations.
Operationally, async computations typically run partly in the .NET Thread Pool via ThreadPool.QueueUserWorkItem,
and, when waiting for asynchronous I/O, they are suspended as thunks using ThreadPool.RegisterWaitForSingleObject,
waiting for the I/O completion.
Some primitive asynchronous computations necessarily end up executing blocking operations:
these should be run on a pool of threads specifically dedicated to resolving blocking conditions,
via UnblockedPrimitive. For example, FileOpen on Windows is, by design, a blocking operation.
However frequently it is important to code as if this is asynchronous. This can be done by running the
blocking operation via UnblockedPrimitive.
When run, async computations belong to an AsyncGroup. This can usually be specified when the async computation
is started. The only action on an AsyncGroup is to raise a cancellation condition for the AsyncGroup.
Async values check the cancellation condition for their AsyncGroup regularly, though synchronous computations
within an asynchronous computation will not automatically check this condition. This gives a user-level
cooperative cancellation protocol.
|
type AsyncGroup | |
type AsyncReplyChannel | |
type AsyncWorker | |
type Handler |
Fresh .NET-compatible events declared in F# are typically
values of type IHandlerEvent<'a>. These
hold event handlers of type Handler<'a>.
|
type IAsyncFuture |
A handle to an asynchronous computation. The Async.AsyncFuture member allows you to
spawn a computation and at a later point synchronize on its result.
Each IAsyncFuture object may consume an OS resource in the form of a WaitHandle.
|
type IDelegateEvent |
.NET events are revealed to F# code as instances of the type IDelegateEvent,
which is a subtype of the type [IEvent]. The delegate type parameter and
arguments are determined by the F# type checker based on information stored
for the .NET event.
F# code may also declare .NET events over any .NET delegate type.
For example, DelegateEvent<PaintEventHandler,PaintEventArgs>
can be used for an event whose callbacks are of type PaintEventHandler. The delegate
and argument types must match.
|
type IEvent |
First-class listening points (i.e. objects that permit you to register a 'callback'
activated when the event is triggered). See the module IEvent
for functions to create events, and the type IDelegateEvent
which extends this type.
|
type IHandlerEvent |
Any instance property that has type IHandlerEvent will be published as a standard
.NET event using standard .NET delegates and metadata, and will
be recognized as an event by any language that supports the
CLI Common Language Specification. The event will accept
handlers of type Handler*lt;'a>.
Note: an abbreviation for IDelegateEvent<Handler<'a>,'a> |
type IPrimitiveDelegateEvent |
F# gives special status to non-virtual instance member properties compatible with type IPrimitiveDelegateEvent,
generating approriate .NET metadata to make the member appear to other .NET languages as a
.NET event.
|
type lazy |
The type of delayed computations.
Use the values in the [[Lazy]] module to manipulate
values of this type, and the notation 'lazy expr' to create values
of this type.
Note: an abbreviation for Lazy<'a> |
type Lazy |
The type of delayed computations.
Use the values in the [[Lazy]] module to manipulate
values of this type, and the notation 'lazy expr' to create values
of this type.
|