after implementing the proposed changes in #33, records just don't look as nice...
this is what you get when you call show() on a DNARecord:
TypedFASTA.Record{LongSequence{DNAAlphabet{4}}}(<description>, <sequence>)
and that's assuming you're using BioSequences, cause otherwise it looks like this:
TypedFASTA.Record{BioSequences.LongSequence{BioSequences.DNAAlphabet{4}}}(<description>, <sequence>)
and that's not even the worst part... I removed the TypedFASTX. at the beginning from the summary method thing to make it smaller, which is a little hack-y, so it would actually look like this:
TypedFASTX.TypedFASTA.Record{BioSequences.LongSequence{BioSequences.DNAAlphabet{4}}}(<description>, <sequence>)
as you can see, this is very hard to look at...

before #33, it'd look like this:
DNARecord{NoQuality}(<description>, <sequence>)
cause records had a quality type parameter, as opposed to now, where we distinguish between typed FASTA and FASTQ records, which also seems to mess with how aliases are detected. see, DNARecord in the last example isn't a type, it's an alias of TypedRecord{LongDNA{4}}, so it replaces that in the summary method. but that shit gets complicated when we put the subtypes in their own submodules, cause then julia wont just replace the names with any aliases defined in the submodules.

proposed solution:

make the show method the supertype, and make sure that there are constructors that can construct subtype instances using that representation or something, so that it still makes sense. idk

we might be able to make it look like this for FASTA records:
DNARecord(<description>, <sequence>)
and like this for FASTQ records:
DNARecord(<description>, <sequence>, <quality>)
which both happen to be valid constructors since DNARecord is an alias for TypedRecord{LongDNA{4}}, and we define constructors in both concrete types that are based on the TypedRecord thing

julia> supertype(typeof(TypedFASTA.Record{LongDNA{4}}("ricky", "ACGT")))
DNARecord (alias for TypedRecord{BioSequences.LongSequence{BioSequences.DNAAlphabet{4}}})

This issue is used to trigger TagBot; feel free to unsubscribe.

If you haven't already, you should update your TagBot.yml to include issue comment triggers.
Please see this post on Discourse for instructions and more details.

If you'd like for me to do this for you, comment TagBot fix on this issue.
I'll open a PR within a few hours, please be patient!

The constructors are a complete mess at the moment (there are like 30 for TypedRecord), and a lot of it has to do with how the quality field of a TypedRecord can be either of type NoQuality or QualityScores. Consider making TypedRecord an abstract type, and differentiate between TypedRecords with and without qualities. The names of these types shouldn't be too long though, and they should be easy to create. There should still be type aliases like DNARecord such that it's as easy as possible to create records.

Here's an idea of how it might look:

using BioSequences

abstract type TypedRecord{T, Q <: AbstractQuality} end

struct TypedFASTARecord{T} <: TypedRecord{T, NoQuality}
    description::String
    sequence::T
end

struct TypedFASTQRecord{T} <: TypedRecord{T, QualityScores}
    description::String
    sequence::T
    quality::QualityScores
end

const DNARecord = TypedRecord{LongDNA{4}}

The constructors might end up looking just as ugly though, and readers and writers would require an overhaul as well.

Should there be constructors where you don't need to specify name/description of records?