package mirage-flow-lwt

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Flow-related devices using lwt

mirage-flow-lwt
- Mirage_flow_lwt
  - Copy
  - F
  - Proxy

Legend:
Library
Module
Module type
Parameter
Class
Class type

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

Release v1.6.0

module type S =
  Mirage_flow.S with type 'a io = 'a Lwt.t and type buffer = Cstruct.t

module type ABSTRACT =
  Mirage_flow.ABSTRACT with type 'a io = 'a Lwt.t and type buffer = Cstruct.t

module type CONCRETE =
  Mirage_flow.CONCRETE with type 'a io = 'a Lwt.t and type buffer = Cstruct.t

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

module type SHUTDOWNABLE =
  Mirage_flow.SHUTDOWNABLE
    with type 'a io = 'a Lwt.t
     and type buffer = Cstruct.t

module Copy (Clock : Mirage_clock.MCLOCK) (A : S) (B : 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 S with type flow = t

type 'a io = 'a Lwt.t

type error

val pp_error : error Fmt.t

type write_error = private [>

| Mirage_flow.write_error

]

val pp_write_error : write_error Fmt.t

type buffer = Cstruct.t

type flow = t

val read : flow -> (buffer Mirage_flow.or_eof, error) Pervasives.result io

val write : flow -> buffer -> (unit, write_error) Pervasives.result io

val writev : flow -> buffer list -> (unit, write_error) Pervasives.result io

val close : flow -> unit io

val create : (module 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 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-lwt

Flow-related devices using lwt