package hack_parallel

  1. Overview
  2. Docs
package hack_parallel
Legend:
Library
Module
Module type
Parameter
Class
Class type

Result is often used to handle error messages.

type ('ok, 'err) t = ('ok, 'err) Stdlib.Pervasives.result =
  1. | Ok of 'ok
  2. | Error of 'err

'a is a function's expected return type, and 'b is often an error message string.

let ric_of_ticker = function
  | "IBM" -> Ok "IBM.N"
  | "MSFT" -> Ok "MSFT.OQ"
  | "AA" -> Ok "AA.N"
  | "CSCO" -> Ok "CSCO.OQ"
  | _ as ticker -> Error (sprintf "can't find ric of %s" ticker)

The return type of ric_of_ticker could be string option, but (string, string) Result.t gives more control over the error message.

include Hack_monad.S2 with type ('a, 'err) t := ('a, 'err) t
include Hack_monad.Infix2 with type ('a, 'err) t := ('a, 'err) t
val (>>=) : ('a, 'd) t -> ('a -> ('b, 'd) t) -> ('b, 'd) t
val (>>|) : ('a, 'd) t -> ('a -> 'b) -> ('b, 'd) t
module Monad_infix : Hack_monad.Infix2 with type ('a, 'd) t := ('a, 'd) t
val bind : ('a, 'd) t -> ('a -> ('b, 'd) t) -> ('b, 'd) t
val return : 'a -> ('a, _) t
val join : (('a, 'd) t, 'd) t -> ('a, 'd) t
val ignore : (_, 'd) t -> (unit, 'd) t
val all : ('a, 'd) t list -> ('a list, 'd) t
val all_ignore : (unit, 'd) t list -> (unit, 'd) t
val fail : 'err -> (_, 'err) t
val failf : ('a, unit, string, (_, string) t) Stdlib.format4 -> 'a

e.g. failf "Couldn't find bloogle %s" (Bloogle.to_string b)

val is_ok : (_, _) t -> bool
val is_error : (_, _) t -> bool
val ok : ('ok, _) t -> 'ok option
val error : (_, 'err) t -> 'err option
val of_option : 'ok option -> error:'err -> ('ok, 'err) t
val iter : ('ok, _) t -> f:('ok -> unit) -> unit
val iter_error : (_, 'err) t -> f:('err -> unit) -> unit
val map : ('ok, 'err) t -> f:('ok -> 'c) -> ('c, 'err) t
val map_error : ('ok, 'err) t -> f:('err -> 'c) -> ('ok, 'c) t
val combine : ('ok1, 'err) t -> ('ok2, 'err) t -> ok:('ok1 -> 'ok2 -> 'ok3) -> err:('err -> 'err -> 'err) -> ('ok3, 'err) t
val ok_fst : ('ok, 'err) t -> [ `Fst of 'ok | `Snd of 'err ]

ok_fst is useful with List.partition_map. Continuing the above example:

let rics, errors = List.partition_map ~f:Result.ok_fst
    (List.map ~f:ric_of_ticker ["AA"; "F"; "CSCO"; "AAPL"])
val ok_if_true : bool -> error:'err -> (unit, 'err) t
val try_with : (unit -> 'a) -> ('a, exn) t
val ok_exn : ('ok, exn) t -> 'ok

ok_exn t returns x if t = Ok x, and raises exn if t = Error exn

val ok_or_failwith : ('ok, string) t -> 'ok
val ok_unit : (unit, _) t

ok_unit = Ok (), used to avoid allocation as a performance hack

module Export : sig ... end
module Stable : sig ... end
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct