package mirage-flow-combinators

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Flow-related devices using lwt

mirage-flow-combinators
- Mirage_flow_combinators
  - Copy
    
    Clock
  - F
  - Proxy
    
    A
    
    B
    
    Clock
  - SHUTDOWNABLE

Legend:
Library
Module
Module type
Parameter
Class
Class type

This module define flow-related devices for MirageOS, using lwt for I/O.

Release v3.0.0

module type CONCRETE =
  Mirage_flow.S
    with type error = [ `Msg of string ]
     and type write_error = [ Mirage_flow.write_error | `Msg of string ]

CONCRETE expose the private row as `Msg str errors, using pp_error and pp_write_error.

module Concrete (S : Mirage_flow.S) : CONCRETE with type flow = S.flow

Functor to transform a flow signature using private rows for errors into concrete error types.

module type SHUTDOWNABLE = sig ... end

module Copy
  (Clock : Mirage_clock.MCLOCK)
  (A : Mirage_flow.S)
  (B : Mirage_flow.S) : 
  sig ... end

module Proxy
  (Clock : Mirage_clock.MCLOCK)
  (A : SHUTDOWNABLE)
  (B : SHUTDOWNABLE) : 
  sig ... end

module F : sig ... end

In-memory, function-based flows.

type t

The type for first-class flows.

include Mirage_flow.S with type flow = t

type error

val pp_error : error Fmt.t

type nonrec write_error = private [>

| Mirage_flow.write_error

]

val pp_write_error : write_error Fmt.t

type flow = t

val read : flow -> (Cstruct.t Mirage_flow.or_eof, error) Stdlib.result Lwt.t

val write : flow -> Cstruct.t -> (unit, write_error) Stdlib.result Lwt.t

val writev : flow -> Cstruct.t list -> (unit, write_error) Stdlib.result Lwt.t

val close : flow -> unit Lwt.t

val create : (module Mirage_flow.S with type flow = 'a) -> 'a -> string -> t

create (module M) t name is the flow representing t using the function defined in M.

val pp : t Fmt.t

pp is the pretty-printer for IO flows.

val forward : ?verbose:bool -> src:t -> dst:t -> unit -> unit Lwt.t

forward ?verbose ~src ~dst () forwards writes from src to dst. Block until either src or dst is closed. If verbose is set (by default it is not), show the full flow contents in the debug messages.

val proxy : ?verbose:bool -> t -> t -> unit Lwt.t

proxy ?verbose x y is the same as forward x y <*> forward y x. Block until both flows are closed. If verbose is set (by default it is not), show the full flow contents in the debug messages.

package mirage-flow-combinators

Flow-related devices using lwt