Module Cf_gadget

module Cf_gadget: sig .. end

Monadic composition of complex stream processors. An experimental interface for constructing highly interactive functional systems in a single thread of control.

Overview

This module implements a marginally more general version of the Gadget system described in Chapter 30 of Magnus Carlsson's and Thomas Hallgren's joint Ph.D. thesis.

In the context of this module, a "gadget" is a monad that evaluates into a Cf_flow object, capable of alternately reading from a source of input values and writing to a sink of output values. The continuation monad is specialized over an abstract "process" monad type, and a scheduler handles the calls and jumps between multiple simultaneous processes communicating with one another over a very lightweight message passing abstraction called a "wire".

The abstract process monad is a kind of state-continuation monad for operations over the internal Cf_flow value. The operations it supports are lifted into the gadget monad, as are briefly sumamrized as follows:

start: launch a new process in the scheduler.
wire: create a new message wire.
put: send a message on a wire.
get: create a gate for receiving messages on a wire.
guard: receive a message from one of several gates.
load: load the current process state.
store: store a new value of the process state.
read: read a new value from the external input.
write: write a new value to the external output.

A wire is logically composed of a receiver and a transmitter, with weak mutual references between them. When either end of the wire is reclaimed by the memory allocator, the other end is automatically rendered into a null wire, i.e. receivers never get messages and transmitters put messages by discarding them.

A pair of classes are provided to represent the receiver and the transmitter on a wire. Objects of the rx class define a get method for creating a "gate" that can receive a message. Objects of the tx class define a put method for transmitting a message. Both objects can be constructed with a wire object, and a convenience operators are defined for creating a new wire and construction a pair of associated rx and tx objects.

Each process contains an encapsulated state, initialized to a value when the process is started. As a process receives and transmits messages, it can easily manipulate this encapsulated state. When a process has no more messages to receive or transmit, the scheduler reclaims its resources and the final state is discarded.

Any process may read from the internal input stream or write to the external output stream. Conventionally, it is often simpler to define a a reader process and a writer process to localize these effects.

Note: see Magnus Carlsson's and Thomas Hallgren's joint Ph.D. thesis for a complete dissertation on the nature of the system of concepts behind this module.

Types

type ('a, 'b, 'c) work_t

An functionally compositional unit of work in a gadget. It encapsulates the state-continuation monad for a work loop.

type ('a, 'b, 'c) gate_t

A gate for receiving messages in a process of type ('s, 'i, 'o) process_t using the guard function.

type ('a, 'b, 'c) wire_t

An object capable of delivering messages of type 'x from a sender to a a receiver in a ('s, 'i, 'o) work_t continuation.

type ('a, 'b, 'c, 'd) guard_t = (('a, 'b, 'c) gate_t, 'd) Cf_cmonad.t

A guard for receiving a message from one or more sources.

type ('a, 'b, 'c, 'd) t = (('a, 'b, 'c) work_t, 'd) Cf_cmonad.t

A continuation monad parameterized by process type.

Functions

val eval : ('a, 'b, 'c, unit) t -> 'a -> ('b, 'c) Cf_flow.t

Use eval y s to obtain a new flow by evaluating the gadget monad y with a state initializer of a.

val start : ('a, 'b, 'c, unit) t -> 'a -> ('d, 'b, 'c, unit) t

Bind the result of start y s to start a new process evaluating the gadget y with a state initializer s.

val guard : ('a, 'b, 'c, unit) guard_t -> ('a, 'b, 'c, unit) t

Use guard m to receive the next message guard by m.

val wire : ('a, 'b, 'c, ('d, 'b, 'c) wire_t) t

Bind wire to create a new wire object for sending messages of type 'x.

val null : ('a, 'b, 'c) wire_t

Use null to construct a rx object that produces gates that never receive any messages, and a tx object that discards every message transmitted without deliver it. This object can be useful for default arguments to some gadget functions.

val read : ('a, 'b, 'c, 'b) t

Bind read to get the next input value from the external stream.

val write : 'a -> ('b, 'c, 'a, unit) t

Bind the result of write obj to put the next output value into the external stream.

val load : ('a, 'b, 'c, 'a) t

Bind load to get the current state encapsulated in the process.

val store : 'a -> ('a, 'b, 'c, unit) t

Bind the result of store obj to store the state obj as the encapsulated state for the current monad.

val modify : ('a -> 'a) -> ('a, 'b, 'c, unit) t

Bind the result of modify f to apply f to the current encapsulated state of the process and store the resulting new state.

Classes

class type connector = object .. end

The class type of connector objects.

class [['a, 'b, 'c]] rx : ('a, 'b, 'c) wire_t -> object .. end

The class of receiver objects.

class [['a, 'b, 'c]] tx : ('a, 'b, 'c) wire_t -> object .. end

The class of transmitter objects.

Miscellaneous

type ('a, 'b, 'c) simplex_t = ('a, 'b, 'c) rx * ('a, 'b, 'c) tx

A convenience type combining the rx and tx objects of a wire.

val fsimplex : f:(('a, 'b, 'c) wire_t ->
          ('a, 'b, 'c) #rx * ('a, 'b, 'c) #tx) ->
       ('d, 'b, 'c, ('a, 'b, 'c) rx * ('a, 'b, 'c) tx)
       t

Use fsimplex ~f to construct a new wire and apply it to the constructor function f to pass along a new matching pair of rx and tx objects.

val simplex : ('a, 'b, 'c, ('d, 'b, 'c) rx * ('d, 'b, 'c) tx)
       t

Use simplex to construct a new maching pair of rx and tx objects.

type ('a, 'b, 'c, 'd) duplex_t = (('a, 'c, 'd) rx * ('b, 'c, 'd) tx) *
       (('b, 'c, 'd) rx * ('a, 'c, 'd) tx)

A convenience type combining two wires into a pair of rx and tx tuples, one tuple for each end of a duplex communication. Each tuple is composed of the rx and the tx objects to use on one end of the communication.

val duplex : ('a, 'b, 'c, ('d, 'e, 'b, 'c) duplex_t) t

Use duplex to construct a new duplex communication channel, composed of two wires each in opposite flowl.

val wrap : ('a, 'b, 'c) #rx ->
       ('d, 'b, 'c) #tx ->
       ('a, 'd) Cf_flow.t -> ('e, 'b, 'c, unit) t

Use wrap rx tx w to start a new process that wraps the flow w, so that it reads output from the flow (copying it to tx object) and writes input to the flow (copying it from the rx object).