let from_tags ?zip_level ?zlib_buffer_size
      (output_tags: tags) : (t, _) Result.t =
    let rec output_transform ?with_zip (output_tags : file_format) =
      let with_zip_result t =
        match with_zip with
        | Some z -> Biocaml_transform.compose_result_left t z
        | None -> t
      in
      let with_zip_no_error t =
        match with_zip with
        | Some z -> Biocaml_transform.compose t z
        | None -> t
      in
      let sam_item_to_file t = return (`sam_item_to_file (with_zip_result t) : t) in
      match output_tags with
      | `raw_zip (tags: file_format) ->
        output_transform
          ~with_zip:(Biocaml_zip.Transform.zip ?zlib_buffer_size
                       ~format:`raw ?level:zip_level ()) tags
      | `gzip (tags: file_format) ->
        output_transform
          ~with_zip:(Biocaml_zip.Transform.zip ?zlib_buffer_size
                       ~format:`gzip ?level:zip_level ()) tags
      | `bam ->
        sam_item_to_file (
          Biocaml_transform.compose_result_left
            (Biocaml_transform.on_output
               (Biocaml_bam.Transform.item_to_raw ())
               (function Ok o -> Ok o | Error e -> Error (`bam e)))
            (Biocaml_bam.Transform.raw_to_string ?gzip_level:zip_level
               ?zlib_buffer_size ()))
      | `sam ->
        sam_item_to_file (
          Biocaml_transform.compose_result_left
            (Biocaml_transform.on_output
               (Biocaml_sam.Transform.item_to_raw ())
               (function Ok o -> Ok o | Error e -> Error (`sam e)))
            (Biocaml_sam.Transform.raw_to_string ()))
      | `gff tag_list ->
        let t = Biocaml_gff.Transform.item_to_string ~tags:tag_list () in
        return (`gff_to_file (with_zip_no_error t) : t)
      | `wig tag_list ->
        let t = Biocaml_wig.Transform.item_to_string  ~tags:tag_list () in
        return (`wig_to_file (with_zip_no_error t) : t)
      | `bed ->
        let t = Biocaml_bed.Transform.item_to_string  () in
        return (`bed_to_file (with_zip_no_error t) : t)
      | `fastq ->
        let t = Biocaml_fastq.Transform.item_to_string () in
        return (`fastq_to_file (with_zip_no_error t) : t)
      | `fasta tags when Biocaml_fasta.Tags.is_char_sequence tags ->
        let t = Biocaml_fasta.Transform.char_seq_raw_item_to_string ~tags () in
        return (`char_fasta_to_file (with_zip_no_error t) : t)
      | `fasta tags (* must be int-sequence *) ->
        let t = Biocaml_fasta.Transform.int_seq_raw_item_to_string ~tags () in
        return (`int_fasta_to_file (with_zip_no_error t) : t)
      | `table tags ->
        let t =
          Biocaml_transform.compose
            (Biocaml_table.Row.Transform.item_to_line ~tags ())
            (Biocaml_lines.Transform.item_to_string ()) in
        return (`table_to_file (with_zip_no_error t) : t)
    in
    match output_tags with
    | `list [#file_format as left; #file_format as right ] ->
      (* We let `output_transform` try its best for any pair of file-formats *)
      output_transform left
      >>= fun left_tr ->
      output_transform right
      >>= fun right_tr ->
      begin match left_tr, right_tr with
      | `char_fasta_to_file t1, `int_fasta_to_file t2 ->
        let rec fasta_tags = function
        | `gzip t -> fasta_tags t
        | `raw_zip t -> fasta_tags t
        | `fasta t -> t
        | _ -> (* no way we got there through another path *) assert false in
        let lftags = fasta_tags left in
        let rftags = fasta_tags right in
        Biocaml_transform.(
          let tleft = (* Sequence Fasta-full-item → string, no possible error *)
            compose
              (Biocaml_fasta.Transform.char_seq_item_to_raw_item ~tags:lftags ())
              t1 in
          let tright = (* Qualities Fasta-full-item → string, no possible error *)
            compose
              (Biocaml_fasta.Transform.int_seq_item_to_raw_item ~tags:rftags ())
              t2 in
          let the_mix = (* Mix the 2 previous ones into one “parallel”. *)
            on_output (mix tleft tright)  (function
              | `both (a, b) -> (a, b)
              | `left a -> (a, "")
              | `right b -> ("", b)) in
          return (`fastq_to_two_files (
              on_error ~f:(fun e -> `fastq e)
                (compose_result_left (* Add (fastq → (fasta-seq, fasta-qual))
                                        in front of the “parallel” one. *)

                   (Biocaml_fastq.Transform.fastq_to_fasta_pair ())
                   the_mix)
            )))
      | _ ->
        fail (`not_implemented "list output_tags")
      end
    | `list (tags : tags list) -> fail (`not_implemented "list output_tags")
    | #file_format as file_output_tags -> output_transform file_output_tags