Given an AST describing a species, with a phantom type parameter
describing the species at the type level, and an underlying set,
generate a list of all possible structures built over the
underlying set; the type of the output list is a
function of the species structure. (Of course, it would be
really nice to have a real dependently-typed language for this!)

Unfortunately, SpeciesTypedAST cannot be made an instance of
Species, so if we want to be able to generate structures given
an expression of the Species DSL as input, we must take
SpeciesAST as input, which existentially wraps the phantom
structure type---but this means that the output list type must be
existentially quantified as well; see generate and
generateTyped below.

There is one caveat: since the type of the generated structures
is different for each species, it must be existentially
quantified! The output of generate can always be Shown, but
not much else.

However! All is not lost. It's possible, by the magic of
Data.Typeable, to yank the type information (kicking and
screaming) back into the open, so that you can then manipulate
the generated structures to your heart's content. To see how,
consult structureType and generateTyped.

generateTyped s ls generates a complete list of all s-structures
over the underlying set of labels ls, where the type of the
generated structures is known (structureType may be used to
compute this type). For example:

structureType s returns a String representation of the
functor type which represents the structure of the species s.
In particular, if structureType s prints "T", then you can
safely use generateTyped by writing