Module Lwt_main

Contents

Instructions: Use this module in your project

In the IDE (CLion, Visual Studio Code, Xcode, etc.) you use for your DkSDK project:

  1. Add the following to your project's dependencies/CMakeLists.txt:

    Copy
    DkSDKProject_DeclareAvailable(lwt
    CONSTRAINT "= 5.6.1"
    FINDLIBS lwt lwt.unix)
DkSDKProject_MakeAvailable(lwt)

  2. Add the Findlib::lwt library to any desired targets in src/*/CMakeLists.txt:

    Copy
    target_link_libraries(YourPackage_YourLibraryName
     # ... existing libraries, if any ...
     Findlib::lwt)

  3. Click your IDE's Build button

Not using DkSDK?

FIRST, do one or all of the following:

  1. Run:

    Copy
    opam install lwt.5.6.1

  2. Edit your dune-project and add:

    Copy
    (package
  (name YourExistingPackage)
  (depends
  ; ... existing dependenices ...
  (lwt (>= 5.6.1))))

    Then run:

    Copy
    dune build *.opam # if this fails, run: dune build

  3. Edit your <package>.opam file and add:

    Copy
    depends: [
  # ... existing dependencies ...
  "lwt" {>= "5.6.1"}
]

    Then run:

    Copy
    opam install . --deps-only

FINALLY, add the lwt.unix library to any desired (library)and/or (executable) targets in your **/dune files:

Copy
(library
  (name YourLibrary)
  ; ... existing library options ...
  (libraries
    ; ... existing libraries ...
    lwt.unix))

(executable
  (name YourExecutable)
  ; ... existing executable options ...
  (libraries
    ; ... existing libraries ...
    lwt.unix))

This module controls the ``main-loop'' of Lwt.

valrun :'a Lwt.t -> 'a

Lwt_main.run p calls the Lwt scheduler, performing I/O until p resolves. Lwt_main.run p returns the value in p if p is fulfilled. If p is rejected with an exception instead, Lwt_main.run p raises that exception.

Every native and bytecode program that uses Lwt should call this function at its top level. It implements the Lwt main loop.

Example:

Copy 
let main () = Lwt_io.write_line Lwt_io.stdout "hello world"

let () = Lwt_main.run (main ())

Lwt_main.run is not available when targeting JavaScript, because the environment (such as Node.js or the browser's script engine) implements the I/O loop.

On Unix, calling Lwt_main.run installs a SIGCHLD handler, which is needed for the implementations of Lwt_unix.waitpid and Lwt_unix.wait4. As a result, programs that call Lwt_main.run and also use non-Lwt system calls need to handle those system calls failing with EINTR.

Nested calls to Lwt_main.run are not allowed. That is, do not call Lwt_main.run in a callback triggered by a promise that is resolved by an outer invocation of Lwt_main.run. If your program makes such a call, Lwt_main.run will raise Failure. This should be considered a logic error (i.e., code making such a call is inherently broken).

It is not safe to call Lwt_main.run in a function registered with Stdlib.at_exit, use Lwt_main.at_exit instead.

valyield : ``unit->``unitLwt.t

yield () is a pending promise that is fulfilled after Lwt finishes calling all currently ready callbacks, i.e. it is fulfilled on the next “tick.”

  • deprecated

    Since 5.5.0 yield is deprecated in favor of the more general Lwt.pause in order to avoid discrepancies in resolution (see below) and stay compatible with other execution environments such as js_of_ocaml.

    Currently, paused promises are resolved more frequently than yielded promises. The difference is unintended but existing applications could depend on it. Unifying the two pools of promises into one in the future would eliminate possible discrepancies and simplify the code.

valabandon_yielded_and_paused : ``unit-> unit

Causes promises created with Lwt.pause and Lwt_main.yield to remain forever pending.

yield is now deprecated in favor of the more general Lwt.pause. Once yield is phased out, this function will be deprecated as well.

This is meant for use with Lwt_unix.fork, as a way to “abandon” more promise chains that are pending in your process.

module type Hooks=sig...end

Hook sequences. Each module of this type is a set of hooks, to be run by Lwt at certain points during execution. See modules Enter_iter_hooks, Leave_iter_hooks, and Exit_hooks.

module Enter_iter_hooks:Hooks with type``'return_valuekind='return_value

Hooks, of type unit -> unit, that are called before each iteration of the Lwt main loop.

module Leave_iter_hooks:Hooks with type``'return_valuekind='return_value

Hooks, of type unit -> unit, that are called after each iteration of the Lwt main loop.

module Exit_hooks:Hooks with type``'return_valuekind='return_value Lwt.t

Promise-returning hooks, of type unit -> unit Lwt.t, that are called at process exit. Exceptions raised by these hooks are ignored.

valenter_iter_hooks : ``(``unit->unit)``Lwt_sequence.t
valleave_iter_hooks : ``(``unit->unit)``Lwt_sequence.t
valexit_hooks : ``(``unit->``unitLwt.t)`` Lwt_sequence.t
valat_exit : ``(``unit->``unitLwt.t)`` -> unit

Lwt_main.at_exit hook is the same as ignore (Lwt_main.Exit_hooks.add_first hook).

More from the DkSDK Book

    1. DkSDK
      1. Package capnp
      1. Package cmdliner
      1. Package fmt
      1. Package logs
      1. Package lwt
        1. ...
        1. Module Lwt_main
          1. Module Lwt_main.Enter_iter_hooks
          1. Module Lwt_main.Exit_hooks
          1. Module Lwt_main.Leave_iter_hooks
      1. Package mtime
      1. Package ocaml
      1. Package
      1. Package result
      1. Package stdint
Logo for Diskuv

Your safety, first.