sig
  module Read_result :
    sig
      type 'a t = [ `Eof | `Ok of 'a ]
      val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
      val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
      module Monad_infix :
        sig
          val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
        end
      val bind : 'a t -> ('a -> 'b t) -> 'b t
      val return : 'a -> 'a t
      val map : 'a t -> f:('a -> 'b) -> 'b t
      val join : 'a t t -> 'a t
      val ignore : 'a t -> unit t
      val all : 'a t list -> 'a list t
      val all_ignore : unit t list -> unit t
      val t_of_sexp :
        (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a Reader.Read_result.t
      val __t_of_sexp__ :
        (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a Reader.Read_result.t
      val sexp_of_t :
        ('a -> Sexplib.Sexp.t) -> 'a Reader.Read_result.t -> Sexplib.Sexp.t
      val bin_t :
        'a Core.Std.Bin_prot.Type_class.t ->
        'a Reader.Read_result.t Core.Std.Bin_prot.Type_class.t
      val bin_read_t :
        'a Core.Std.Bin_prot.Unsafe_read_c.reader ->
        'a Reader.Read_result.t Core.Std.Bin_prot.Read_ml.reader
      val bin_read_t_ :
        'a Core.Std.Bin_prot.Unsafe_read_c.reader ->
        'a Reader.Read_result.t Core.Std.Bin_prot.Unsafe_read_c.reader
      val bin_read_t__ :
        'a Core.Std.Bin_prot.Unsafe_read_c.reader ->
        (int -> 'a Reader.Read_result.t)
        Core.Std.Bin_prot.Unsafe_read_c.reader
      val bin_reader_t :
        'a Core.Std.Bin_prot.Type_class.reader ->
        'a Reader.Read_result.t Core.Std.Bin_prot.Type_class.reader
      val bin_size_t :
        'a Core.Std.Bin_prot.Size.sizer ->
        'a Reader.Read_result.t Core.Std.Bin_prot.Size.sizer
      val bin_write_t :
        'a Core.Std.Bin_prot.Unsafe_write_c.writer ->
        'a Reader.Read_result.t Core.Std.Bin_prot.Write_ml.writer
      val bin_write_t_ :
        'a Core.Std.Bin_prot.Unsafe_write_c.writer ->
        'a Reader.Read_result.t Core.Std.Bin_prot.Unsafe_write_c.writer
      val bin_writer_t :
        'a Core.Std.Bin_prot.Type_class.writer ->
        'a Reader.Read_result.t Core.Std.Bin_prot.Type_class.writer
    end
  module Id : Core.Std.Unique_id
  type t
  val invariant : t Core_kernel.Invariant_intf.inv
  val io_stats : Io_stats.t
  val last_read_time : Reader.t -> Core.Std.Time.t
  val stdin : Reader.t Core.Std.Lazy.t
  val open_file :
    ?close_on_exec:bool ->
    ?buf_len:int -> string -> Reader.t Import.Deferred.t
  val transfer :
    Reader.t -> string Import.Pipe.Writer.t -> unit Import.Deferred.t
  val pipe : Reader.t -> string Import.Pipe.Reader.t
  val create : ?buf_len:int -> Fd.t -> Reader.t
  val of_in_channel : Pervasives.in_channel -> Fd.Kind.t -> Reader.t
  val with_file :
    ?buf_len:int ->
    ?exclusive:bool ->
    string -> f:(Reader.t -> 'a Import.Deferred.t) -> 'a Import.Deferred.t
  val close : Reader.t -> unit Import.Deferred.t
  val close_finished : Reader.t -> unit Import.Deferred.t
  val is_closed : Reader.t -> bool
  val with_close :
    Reader.t -> f:(unit -> 'a Import.Deferred.t) -> 'a Import.Deferred.t
  val id : Reader.t -> Id.t
  val fd : Reader.t -> Fd.t
  val read :
    Reader.t ->
    ?pos:int ->
    ?len:int -> string -> int Reader.Read_result.t Import.Deferred.t
  type 'a read_one_chunk_at_a_time_until_eof_result =
      [ `Eof | `Eof_with_unconsumed_data of string | `Stopped of 'a ]
  val read_one_chunk_at_a_time_until_eof :
    Reader.t ->
    handle_chunk:(Core.Std.Bigstring.t ->
                  pos:int ->
                  len:int ->
                  [ `Consumed of int * [ `Need of int | `Need_unknown ]
                  | `Continue
                  | `Stop of 'a ] Import.Deferred.t) ->
    'a Reader.read_one_chunk_at_a_time_until_eof_result Import.Deferred.t
  val read_substring :
    Reader.t ->
    Core.Std.Substring.t -> int Reader.Read_result.t Import.Deferred.t
  val read_bigsubstring :
    Reader.t ->
    Core.Std.Bigsubstring.t -> int Reader.Read_result.t Import.Deferred.t
  val read_char : Reader.t -> char Reader.Read_result.t Import.Deferred.t
  val really_read :
    Reader.t ->
    ?pos:int -> ?len:int -> string -> [ `Eof of int | `Ok ] Import.Deferred.t
  val really_read_substring :
    Reader.t ->
    Core.Std.Substring.t -> [ `Eof of int | `Ok ] Import.Deferred.t
  val really_read_bigsubstring :
    Reader.t ->
    Core.Std.Bigsubstring.t -> [ `Eof of int | `Ok ] Import.Deferred.t
  val read_until :
    Reader.t ->
    [ `Char of char | `Pred of char -> bool ] ->
    keep_delim:bool ->
    [ `Eof | `Eof_without_delim of string | `Ok of string ] Import.Deferred.t
  val read_until_max :
    Reader.t ->
    [ `Char of char | `Pred of char -> bool ] ->
    keep_delim:bool ->
    max:int ->
    [ `Eof
    | `Eof_without_delim of string
    | `Max_exceeded of string
    | `Ok of string ] Import.Deferred.t
  val read_line : Reader.t -> string Reader.Read_result.t Import.Deferred.t
  val really_read_line :
    wait_time:Core.Std.Time.Span.t ->
    Reader.t -> string option Import.Deferred.t
  type 'a read = ?parse_pos:Core.Std.Sexp.Parse_pos.t -> 'a
  val read_sexp :
    (Reader.t -> Core.Std.Sexp.t Reader.Read_result.t Import.Deferred.t)
    Reader.read
  val read_sexps :
    (Reader.t -> Core.Std.Sexp.t Import.Pipe.Reader.t) Reader.read
  val read_bin_prot :
    ?max_len:int ->
    Reader.t ->
    'a Core.Std.Bin_prot.Type_class.reader ->
    'a Reader.Read_result.t Import.Deferred.t
  val read_marshal_raw :
    Reader.t -> string Reader.Read_result.t Import.Deferred.t
  val read_marshal : Reader.t -> 'a Reader.Read_result.t Import.Deferred.t
  val recv : Reader.t -> string Reader.Read_result.t Import.Deferred.t
  val read_all :
    Reader.t ->
    (Reader.t -> 'a Reader.Read_result.t Import.Deferred.t) ->
    'a Import.Pipe.Reader.t
  val lseek :
    Reader.t -> int64 -> mode:[< `End | `Set ] -> int64 Import.Deferred.t
  val lines : Reader.t -> string Import.Pipe.Reader.t
  val contents : Reader.t -> string Import.Deferred.t
  val file_contents : string -> string Import.Deferred.t
  val file_lines : string -> string list Import.Deferred.t
  val load_sexp :
    ?exclusive:bool ->
    string ->
    (Core.Std.Sexp.t -> 'a) -> 'a Core.Std.Or_error.t Import.Deferred.t
  val load_sexp_exn :
    ?exclusive:bool ->
    string -> (Core.Std.Sexp.t -> 'a) -> 'a Import.Deferred.t
  val load_sexps :
    ?exclusive:bool ->
    string ->
    (Core.Std.Sexp.t -> 'a) -> 'a list Core.Std.Or_error.t Import.Deferred.t
  val load_sexps_exn :
    ?exclusive:bool ->
    string -> (Core.Std.Sexp.t -> 'a) -> 'a list Import.Deferred.t
  val sexp_of_t : Reader.t -> Sexplib.Sexp.t
  val sexp_of_read_one_chunk_at_a_time_until_eof_result :
    ('a -> Sexplib.Sexp.t) ->
    'a Reader.read_one_chunk_at_a_time_until_eof_result -> Sexplib.Sexp.t
end