Fuseau_lwtSourceInteroperability between Fuseau and Lwt.
This combines Fuseau's fibers with the Lwt event loop (ie Lwt_engine) to deal with timers and file descriptors readiness. In essence, one can use fibers and structured concurrency from Fuseau alongside Lwt libraries and Lwt IO operations.
include module type of struct include Fuseau endThe unique name of a fiber
Atomic events.
See Event.select.
Basic channels
Exception with backtrace
Time measurement
Fibers.
Fiber-local storage.
Exception raised when trying to perform operations on the scheduler after it's been disposed of
Scheduler that runs fibers.
Resource pool.
A pool of buffers to reuse.
Put the current fiber to sleep for that many seconds.
Exception used for cancellation caused by timeout
Wait for the fiber to terminate, and return the result. If the fiber failed, this re-raises the exception.
This must be called from inside another fiber, which will be suspended if needed.
Like await but catches exceptions.
Cancel the current fiber after delay seconds, unless the fiber terminates first. The cancellation will use the Timeout exception.
ev_timeout duration is an event that resolves after duration seconds with a Error Timeout error
ev_deadline time is an event that resolves at monotonic time t with a Error Timeout error
let@ () = with_cancel_callback cb in <e> evaluates e in a scope in which, if the current fiber is cancelled, cb() is called. If e returns without the fiber being cancelled, this callback is removed.
Must be run from inside the scheduler's thread. Spawn a new computation. This fiber has an implicit parent, which is normally the currently running fiber (the one calling spawn). If the parent fails or is cancelled, the resulting fiber will also be cancelled (parent to child).
Spawn a task from anywhere, possibly from another thread. The task will run in a subsequent call to run_iteration in the scheduler's thread. Thread-safe, more costly than spawn. Runs under the root switch.
val spawn_as_child_of :
?name:string ->
?propagate_cancel_to_parent:bool ->
Scheduler.t ->
_ Fiber.t ->
(unit -> 'a) ->
'a Fiber.tSpawn a fiber in the given parent fiber's scope. See spawn for more details on the arguments
Must be run from inside a Scheduler.t's thread. Schedules a microtask that will run in this tick. Be careful not to create infinite sequences of micro tasks that starve the IO loop!
These microtasks do not handle effects and should try their best to not raise exceptions. Only use them for very short amount of work.
Not thread-safe.
yield () returns control to the scheduler and checks for cancellation. This must be called from a fiber.
This returns the scheduler on which the caller runs. It must be called from inside a fiber.
This is the loop that runs both fibers, and the IO event loop, in an interspersed way.
Here we have functions that are used to cross the boundary between the Fuseau world and the Lwt world.
Like Fuseau.await but on a Lwt promise.
val spawn_as_lwt :
?parent:_ Fiber.t ->
?name:string ->
?propagate_cancel_to_parent:bool ->
(unit -> 'a) ->
'a Lwt.tspawn_as_lwt f runs f() in the Fuseau+Lwt thread, and returns a Lwt future that resolves when the fiber does
spawn_from_anywhere scheduler f runs f() as a toplevel fiber in scheduler. It can be run from another thread.
ev_read fd buf i len is an event that, when ready, will ready at most len bytes from fd into buf[i.. i+len], and return how many bytes were read. It uses Lwt_engine to wait for fd's readiness.
ev_write fd buf i len is an event that, when ready, writes at most len bytes from buf into fd. It uses Lwt_engine to wait for fd's readiness.
Run main loop, using the current Lwt_engine.t.