package biocaml

You can search for identifiers within the package.

in-package search v0.2.0

The OCaml Bioinformatics Library

Install

Dune Dependency

biocaml.org Readme Edit opam file Versions (5)

Authors

Maintainers

B

biocaml@googlegroups.com

Sources

v0.10.0.tar.gz

md5=497e3f2f7128a6ca347d66848da38a3d

sha512=4a76ebbafda3bc944afaff40d69791dfe153a0638ef5d7e6e1bc962b7f991d9545cd0af2d7930b39f8b31dbf067d0603cfa03d9b7a49396ab1ae452df47fd1f3

doc/biocaml.unix/Biocaml_unix/Biocaml_result/index.html

Module `Biocaml_unix.Biocaml_result`

Extension of Core's Result. Internal use only.

include module type of Core_kernel.Result

type ('a, 'b) t = ('a, 'b) Base.Result.t =

| Ok of 'a
| Error of 'b

include Bin_prot.Binable.S2 with type ('a, 'b) t := ('a, 'b) t

val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t -> Bin_prot.Shape.t

val bin_size_t : ('a, 'b, ('a, 'b) t) Bin_prot.Size.sizer2

val bin_write_t : ('a, 'b, ('a, 'b) t) Bin_prot.Write.writer2

val bin_read_t : ('a, 'b, ('a, 'b) t) Bin_prot.Read.reader2

val __bin_read_t__ : ('a, 'b, int -> ('a, 'b) t) Bin_prot.Read.reader2

val bin_writer_t : ('a, 'b, ('a, 'b) t) Bin_prot.Type_class.S2.writer

val bin_reader_t : ('a, 'b, ('a, 'b) t) Bin_prot.Type_class.S2.reader

val bin_t : ('a, 'b, ('a, 'b) t) Bin_prot.Type_class.S2.t

include Ppx_sexp_conv_lib.Sexpable.S2 with type ('a, 'b) t := ('a, 'b) t

include module type of Base.Result with type ('a, 'b) t := ('a, 'b) t

include Base.Sexpable.S2 with type ('ok, 'err) t := ('ok, 'err) t

val t_of_sexp : 
  (Base.Sexp.t -> 'a) ->
  (Base.Sexp.t -> 'b) ->
  Base.Sexp.t ->
  ('a, 'b) t

val sexp_of_t : 
  ('a -> Base.Sexp.t) ->
  ('b -> Base.Sexp.t) ->
  ('a, 'b) t ->
  Base.Sexp.t

val compare : 
  ('ok -> 'ok -> int) ->
  ('err -> 'err -> int) ->
  ('ok, 'err) t ->
  ('ok, 'err) t ->
  int

val hash_fold_t : 
  (Base.Hash.state -> 'ok -> Base.Hash.state) ->
  (Base.Hash.state -> 'err -> Base.Hash.state) ->
  Base.Hash.state ->
  ('ok, 'err) t ->
  Base.Hash.state

include Base.Monad.S2 with type ('a, 'err) t := ('a, 'err) t

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

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

module Let_syntax = Base.Result.Let_syntax

module Monad_infix = Base.Result.Monad_infix

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

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

val join : (('a, 'e) t, 'e) t -> ('a, 'e) t

val ignore_m : (_, 'e) t -> (unit, 'e) t

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

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

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

deprecated [since 2018-02] Use [all_unit]

val ignore : (_, 'err) t -> (unit, 'err) t

val fail : 'err -> (_, 'err) t

val failf : ('a, unit, string, (_, string) t) 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 ok_exn : ('ok, exn) t -> 'ok

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

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

Returns Ok if both are Ok and Error otherwise.

val combine_errors : ('ok, 'err) t list -> ('ok list, 'err list) t

combine_errors ts returns Ok if every element in ts is Ok, else it returns Error with all the errors in ts.

This is similar to all from Monad.S2, with the difference that all only returns the first error.

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

combine_errors_unit returns Ok if every element in ts is Ok (), else it returns Error with all the errors in ts, like combine_errors.

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

ok_if_true returns Ok () if bool is true, and Error error if it is false.

val try_with : (unit -> 'a) -> ('a, exn) t

val ok_unit : (unit, _) t

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

module Export = Base.Result.Export

module Stable = Core_kernel.Result.Stable

module List : sig ... end