package middleware

You can search for identifiers within the package.

in-package search v0.2.0

middleware
- Middleware
  - Diverter
  - Infix
  - MONAD
  - MONAD2
  - Make
    
    Diverter
    
    Infix
    
    M
  - Make2
    
    Diverter
    
    Infix
    
    M
  - Monads
    
    Identity

Legend:
Library
Module
Module type
Parameter
Class
Class type

A "middleware" function is one which runs before, after, and possibly instead of another function.

Middleware can be composed, in order to create a chain of wrapping invocations.

Note that a middleware function can not be called on its own. It is required to be "terminated" by a conventional function.

module type MONAD = sig ... end

Minimal monad definition required by a Middleware.

module type MONAD2 = sig ... end

Monads of two type parameters.

module Monads : sig ... end

Some common monads.

module Make (M : MONAD) : sig ... end

Creates a Middleware module, providing effects with the given Monad.

module Make2 (M : MONAD2) : sig ... end

Creates a Middleware module, providing effects with the given two-parameter Monad.

Middleware backed by the identity monad.

include sig ... end

module Diverter : sig ... end

val stop : 'output Monads.Identity.t -> ('a, 'b, 'output) Diverter.t

stop x creates a Stop Diverter with the return value x.

val continue : 
  'next_input ->
  ('next_output -> 'output Monads.Identity.t) ->
  ('next_input, 'next_output, 'output) Diverter.t

continue next_input fn creates a Continue diverter, passing next_input to the subsequent Middleware g. fn is applied to the value returned by g.

type (!'input0, !'next_input0, !'next_output0, !'output0) t =
  'input ->
  ('next_input, 'next_output, 'output) Diverter.t

A function which composes with other Middleware functions. Composed Middleware can respond to the return value of Middleware running later. When a Middleware function f runs, it either:

Stops, and returns a result
Continues by allowing the next middleware function g to run
After g runs, control returns to f, where f can respond to g's result and change its own return value.

val terminate : 
  ('ai, 'bi, 'bo, 'ao) t ->
  ('bi -> 'bo Monads.Identity.t) ->
  'ai ->
  'ao Monads.Identity.t

terminate ma fb terminates Middleware ma by providing a function fb which does not delegate. In order to turn a Middleware chain into a function, it must be terminated by a non-delegating function using terminate.

val compose : 
  ('ai, 'bi, 'bo, 'ao) t ->
  ('bi, 'ci, 'co, 'bo) t ->
  ('ai, 'ci, 'co, 'ao) t

compose ma mb composes two Middleware functions. When run, ma first runs, giving mb the option to continue later on. Note that a composed Middleware still need to be terminated via terminate to be called.

module Infix : sig ... end