package bio_io

You can search for identifiers within the package.

in-package search v0.2.0

package bio_io

bio_io
- Bio_io
  - Btab
    
    In_channel
    
    Record
    
    Fields
    
    Direct
  - Cigar
  - Fasta
    
    In_channel
    
    Record
  - Mmseqs
    
    In_channel
    
    Record
    
    Fields
    
    Direct
  - 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

include Record_in_channel.S with type record := Record.t

API

type t

val stdin : t

create_exn file_name opens an t on the standard input channel.

val create_exn : Base.string -> t

create_exn file_name opens an input channel on the file specified by file_name.

val create : Base.string -> t Base.Or_error.t

create file_name opens an input channel on the file specified by file_name.

val close_exn : t -> Base.unit

close_exn t Close the t. Raises if the call fails.

val close : t -> Base.unit Base.Or_error.t

close t is like close_exnt t except that it shouldn't raise.

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

with_file_exn file_name ~f executes ~f on the channel created from file_name and closes it afterwards.

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

with_file file_name ~f is like with_file_exn file_name ~f except that it shouldn't raise.

val equal : t -> t -> Base.bool

equal t1 t2 compares t1 and t2 for equality.

val input_record_exn : t -> Record.t Base.option

input_record_exn t returns Some record if there is a record to return. If there are no more records, None is returned. Exn is raised on bad input.

val input_record : t -> Record.t Base.option Base.Or_error.t

input_record t is like input_record_exn t except that it should not raise exceptions.

Folding over records

val fold_records_exn : t -> init:'a -> f:('a -> Record.t -> 'a) -> 'a

fold_records_exn t ~init ~f reduces all records from a t down to a single value of type 'a.

val fold_records : 
  t ->
  init:'a ->
  f:('a -> Record.t -> 'a) ->
  'a Base.Or_error.t

fold_records t ~init ~f is like fold_records_exn t ~init ~f except that it should not raise exceptions. Rather than deal with exceptions inside the reducing function, you must deal with them at the end when handling the return value.

val foldi_records_exn : 
  t ->
  init:'a ->
  f:(Base.int -> 'a -> Record.t -> 'a) ->
  'a

Like fold_records_exn t ~init ~f except that f is provided the 0-based record index as its first argument. See fold_records_exn.

val foldi_records : 
  t ->
  init:'a ->
  f:(Base.int -> 'a -> Record.t -> 'a) ->
  'a Base.Or_error.t

Like foldi_records_exn t ~init ~f except that it shouldn't raise. See foldi_records_exn.

Folding with file name

val with_file_fold_records_exn : 
  Base.string ->
  init:'a ->
  f:('a -> Record.t -> 'a) ->
  'a

with_file_fold_records_exn file_name ~init ~f is like fold_records_exn t ~init ~f except that it is passed a file name, and it manages t automatically. See with_file.

val with_file_fold_records : 
  Base.string ->
  init:'a ->
  f:('a -> Record.t -> 'a) ->
  'a Base.Or_error.t

with_file_fold_records file_name ~init ~f is like fold_records t ~init ~f except that it is passed a file name, and it manages t automatically. See with_file.

val with_file_foldi_records_exn : 
  Base.string ->
  init:'a ->
  f:(Base.int -> 'a -> Record.t -> 'a) ->
  'a

with_file_foldi_records_exn file_name ~init ~f is like foldi_records_exn t ~init ~f except that it is passed a file name, and it manages t automatically. See with_file.

val with_file_foldi_records : 
  Base.string ->
  init:'a ->
  f:(Base.int -> 'a -> Record.t -> 'a) ->
  'a Base.Or_error.t

with_file_foldi_records file_name ~init ~f is like fold'_records t ~init ~f except that it is passed a file name, and it manages t automatically. See with_file.

Iterating over records

The iter functions are like the fold functions except they do not take an init value and the f function returns unit insead of some other value 'a, and thus return unit rather than a value 'a.

They are mainly called for side effects.

val iter_records_exn : t -> f:(Record.t -> Base.unit) -> Base.unit

iter_records_exn t ~f calls f on each record in t. As f returns unit this is generally used for side effects.

val iter_records : t -> f:(Record.t -> Base.unit) -> Base.unit Base.Or_error.t

iter_records t ~f is like iter_records_exn t ~f except that it shouldn't raise.

val iteri_records_exn : t -> f:(Base.int -> Record.t -> Base.unit) -> Base.unit

iteri_records_exn t ~f is like iteri_records_exn t ~f except that f is passed in the 0-indexed record index as its first argument.

val iteri_records : 
  t ->
  f:(Base.int -> Record.t -> Base.unit) ->
  Base.unit Base.Or_error.t

iteri_records t ~f is like iteri_records_exn t ~f except that it shouldn't raise.

Iterating with file name

val with_file_iter_records_exn : 
  Base.string ->
  f:(Record.t -> Base.unit) ->
  Base.unit

with_file_iter_records_exn file_name ~init ~f is like iter_records_exn t ~init ~f except that it is passed a file name, and it manages t automatically. See with_file.

val with_file_iter_records : 
  Base.string ->
  f:(Record.t -> Base.unit) ->
  Base.unit Base.Or_error.t

with_file_iter_records file_name ~init ~f is like iter_records t ~init ~f except that it is passed a file name, and it manages t automatically. See with_file.

val with_file_iteri_records_exn : 
  Base.string ->
  f:(Base.int -> Record.t -> Base.unit) ->
  Base.unit

with_file_iteri_records_exn file_name ~init ~f is like iteri_records_exn t ~init ~f except that it is passed a file name, and it manages t automatically. See with_file.

val with_file_iteri_records : 
  Base.string ->
  f:(Base.int -> Record.t -> Base.unit) ->
  Base.unit Base.Or_error.t

with_file_iteri_records file_name ~init ~f is like iteri_records t ~init ~f except that it is passed a file name, and it manages t automatically. See with_file.

Getting records as a list

These functions return lists of recordss.

val records_exn : t -> Record.t Base.List.t

val records : t -> Record.t Base.List.t Base.Or_error.t

With file name

val with_file_records_exn : Base.string -> Record.t Base.List.t

val with_file_records : Base.string -> Record.t Base.List.t Base.Or_error.t

Getting records as a sequence

These are a bit different:

* There are no with_file versions as you would have to do some fiddly things to keep the channel open, making them not so nice to use.

* Each record that is yielded is wrapped in an Or_error.t. This is different from the iter, fold, and other non _exn functions in which case the entire result is wrapped in an Or_error.t, letting you ignore errors in the passed in ~f function and deal with failure once.

val record_sequence_exn : t -> Record.t Base.Sequence.t

record_sequence_exn t returns a Sequence.t of record. May raise exceptions.

val record_sequence : t -> Record.t Base.Or_error.t Base.Sequence.t

record_sequence t is like record_sequence_exn t except that instead of raising exceptions, each item of the sequence is a record Or_error.t rather than an "unwrapped" record. This could make things annoying to deal with. If you don't want exceptions, you could instead wrap your entire sequence processing pipeline in a call to with_file and handle the Or_error.t in that way. See the pipelines usage examples for more info.