package containers

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Futures for concurrency
1. Constructors
2. Basics
3. Combinators
4. Helpers
5. Event timer
6. Low level

package containers

containers
- CCArray
  - S
  - Sub
- CCBool
- CCError
  - MONAD
  - Traverse
    
    M
- CCFloat
- CCFormat
- CCFun
  - Monad
    
    X
- CCHash
- CCHashtbl
  - COUNTER
  - DEFAULT
  - Make
    
    X
  - MakeCounter
    
    X
  - MakeDefault
    
    X
  - S
- CCHeap
  - Make
    
    E
  - PARTIAL_ORD
  - S
- CCInt
- CCList
  - Assoc
  - Idx
  - MONAD
  - Ref
  - Set
  - Traverse
    
    M
  - Zipper
- CCMap
  - Make
    
    O
  - S
- CCOpt
- CCOrd
- CCPair
- CCPrint
  - MONAD_IO
  - MakeIO
    
    M
- CCRandom
- CCString
  - S
  - Split
  - Sub
- CCVector
containers.bigarray
- CCBigstring
containers.data
- CCBV
- CCCache
- CCDeque
- CCFQueue
- CCFlatHashtbl
  - HASHABLE
  - Make
    
    X
  - S
- CCMixtbl
- CCMultiMap
  - BIDIR
  - Make
    
    K
    
    V
  - MakeBidir
    
    L
    
    R
  - OrderedType
  - S
- CCMultiSet
  - Make
    
    O
  - S
- CCPersistentHashtbl
  - HashedType
  - Make
    
    H
  - S
- CCTrie
  - Make
    
    W
  - MakeArray
    
    X
  - MakeList
    
    X
  - ORDERED
  - S
  - String
  - WORD
containers.io
- CCIO
  - File
containers.iter
- CCKList
  - MONAD
  - Traverse
    
    M
- CCKTree
  - Dot
  - pset
containers.misc
- Containers_misc
containers.pervasives
- CCPervasives
  - Array
  - List
  - Random
  - String
containers.sexp
- CCSexp
  - Traverse
- CCSexpM
  - MONAD
  - MakeDecode
    
    M
- CCSexpStream
  - L
  - Lexer
  - ParseGen
  - Source
    
    Manual
containers.string
- Containers_string
containers.thread
- CCFuture
  - Infix
  - Timer
- CCLock

Legend:
Library
Module
Module type
Parameter
Class
Class type

Futures for concurrency

type 'a state =

| Done of 'a
| Waiting
| Failed of exn

type 'a t

A future value of type 'a

type 'a future = 'a t

Constructors

val return : 'a -> 'a t

Future that is already computed

val fail : exn -> 'a t

Future that fails immediately

val make : (unit -> 'a) -> 'a t

Create a future, representing a value that will be computed by the function. If the function raises, the future will fail.

val make1 : ('a -> 'b) -> 'a -> 'b t

val make2 : ('a -> 'b -> 'c) -> 'a -> 'b -> 'c t

Basics

val get : 'a t -> 'a

Blocking get: wait for the future to be evaluated, and get the value, or the exception that failed the future is returned.

raises e
if the exception failed with e

val state : 'a t -> 'a state

State of the future

val is_done : 'a t -> bool

Is the future evaluated (success/failure)?

Combinators

val on_success : 'a t -> ('a -> unit) -> unit

Attach a handler to be called upon success

val on_failure : _ t -> (exn -> unit) -> unit

Attach a handler to be called upon failure

val on_finish : 'a t -> ('a state -> unit) -> unit

Attach a handler to be called when the future is evaluated

val flat_map : ('a -> 'b t) -> 'a t -> 'b t

Monadic combination of futures

val and_then : 'a t -> (unit -> 'b t) -> 'b t

Wait for the first future to succeed, then launch the second

val sequence : 'a t list -> 'a list t

Future that waits for all previous sequences to terminate. If any future in the list fails, sequence l fails too.

val choose : 'a t list -> 'a t

Choose among those futures (the first to terminate). Behaves like the first future that terminates, by failing if the future fails

val map : ('a -> 'b) -> 'a t -> 'b t

Maps the value inside the future. The function doesn't run in its own task; if it can take time, use flat_map

Helpers

val read_chan : Pervasives.in_channel -> Bytes.t t

Read the whole channel

type subprocess_res = < errcode : int ; stdout : Bytes.t ; stderr : Bytes.t >

val spawn_process : ?stdin:string -> string -> subprocess_res t

Spawn a sub-process with the given command (and possibly input); returns a future containing (returncode, stdout, stderr)

val sleep : float -> unit t

Future that returns with success in the given amount of seconds. Blocks the thread! If you need to wait on many events, consider using Timer

Event timer

module Timer : sig ... end

module Infix : sig ... end

val (>>=) : 'a t -> ('a -> 'b t) -> 'b t

val (>>) : 'a t -> (unit -> 'b t) -> 'b t

val (>|=) : 'a t -> ('a -> 'b) -> 'b t

Low level

val stop_pool : unit -> unit

Stop the thread pool