package bio_io

In_channel for FASTQ records.

For more general info, see the Record_in_channel module mli file. For more specific info, see the Fasta.In_channel module.

Note: Empty fastq files parse OK, but are empty.

Examples

These examples basically match those in the Fasta.In_channel module.

Return all records in a list

let records = Fastq.In_channel.with_file_records fname

Iterating over records

Use the iter functions when you need to go over each record and perform some side-effects with them.

Print sequence IDs and sequence lengths

let () =
  Fastq.In_channel.with_file_iter_records "sequences.fastq"
    ~f:(fun record ->
      let open Fastq.Record in
      printf "%s => %d\n" (id record) (seq_length record))

Print sequence index, IDs, and sequence lengths.

This is like the last example except that we also want to print the index. The first record is 0, the 2nd is 1, etc.

let () =
  Fastq.In_channel.with_file_iteri_records "sequences.fastq"
    ~f:(fun i record ->
      let open Fastq.Record in
      printf "%d: %s => %d\n" (i + 1) (id record) (seq_length record))

Folding over records

If you need to reduce all the records down to a single value, use the fold functions.

Get total length of all sequences in the file.

let total_length =
  Fastq.In_channel.with_file_fold_records "sequences.fastq" ~init:0
    ~f:(fun length record -> length + Fastq.Record.seq_length record)

Pipelines with records

Sometimes you have a "pipeline" of computations that you need to do one after the other on records. In that case, you could the sequence functions. Here's a silly example.

let () =
  Fastq.In_channel.with_file name ~f:(fun chan ->
      Fastq.In_channel.record_sequence chan
      (* Add sequence index to record description *)
      |> Sequence.mapi ~f:(fun i record ->
             let new_desc =
               match Fastq.Record.desc record with
               | None -> Some (sprintf "sequence %d" i)
               | Some old_desc ->
                   Some (sprintf "%s -- sequence %d" old_desc i)
             in
             Fastq.Record.with_desc new_desc record)
      (* Convert all sequence chars to lowercase *)
      |> Sequence.map ~f:(fun record ->
             let new_seq = String.lowercase (Fastq.Record.seq record) in
             Fastq.Record.with_seq new_seq record)
      (* Print sequences *)
      |> Sequence.iter ~f:(fun record ->
             print_endline @@ Fastq.Record.to_string record))

One thing to watch out for though...if you get an exception half way through and you are running side-effecting code like we are here then part of your side effects will have occured and part of them will not have occured.

As you can see, if that fastq file has more than one sequence it will hit the assert false and blow up.