package batteries
Install
Dune Dependency
Authors
Maintainers
Sources
md5=d3d16ffc960e832a1c0e21b7123194e9
sha512=36c8561079aa9fefc864c2f03bd8ae20aa05987bb67e7a9beac3ab4f440dbf7d44f141c172b05fddb1a5b618fc55a27962bb45fc39bd7b3a15d56e0ed3ff3870
doc/batteries.unthreaded/BatResult/index.html
Module BatResult
Monadic results of computations that can raise exceptions
The type of a result. A result is either Ok x
carrying the normal return value x
or is Error e
carrying some indication of an error. The value associated with a bad result is usually an exception (exn
) that can be raised.
val ok : 'a -> ('a, 'b) t
ok v
is Ok v
.
val error : 'e -> ('a, 'e) t
error e
is Error e
.
val value : ('a, 'e) t -> default:'a -> 'a
value r ~default
is v
if r
is Ok v
and default
otherwise.
val default : 'a -> ('a, _) t -> 'a
default d r
evaluates to d
if r
is Error
else x
when r
is Ok x
.
val get_ok : ('a, 'e) t -> 'a
get_ok r
is v
if r
is Ok v
and
val get_error : ('a, 'e) t -> 'e
get_error r
is e
if r
is Error e
and
val get : ('a, exn) t -> 'a
get (Ok x)
returns x
, and get (Error e)
raises e
. This function is, in a way, the opposite of the catch
function
val catch : ('a -> 'e) -> 'a -> ('e, exn) t
Execute a function and catch any exception as a result. This function encapsulates code that could throw an exception and returns that exception as a value.
val catch2 : ('a -> 'b -> 'c) -> 'a -> 'b -> ('c, exn) t
As catch
but two parameters. This saves a closure construction
val catch3 : ('a -> 'b -> 'c -> 'd) -> 'a -> 'b -> 'c -> ('d, exn) t
As catch
but three parameters. This saves a closure construction
bind r f
is f v
if r
is Ok v
and r
if r
is Error _
.
map f r
is Ok (f v)
if r
is Ok v
and r
if r
is Error _
.
map_error f r
is Error (f e)
if r
is Error e
and r
if r
is Ok _
.
map_both f g (Ok x)
returns Ok (f x)
and map_both f g (Error e)
returns Error (g e)
.
val map_default : 'b -> ('a -> 'b) -> ('a, _) t -> 'b
map_default d f r
evaluates to d
if r
is Error
else f x
when r
is Ok x
val fold : ok:('a -> 'c) -> error:('e -> 'c) -> ('a, 'e) t -> 'c
fold ~ok ~error r
is ok v
if r
is Ok v
and error e
if r
is Error e
.
val iter : ('a -> unit) -> ('a, 'e) t -> unit
iter f r
is f v
if r
is Ok v
and ()
otherwise.
val iter_error : ('e -> unit) -> ('a, 'e) t -> unit
iter_error f r
is f e
if r
is Error e
and ()
otherwise.
Predicates and comparisons
val is_ok : ('a, 'e) t -> bool
is_ok (Ok _)
is true
, otherwise false
.
val is_error : ('a, 'e) t -> bool
is_error r
is true
iff r
is Error _
.
val is_bad : ('a, 'e) t -> bool
Same as is_error
.
val is_exn : exn -> ('a, exn) t -> bool
is_exn e1 r
is true
iff r
is Error e2
with e1=e2
equal ~ok ~error r0 r1
tests equality of r0
and r1
using ok
and error
to respectively compare values wrapped by Ok _
and Error _
.
compare ~ok ~error r0 r1
totally orders r0
and r1
using ok
and error
to respectively compare values wrapped by Ok _
and Error _
. Ok _
values are smaller than Error _
values.
Converting
val to_option : ('a, _) t -> 'a option
to_option r
is r
as an option, mapping Ok v
to Some v
and Error _
to None
.
val of_option : 'a option -> ('a, unit) t
Convert an option
to a result
val to_list : ('a, 'e) t -> 'a list
to_list r
is [v]
if r
is Ok v
and []
otherwise.
to_seq r
is r
as a sequence. Ok v
is the singleton sequence containing v
and Error _
is the empty sequence.
The Result Monad
This monad is very similar to the option monad, but instead of being None
when an error occurs, the first error in the sequence is preserved as the return value.
module Monad : sig ... end
Infix
module Infix : sig ... end
This infix module provides the operator (>>=)
val print :
('b BatInnerIO.output -> 'a -> unit) ->
'b BatInnerIO.output ->
('a, exn) t ->
unit
Print a result as Ok(x) or Error(exn)