=head1 NAME

recs-tofasta

=head1 USAGE

    Help from: --help-basic:
    Usage: recs-tofasta <options> [files]
       Outputs a FASTA-formatted sequence for each record.
    
       By default the keys "id", "description", and "sequence" are used to build the
       FASTA format. These defaults match up with what recs-fromfasta produces. The
       special key name "NONE" may be used to indicate that no key should be used,
       disabling the defaults. Note that warnings may be generated if you specify
       NONE for --id without specifying --passthru.
    
    Arguments:
       --id|-i <keyspec>            Record field to use for the sequence id
       --description|-d <keyspec>   Record field to use for the sequence description
       --sequence|-s <keyspec>      Record field to use for the sequence itself
       --width|w <#>                Format sequence blocks to # characters wide
       --oneline                    Format sequences on a single long line
       --passthru                   Pass through nucleotides unformatted
       --filename-key|fk <keyspec>  Add a key with the source filename (if no
                                    filename is applicable will put NONE)
    
      Help Options:
          --help-all       Output all help for this script
          --help           This help screen
          --help-keys      Help on keygroups and keyspecs
          --help-keyspecs  Help on keyspecs, a way to index deeply and with regexes
    
    Examples:
      # Remove gaps from a fasta file
      recs-fromfasta seqs.fa | recs-xform '{{sequence}} =~ s/-//g' | recs-tofasta > seqs-nogaps.fa
    
    Help from: --help-keyspecs:
      KEY SPECS
       A key spec is short way of specifying a field with prefixes or regular
       expressions, it may also be nested into hashes and arrays. Use a '/' to nest
       into a hash and a '#NUM' to index into an array (i.e. #2)
    
       An example is in order, take a record like this:
    
         {"biz":["a","b","c"],"foo":{"bar 1":1},"zap":"blah1"}
         {"biz":["a","b","c"],"foo":{"bar 1":2},"zap":"blah2"}
         {"biz":["a","b","c"],"foo":{"bar 1":3},"zap":"blah3"}
    
       In this case a key spec of 'foo/bar 1' would have the values 1,2, and 3 in
       the respective records.
    
       Similarly, 'biz/#0' would have the value of 'a' for all 3 records
    
       You can also prefix key specs with '@' to engage the fuzzy matching logic
    
       Fuzzy matching works like this in order, first key to match wins
         1. Exact match ( eq )
         2. Prefix match ( m/^/ )
         3. Match anywehre in the key (m//)
    
       So, in the above example '@b/#2', the 'b' portion would expand to 'biz' and 2
       would be the index into the array, so all records would have the value of 'c'
    
       Simiarly, @f/b would have values 1, 2, and 3
    
       You can escape / with a \. For example, if you have a record:
       {"foo/bar":2}
    
       You can address that key with foo\/bar
    

=head1 SEE ALSO

L<App::RecordStream::Bio>

=cut

