package async_extended

You can search for identifiers within the package.

in-package search v0.2.0

async_extended
- Async_extended
  - Any_error
    
    Applicative_infix
  - Async_cbreak
  - Async_color_print
  - Async_heap
  - Async_mutex
  - Coalesced_throttle
  - Cpu_load
    
    Stats
  - Csv
  - Deferred_cache
  - Deferred_list
  - Delimited
  - Embedded_script
  - Enforcer
  - Extended_log
    
    Console
    
    Blocking
    
    Syslog
    
    Blocking
  - Fd_leak_check
  - File_updates
    
    Update
  - Find
  - Generator
  - Inotify
  - Interactive_edit
  - Keyed_sequencer
  - Ltl
    
    Make
    
    Assignment
    
    Expression
    
    Applicative_infix
    
    Field
    
    O
    
    State
    
    Variable
    
    State
  - Mailbox
    
    Filter
  - Pipe_iterator
  - Pipe_zipper
  - Priority_queue
  - Process
    
    Output
  - Reader_ext
  - Resource
    
    Let_syntax
    
    Let_syntax
    
    Open_on_rhs
    
    Memo
    
    Key
    
    Hash_queue
    
    Hash_set
    
    Provide_bin_io
    
    X
    
    Provide_of_sexp
    
    X
    
    Table
    
    Provide_bin_io
    
    Key
    
    Provide_of_sexp
    
    Key
    
    Monad_infix
    
    Raw
    
    Handle
  - Rpc_proxy
    
    Environment
  - Run_in_fork
  - Semaphore
  - Shell
  - Signal
  - Simple_tcp_proxy
  - Sound
  - Std
    
    Log
    
    Reader
  - Synccast
  - Udp
  - Validate_command
    
    S
  - Watcher

Legend:
Library
Module
Module type
Parameter
Class
Class type

type ('ok, 'err) t = ('ok, 'err) Async.Deferred.Result.t

A variant of Deferred.Result.t with "any error" semantics. When multiple deferred values that each may be an error are combined, the result may fail with any of the component errors, instead of deterministically choosing a particular one. This enables the result to become determined sooner: for example, Deferred.Or_error.all gives the "leftmost" error if any, so if only the last element of the list is an error, the result will still not be determined until every other element has become so. By contrast, Any_error.all ts may become determined with an error as soon as any element of ts becomes determined with an error.

Note that there is no monad interface, since in a monadic bind, whether or not later deferreds become errors may depend on the value of earlier ones, so "any-error" doesn't make sense in that context. However, the equivalence with Deferred.Result.t is exposed, so you can just use that monad interface where necessary.

include Core.Applicative.S2 with type ('ok, 'err) t := ('ok, 'err) t

val return : 'a -> ('a, 'b) t

val apply : ('a -> 'b, 'e) t -> ('a, 'e) t -> ('b, 'e) t

val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t

val map2 : ('a, 'e) t -> ('b, 'e) t -> f:('a -> 'b -> 'c) -> ('c, 'e) t

val map3 : 
  ('a, 'e) t ->
  ('b, 'e) t ->
  ('c, 'e) t ->
  f:('a -> 'b -> 'c -> 'd) ->
  ('d, 'e) t

val all : ('a, 'e) t list -> ('a list, 'e) t

val all_ignore : (unit, 'e) t list -> (unit, 'e) t

deprecated [since 2018-02] Use [all_unit]

val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t

module Applicative_infix : sig ... end

val (<*>) : ('a -> 'b, 'e) t -> ('a, 'e) t -> ('b, 'e) t

val (<*) : ('a, 'e) t -> (unit, 'e) t -> ('a, 'e) t

val (*>) : (unit, 'e) t -> ('a, 'e) t -> ('a, 'e) t

val all_unit : (unit, 'err) t list -> (unit, 'err) t