A cancelable promise.
ℹ️ In addition to using a promise to concurrently compute and return a value, a cancelable promise can also represent a concurrent fiber that will continue until it is explicitly canceled.
⚠️ Canceling a promise does not immediately terminate the fiber or wait for the fiber working to complete the promise to terminate. Constructs like Bundle.join_after and Flock.join_after only guarantee that all fibers forked within their scope have terminated before they return or raise. The reason for this design choice in this library is that synchronization is expensive and delaying synchronization to the join operation is typically sufficient and amortizes the cost.
val of_value : 'a -> 'a tval await : 'a t -> 'aawait promise awaits until the promise has completed and either returns the value that the evaluation of the promise returned, raises the exception that the evaluation of the promise raised, or raises the Terminate exception in case the promise has been canceled.
⚠️ The fiber corresponding to a canceled promise is not guaranteed to have terminated at the point await raises.
val completed : 'a t -> 'a Picos_std_event.Event.tcompleted promise returns an event that can be committed to once the promise has completed.
val is_running : 'a t -> boolis_running promise determines whether the completion of the promise is still pending.
val try_terminate : ?callstack:int -> 'a t -> booltry_terminate promise tries to terminate the promise by canceling it with the Terminate exception and returns true in case of success and false in case the promise had already completed, i.e. either returned, raised, or canceled.
The optional callstack argument specifies the number of callstack entries to capture with the Terminate exception. The default is 0.
val terminate : ?callstack:int -> 'a t -> unitterminate promise is equivalent to try_terminate promise |> ignore.
val terminate_after : ?callstack:int -> 'a t -> seconds:float -> unit