package bio_io

You can search for identifiers within the package.

in-package search v0.2.0

bio_io
- Bio_io
  - Btab
    
    In_channel
    
    Record
    
    Parsed
    
    Fields
    
    Direct
  - Btab_queries
    
    In_channel
    
    T
    
    Record
  - Cigar
  - Fasta
    
    In_channel
    
    Record
  - Fastq
    
    In_channel
    
    Record
  - Private
    
    In_channel
    
    Peekable_in_channel
  - Record_in_channel
    
    In_channel_input_record
    
    Make
    
    M
    
    S
  - Utils

Legend:
Library
Module
Module type
Parameter
Class
Class type

Alternate interface to Stdio.In_channel. The create and with_file functions don't have a binary option, so it is compatible with the Record_in_channel.Make functor.

include module type of Stdio.In_channel

type t = in_channel

include Base.Equal.S with type t := t

val equal : t Base.Equal.equal

val stdin : t

Channels are opened in binary mode iff binary is true. This only has an effect on Windows.

val close : t -> Base.unit

close t closes t, or does nothing if t is already closed, and may raise an exception.

val input : t -> buf:Base.bytes -> pos:Base.int -> len:Base.int -> Base.int

val really_input : 
  t ->
  buf:Base.bytes ->
  pos:Base.int ->
  len:Base.int ->
  Base.unit Base.option

val really_input_exn : 
  t ->
  buf:Base.bytes ->
  pos:Base.int ->
  len:Base.int ->
  Base.unit

Same as Pervasives.really_input, for backwards compatibility

val input_char : t -> Base.char Base.option

Read one character from the given input channel. Return None if there are no more characters to read.

val input_byte : t -> Base.int Base.option

Same as input_char, but return the 8-bit integer representing the character. Return None if an end of file was reached.

val input_binary_int : t -> Base.int Base.option

Read an integer encoded in binary format (4 bytes, big-endian) from the given input channel. See Pervasives.output_binary_int. Return None if an end of file was reached while reading the integer.

val unsafe_input_value : t -> _ Base.option

OCaml's built-in marshal format

val input_buffer : t -> Base.Buffer.t -> len:Base.int -> Base.unit Base.option

input_buffer t buf ~len reads at most len characters from the input channel t and stores them at the end of buffer buf. Return None if the channel contains fewer than len characters. In this case, the characters are still added to the buffer, so as to avoid loss of data.

val input_all : t -> Base.string

val input_line : ?fix_win_eol:Base.bool -> t -> Base.string Base.option

input_line ?fix_win_eol t reads a line from t and returns it, without the newline ("\n") character at the end, and, if fix_win_eol the trailing "\r\n" is dropped.

val input_line_exn : ?fix_win_eol:Base.bool -> t -> Base.string

val fold_lines : 
  ?fix_win_eol:Base.bool ->
  t ->
  init:'a ->
  f:('a -> Base.string -> 'a) ->
  'a

fold_lines ?fix_win_eol t ~init ~f folds over the lines read from t using input_line. Lines are provided to f in the order they are found in the file.

val input_lines : ?fix_win_eol:Base.bool -> t -> Base.string Base.list

Completely reads an input channel and returns the results as a list of strings. Each line in one string.

val iter_lines : 
  ?fix_win_eol:Base.bool ->
  t ->
  f:(Base.string -> Base.unit) ->
  Base.unit

iter_lines ?fix_win_eol t ~f applies f to each line read from t using input_line.

val seek : t -> Base.int64 -> Base.unit

This works only for regular files. On files of other kinds, the behavior is unspecified.

val pos : t -> Base.int64

val length : t -> Base.int64

Return the size (number of characters) of the regular file on which the given channel is opened. If the channel is opened on a file that is not a regular file, the result is meaningless. The returned size does not take into account the end-of-line translations that can be performed when reading from a channel opened in text mode.

val set_binary_mode : t -> Base.bool -> Base.unit

same as Pervasives.set_binary_mode_in, only applicable for Windows or Cygwin, no-op otherwise

val read_lines : ?fix_win_eol:Base.bool -> Base.string -> Base.string Base.list

read_lines filename reads the full contents of file and returns it as a list of lines, closing the file when it's done. It's the equivalent of with_file fname ~f:input_lines

val read_all : Base.string -> Base.string

read_all filename reads the full contents of file and returns it as a single string, closing the file when it's done. It's the equivalent of with_file fname ~f:input_all

val create : Base.string -> t

val with_file : Base.string -> f:(t -> 'a) -> 'a