sig
  module Line :
    sig
      type t = Biocaml_line.t
      val to_string : t -> string
      val string_to_lines : string -> t list * bool
      val of_string_unsafe : string -> t
      val lstrip : ?drop:(char -> bool) -> t -> t
      val rstrip : ?drop:(char -> bool) -> t -> t
      val strip : ?drop:(char -> bool) -> t -> t
      val split : t -> on:char -> string list
      val for_all : string -> f:(char -> bool) -> bool
      val t_of_sexp : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
    end
  module Pos :
    sig
      type t =
        Biocaml_pos.t = {
        source : string option;
        line : int option;
        offset : int option;
      }
      val make : ?source:string -> ?line:int -> ?offset:int -> unit -> t
      val unknown : t
      val incr_line : ?n:int -> t -> t
      val to_string : t -> string
      val t_of_sexp : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
    end
  module Stream :
    sig
      type 'a t = 'a Stream.t
      val to_stream : 'a t -> 'a Stream.t
      val of_stream : 'a Stream.t -> 'a t
      exception Failure
      exception Error of string
      exception Expected_streams_of_equal_length
      exception Premature_end_of_input
      val next : 'a t -> 'a option
      val next_exn : 'a t -> 'a
      val peek : 'a t -> 'a option
      val npeek : 'a t -> int -> 'a list
      val junk : 'a t -> unit
      val count : 'a t -> int
      val is_empty : 'a t -> bool
      val from : (int -> 'a option) -> 'a t
      val of_channel : in_channel -> char t
      val strings_of_channel : ?buffer_size:int -> in_channel -> string t
      val range : ?until:int -> int -> int t
      val empty : unit -> 'a t
      val init : int -> f:(int -> 'a) -> 'a t
      val singleton : 'a -> 'a t
      val unfold : 'a -> f:('a -> ('b * 'a) option) -> 'b t
      val unfoldi : 'a -> f:(int -> 'a -> ('b * 'a) option) -> 'b t
      val of_lazy : 'a t lazy_t -> 'a t
      val iter : 'a t -> f:('a -> unit) -> unit
      val iter2 : 'a t -> 'b t -> f:('a -> 'b -> unit) -> unit
      val iter2_exn : 'a t -> 'b t -> f:('a -> 'b -> unit) -> unit
      val fold : 'a t -> init:'b -> f:('b -> 'a -> 'b) -> 'b
      val fold2 : 'a t -> 'b t -> init:'c -> f:('c -> 'a -> 'b -> 'c) -> 'c
      val fold2_exn :
        'a t -> 'b t -> init:'c -> f:('c -> 'a -> 'b -> 'c) -> 'c
      val scanl : 'a t -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
      val scan : 'a t -> f:('a -> 'a -> 'a) -> 'a t
      val iteri : 'a t -> f:(int -> 'a -> unit) -> unit
      val iter2i_exn :
        'a t -> 'b t -> f:(int -> int -> 'a -> 'b -> unit) -> unit
      val iter2i : 'a t -> 'b t -> f:(int -> int -> 'a -> 'b -> unit) -> unit
      val foldi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b) -> 'b
      val fold2i_exn :
        'a t ->
        'b t -> init:'c -> f:(int -> int -> 'c -> 'a -> 'b -> 'c) -> 'c
      val fold2i :
        'a t ->
        'b t -> init:'c -> f:(int -> int -> 'c -> 'a -> 'b -> 'c) -> 'c
      val reduce : 'a t -> f:('a -> 'a -> 'a) -> 'a
      val sum : int t -> int
      val fsum : float t -> float
      val exists : 'a t -> f:('a -> bool) -> bool
      val for_all : 'a t -> f:('a -> bool) -> bool
      val find : 'a t -> f:('a -> bool) -> 'a option
      val find_exn : 'a t -> f:('a -> bool) -> 'a
      val find_map : 'a t -> f:('a -> 'b option) -> 'b option
      val take : 'a t -> n:int -> 'a t
      val take_while : 'a t -> f:('a -> bool) -> 'a t
      val drop : 'a t -> n:int -> unit
      val drop_while : 'a t -> f:('a -> bool) -> unit
      val skip : 'a t -> n:int -> 'a t
      val skip_while : 'a t -> f:('a -> bool) -> 'a t
      val take_whilei : 'a t -> f:(int -> 'a -> bool) -> 'a t
      val drop_whilei : 'a t -> f:(int -> 'a -> bool) -> unit
      val skip_whilei : 'a t -> f:(int -> 'a -> bool) -> 'a t
      val span : 'a t -> f:('a -> bool) -> 'a t * 'a t
      val group : 'a t -> f:('a -> 'b) -> 'a t t
      val group_by : 'a t -> eq:('a -> 'a -> bool) -> 'a t t
      val chunk2 : 'a t -> ('a * 'a) t
      val chunk3 : 'a t -> ('a * 'a * 'a) t
      val chunk4 : 'a t -> ('a * 'a * 'a * 'a) t
      val map : 'a t -> f:('a -> 'b) -> 'b t
      val mapi : 'a t -> f:(int -> 'a -> 'b) -> 'b t
      val map2_exn : 'a t -> 'b t -> f:('a -> 'b -> 'c) -> 'c t
      val mapi2_exn : 'a t -> 'b t -> f:(int -> 'a -> 'b -> 'c) -> 'c t
      val filter : 'a t -> f:('a -> bool) -> 'a t
      val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
      val append : 'a t -> 'a t -> 'a t
      val concat : 'a t t -> 'a t
      val concat_map : 'a t -> f:('a -> 'b t) -> 'b t
      val combine : 'a t * 'b t -> ('a * 'b) t
      val uncombine : ('a * 'b) t -> 'a t * 'b t
      val merge : 'a t -> 'a t -> cmp:('a -> 'a -> int) -> 'a t
      val partition : 'a t -> f:('a -> bool) -> 'a t * 'a t
      val uniq : 'a t -> 'a t
      val of_list : 'a list -> 'a t
      val to_list : 'a t -> 'a list
      val of_array : 'a array -> 'a t
      val to_array : 'a t -> 'a array
      val of_hashtbl : ('a, 'b) Core_kernel.Std.Hashtbl.t -> ('a * 'b) t
      val to_hashtbl : ('a * 'b) t -> ('a, 'b) Core_kernel.Std.Hashtbl.t
      val of_map : ('a, 'b, 'c) Core_kernel.Std.Map.t -> ('a * 'b) t
      val to_map : ('a * 'b) t -> ('a, 'b) Core_kernel.Std.Map.Poly.t
      val of_set : ('a, 'b) Core_kernel.Std.Set.t -> 'a t
      val to_set : 'a t -> 'a Core_kernel.Std.Set.Poly.t
      val of_string : string -> char t
      val result_to_exn :
        ('output, 'error) Core_kernel.Std.Result.t t ->
        error_to_exn:('error -> exn) -> 'output t
      module Result :
        sig
          type ('a, 'e) t = ('a, 'e) Core_kernel.Std.Result.t Stream.t
          val all :
            ('a, 'e) t ->
            f:('a Stream.t -> ('b, 'e) Core_kernel.Std.Result.t) ->
            ('b, 'e) Core_kernel.Std.Result.t
          val all' :
            ('a, 'e) t ->
            f:('a Stream.t -> 'b) -> ('b, 'e) Core_kernel.Std.Result.t
          val to_exn : ('a, 'e) t -> error_to_exn:('e -> exn) -> 'a Stream.t
          val map :
            ('a, 'e) t ->
            f:('a -> ('b, 'e) Core_kernel.Std.Result.t) -> ('b, 'e) t
          val map' : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
          val map2_exn :
            ('a, 'e) t ->
            ('b, 'e) t ->
            f:('a -> 'b -> ('c, 'e) Core_kernel.Std.Result.t) -> ('c, 'e) t
          val map2_exn' :
            ('a, 'e) t -> ('b, 'e) t -> f:('a -> 'b -> 'c) -> ('c, 'e) t
          val fold :
            ('a, 'e) t ->
            init:'b ->
            f:('b -> 'a -> ('b, 'e) Core_kernel.Std.Result.t) ->
            ('b, 'e) Core_kernel.Std.Result.t
          val fold' :
            ('a, 'e) t ->
            init:'b ->
            f:('b -> 'a -> 'b) -> ('b, 'e) Core_kernel.Std.Result.t
        end
      module Or_error :
        sig
          type 'a t = 'a Core_kernel.Std.Or_error.t Stream.t
          val all :
            'a t ->
            f:('a Stream.t -> 'b Core_kernel.Std.Or_error.t) ->
            'b Core_kernel.Std.Or_error.t
          val all' :
            'a t -> f:('a Stream.t -> 'b) -> 'b Core_kernel.Std.Or_error.t
          val to_exn :
            'a t ->
            error_to_exn:(Core_kernel.Std.Error.t -> exn) -> 'a Stream.t
          val map : 'a t -> f:('a -> 'b Core_kernel.Std.Or_error.t) -> 'b t
          val map' : 'a t -> f:('a -> 'b) -> 'b t
          val map2_exn :
            'a t ->
            'b t -> f:('a -> 'b -> 'c Core_kernel.Std.Or_error.t) -> 'c t
          val map2_exn' : 'a t -> 'b t -> f:('a -> 'b -> 'c) -> 'c t
          val fold :
            'a t ->
            init:'b ->
            f:('b -> 'a -> 'b Core_kernel.Std.Or_error.t) ->
            'b Core_kernel.Std.Or_error.t
          val fold' :
            'a t ->
            init:'b -> f:('b -> 'a -> 'b) -> 'b Core_kernel.Std.Or_error.t
        end
      module Infix :
        sig
          val ( -- ) : int -> int -> int t
          val ( --^ ) : int -> int -> int t
          val ( --. ) : float * float -> float -> float t
          val ( --- ) : int -> int -> int t
          val ( /@ ) : 'a t -> ('a -> 'b) -> 'b t
          val ( // ) : 'a t -> ('a -> bool) -> 'a t
          val ( //@ ) : 'a t -> ('a -> 'b option) -> 'b t
        end
    end
  val ( |? ) : 'a option -> 'a -> 'a
  module Array :
    sig
      type 'a t = 'a array
      val typerep_of_t :
        'a Typerep_lib.Std.Typerep.t -> 'a t Typerep_lib.Std.Typerep.t
      val typename_of_t :
        'a Typerep_lib.Std.Typename.t -> 'a t Typerep_lib.Std.Typename.t
      val binary_search :
        ?pos:int ->
        ?len:int ->
        'a t ->
        compare:('a -> 'a -> int) ->
        [ `First_equal_to
        | `First_greater_than_or_equal_to
        | `First_strictly_greater_than
        | `Last_equal_to
        | `Last_less_than_or_equal_to
        | `Last_strictly_less_than ] -> 'a -> int option
      val binary_search_segmented :
        ?pos:int ->
        ?len:int ->
        'a t ->
        segment_of:('a -> [ `Left | `Right ]) ->
        [ `First_on_right | `Last_on_left ] -> int option
      val mem : ?equal:('a -> 'a -> bool) -> 'a t -> 'a -> bool
      val length : 'a t -> int
      val is_empty : 'a t -> bool
      val iter : 'a t -> f:('a -> unit) -> unit
      val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
      val exists : 'a t -> f:('a -> bool) -> bool
      val for_all : 'a t -> f:('a -> bool) -> bool
      val count : 'a t -> f:('a -> bool) -> int
      val sum :
        (module Core_kernel.Commutative_group.S with type t = 'sum) ->
        'a t -> f:('a -> 'sum) -> 'sum
      val find : 'a t -> f:('a -> bool) -> 'a option
      val find_map : 'a t -> f:('a -> 'b option) -> 'b option
      val to_list : 'a t -> 'a list
      val to_array : 'a t -> 'a array
      val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
      val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
      val max_length : int
      external get : 'a t -> int -> 'a = "%array_safe_get"
      external set : 'a t -> int -> 'a -> unit = "%array_safe_set"
      external unsafe_get : 'a t -> int -> 'a = "%array_unsafe_get"
      external unsafe_set : 'a t -> int -> 'a -> unit = "%array_unsafe_set"
      val create : len:int -> 'a -> 'a t
      val init : int -> f:(int -> 'a) -> 'a t
      val make_matrix : dimx:int -> dimy:int -> 'a -> 'a t t
      val append : 'a t -> 'a t -> 'a t
      val concat : 'a t list -> 'a t
      val copy : 'a t -> 'a t
      val fill : 'a t -> pos:int -> len:int -> 'a -> unit
      val blit : ('a t, 'a t) Core_kernel.Blit_intf.blit
      val blito : ('a t, 'a t) Core_kernel.Blit_intf.blito
      val unsafe_blit : ('a t, 'a t) Core_kernel.Blit_intf.blit
      val sub : ('a t, 'a t) Core_kernel.Blit_intf.sub
      val subo : ('a t, 'a t) Core_kernel.Blit_intf.subo
      module Int :
        sig
          type t = int t
          val blit : (t, t) Core_kernel.Blit_intf.blit
          val blito : (t, t) Core_kernel.Blit_intf.blito
          val sub : (t, t) Core_kernel.Blit_intf.sub
          val subo : (t, t) Core_kernel.Blit_intf.subo
          external unsafe_blit :
            src:t -> src_pos:int -> dst:t -> dst_pos:int -> len:int -> unit
            = "core_array_unsafe_int_blit" "noalloc"
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val compare : t -> t -> int
          val bin_t : t Bin_prot.Type_class.t
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_writer_t : t Bin_prot.Type_class.writer
        end
      module Float :
        sig
          type t = float t
          val blit : (t, t) Core_kernel.Blit_intf.blit
          val blito : (t, t) Core_kernel.Blit_intf.blito
          val sub : (t, t) Core_kernel.Blit_intf.sub
          val subo : (t, t) Core_kernel.Blit_intf.subo
          external unsafe_blit :
            src:t -> src_pos:int -> dst:t -> dst_pos:int -> len:int -> unit
            = "core_array_unsafe_float_blit" "noalloc"
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val compare : t -> t -> int
          val bin_t : t Bin_prot.Type_class.t
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_writer_t : t Bin_prot.Type_class.writer
        end
      val of_list : 'a list -> 'a t
      val map : f:('a -> 'b) -> 'a t -> 'b t
      val iteri : f:(int -> 'a -> unit) -> 'a t -> unit
      val mapi : f:(int -> 'a -> 'b) -> 'a t -> 'b t
      val foldi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b) -> 'b
      val fold_right : 'a t -> f:('a -> 'b -> 'b) -> init:'b -> 'b
      val sort :
        ?pos:int -> ?len:int -> 'a t -> cmp:('a -> 'a -> int) -> unit
      val stable_sort : 'a t -> cmp:('a -> 'a -> int) -> unit
      val is_sorted : 'a t -> cmp:('a -> 'a -> int) -> bool
      val is_sorted_strictly : 'a t -> cmp:('a -> 'a -> int) -> bool
      val concat_map : 'a t -> f:('a -> 'b array) -> 'b array
      val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
      val partitioni_tf : 'a t -> f:(int -> 'a -> bool) -> 'a t * 'a t
      val cartesian_product : 'a t -> 'b t -> ('a * 'b) t
      val normalize : 'a t -> int -> int
      val slice : 'a t -> int -> int -> 'a t
      val nget : 'a t -> int -> 'a
      val nset : 'a t -> int -> 'a -> unit
      val filter_opt : 'a option t -> 'a t
      val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
      val filter_mapi : 'a t -> f:(int -> 'a -> 'b option) -> 'b t
      val iter2_exn : 'a t -> 'b t -> f:('a -> 'b -> unit) -> unit
      val map2_exn : 'a t -> 'b t -> f:('a -> 'b -> 'c) -> 'c t
      val fold2_exn :
        'a t -> 'b t -> init:'c -> f:('c -> 'a -> 'b -> 'c) -> 'c
      val for_all2_exn : 'a t -> 'b t -> f:('a -> 'b -> bool) -> bool
      val filter : f:('a -> bool) -> 'a t -> 'a t
      val filteri : f:(int -> 'a -> bool) -> 'a t -> 'a t
      val swap : 'a t -> int -> int -> unit
      val rev_inplace : 'a t -> unit
      val of_list_rev : 'a list -> 'a t
      val of_list_map : 'a list -> f:('a -> 'b) -> 'b t
      val of_list_rev_map : 'a list -> f:('a -> 'b) -> 'b t
      val replace : 'a t -> int -> f:('a -> 'a) -> unit
      val replace_all : 'a t -> f:('a -> 'a) -> unit
      val find_exn : 'a t -> f:('a -> bool) -> 'a
      val findi : 'a t -> f:(int -> 'a -> bool) -> (int * 'a) option
      val findi_exn : 'a t -> f:(int -> 'a -> bool) -> int * 'a
      val find_consecutive_duplicate :
        'a t -> equal:('a -> 'a -> bool) -> ('a * 'a) option
      val reduce : 'a t -> f:('a -> 'a -> 'a) -> 'a option
      val reduce_exn : 'a t -> f:('a -> 'a -> 'a) -> 'a
      val permute :
        ?random_state:Core_kernel.Core_random.State.t -> 'a t -> unit
      val combine : 'a t -> 'b t -> ('a * 'b) t
      val split : ('a * 'b) t -> 'a t * 'b t
      val sorted_copy : 'a t -> cmp:('a -> 'a -> int) -> 'a t
      val last : 'a t -> 'a
      val empty : unit -> 'a t
      val equal : 'a t -> 'a t -> equal:('a -> 'a -> bool) -> bool
      val truncate : 'a t -> len:int -> unit
      module Infix : sig val ( <|> ) : 'a t -> int * int -> 'a t end
      val to_sequence : 'a t -> 'a Core_kernel.Sequence.t
      val to_sequence_mutable : 'a t -> 'a Core_kernel.Sequence.t
      val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
      val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
      val bin_t : 'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
      val bin_read_t : 'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
      val __bin_read_t__ :
        'a Bin_prot.Read.reader -> (int -> 'a t) Bin_prot.Read.reader
      val bin_reader_t :
        'a Bin_prot.Type_class.reader -> 'a t Bin_prot.Type_class.reader
      val bin_size_t : 'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
      val bin_write_t :
        'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
      val bin_writer_t :
        'a Bin_prot.Type_class.writer -> 'a t Bin_prot.Type_class.writer
      val range : 'a t -> int Biocaml_internal_utils.Stream.t
    end
  module Result :
    sig
      type ('ok, 'err) t =
        ('ok, 'err) Core_kernel.Result.t =
          Ok of 'ok
        | Error of 'err
      val ( >>= ) : ('a, 'd) t -> ('a -> ('b, 'd) t) -> ('b, 'd) t
      val ( >>| ) : ('a, 'd) t -> ('a -> 'b) -> ('b, 'd) t
      module Monad_infix :
        sig
          val ( >>= ) : ('a, 'd) t -> ('a -> ('b, 'd) t) -> ('b, 'd) t
          val ( >>| ) : ('a, 'd) t -> ('a -> 'b) -> ('b, 'd) t
        end
      val bind : ('a, 'd) t -> ('a -> ('b, 'd) t) -> ('b, 'd) t
      val return : 'a -> ('a, 'b) t
      val join : (('a, 'd) t, 'd) t -> ('a, 'd) t
      val ignore : ('a, '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 -> ('a, 'err) t
      val failf : ('a, unit, string, ('b, string) t) format4 -> 'a
      val is_ok : ('a, 'b) t -> bool
      val is_error : ('a, 'b) t -> bool
      val ok : ('ok, 'a) t -> 'ok option
      val error : ('a, 'err) t -> 'err option
      val of_option : 'ok option -> error:'err -> ('ok, 'err) t
      val iter : ('ok, 'a) t -> f:('ok -> unit) -> unit
      val iter_error : ('a, '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 ]
      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
      val ok_or_failwith : ('ok, string) t -> 'ok
      val ok_unit : (unit, 'a) t
      module Export :
        sig
          type ('ok, 'err) _result =
            ('ok, 'err) t =
              Ok of 'ok
            | Error of 'err
          val is_ok : ('a, 'b) t -> bool
          val is_error : ('a, 'b) t -> bool
        end
      module Stable :
        sig
          module V1 :
            sig
              type ('ok, 'err) t = ('ok, 'err) t = Ok of 'ok | Error of 'err
              val compare :
                ('ok -> 'ok -> int) ->
                ('err -> 'err -> int) ->
                ('ok, 'err) t -> ('ok, 'err) t -> int
              val bin_t :
                'ok Bin_prot.Type_class.t ->
                'err Bin_prot.Type_class.t ->
                ('ok, 'err) t Bin_prot.Type_class.t
              val bin_read_t :
                'ok Bin_prot.Read.reader ->
                'err Bin_prot.Read.reader ->
                ('ok, 'err) t Bin_prot.Read.reader
              val __bin_read_t__ :
                'ok Bin_prot.Read.reader ->
                'err Bin_prot.Read.reader ->
                (int -> ('ok, 'err) t) Bin_prot.Read.reader
              val bin_reader_t :
                'ok Bin_prot.Type_class.reader ->
                'err Bin_prot.Type_class.reader ->
                ('ok, 'err) t Bin_prot.Type_class.reader
              val bin_size_t :
                'ok Bin_prot.Size.sizer ->
                'err Bin_prot.Size.sizer -> ('ok, 'err) t Bin_prot.Size.sizer
              val bin_write_t :
                'ok Bin_prot.Write.writer ->
                'err Bin_prot.Write.writer ->
                ('ok, 'err) t Bin_prot.Write.writer
              val bin_writer_t :
                'ok Bin_prot.Type_class.writer ->
                'err Bin_prot.Type_class.writer ->
                ('ok, 'err) t Bin_prot.Type_class.writer
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'ok) ->
                (Sexplib.Sexp.t -> 'err) -> Sexplib.Sexp.t -> ('ok, 'err) t
              val sexp_of_t :
                ('ok -> Sexplib.Sexp.t) ->
                ('err -> Sexplib.Sexp.t) -> ('ok, 'err) t -> Sexplib.Sexp.t
            end
          module V1_stable_unit_test :
            sig
              type t = Core_kernel.Result.Stable.V1_stable_unit_test.t
              val equal : t -> t -> bool
              val tests : (t * string * string) list
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
            end
        end
      val compare :
        ('ok -> 'ok -> int) ->
        ('err -> 'err -> int) -> ('ok, 'err) t -> ('ok, 'err) t -> int
      val t_of_sexp :
        (Sexplib.Sexp.t -> 'ok) ->
        (Sexplib.Sexp.t -> 'err) -> Sexplib.Sexp.t -> ('ok, 'err) t
      val sexp_of_t :
        ('ok -> Sexplib.Sexp.t) ->
        ('err -> Sexplib.Sexp.t) -> ('ok, 'err) t -> Sexplib.Sexp.t
      val bin_t :
        'ok Bin_prot.Type_class.t ->
        'err Bin_prot.Type_class.t -> ('ok, 'err) t Bin_prot.Type_class.t
      val bin_read_t :
        'ok Bin_prot.Read.reader ->
        'err Bin_prot.Read.reader -> ('ok, 'err) t Bin_prot.Read.reader
      val __bin_read_t__ :
        'ok Bin_prot.Read.reader ->
        'err Bin_prot.Read.reader ->
        (int -> ('ok, 'err) t) Bin_prot.Read.reader
      val bin_reader_t :
        'ok Bin_prot.Type_class.reader ->
        'err Bin_prot.Type_class.reader ->
        ('ok, 'err) t Bin_prot.Type_class.reader
      val bin_size_t :
        'ok Bin_prot.Size.sizer ->
        'err Bin_prot.Size.sizer -> ('ok, 'err) t Bin_prot.Size.sizer
      val bin_write_t :
        'ok Bin_prot.Write.writer ->
        'err Bin_prot.Write.writer -> ('ok, 'err) t Bin_prot.Write.writer
      val bin_writer_t :
        'ok Bin_prot.Type_class.writer ->
        'err Bin_prot.Type_class.writer ->
        ('ok, 'err) t Bin_prot.Type_class.writer
      module List :
        sig
          val mapi :
            'a list -> f:(int -> 'a -> ('b, 'e) t) -> ('b list, 'e) t
          val map : 'a list -> f:('a -> ('b, 'err) t) -> ('b list, 'err) t
        end
    end
  val try_finally_exn : fend:('a -> unit) -> ('a -> 'b) -> 'a -> 'b
  val open_out_safe : string -> Pervasives.out_channel
  module Url :
    sig
      val escape : string -> string
      val unescape :
        string ->
        error:(string -> 'error) ->
        (string, 'error) Biocaml_internal_utils.Result.t
    end
  module Debug :
    sig
      val enable : string -> unit
      val disable : string -> unit
      val make : string -> ('a, unit, string, unit) Pervasives.format4 -> 'a
    end
  val compare_of_list :
    ?equal:('a -> 'a -> bool) -> 'a list -> 'a -> 'a -> int
end