## rename gFDomain to gDomain and sort all generated values on depth

The problem with left-to-right generation is not that elements of the domain might be infinite, but that no list may be generated at all, even though there are more finite values. Consider this example:

```
:: T = S T | Z
Start = hd [() \\ _ <- dom]
dom :: [T]
dom = gFDomain{|*|}
```

In case `dom`

would be generated with a first infinite element, this should result in `()`

. It however does not terminate, but goes into infinite recursion.

If you think about it the first element would be of infinite length. Then the length of the second should be infinity minus one, which does not makes any sense. The only sensible way to enumerate the domain is: `[Z, S Z, S (S Z), ...]`

.

`gDomain`

should be guaranteed to produce finite values, as long as more of them are available. Only for strange types, such as `:: I = I I`

, `gDomain`

will go into infinite recursion without producing further list elements.

There is an overhead for types for which sorting on depth is not required (e.g. types with finite domain), but I think we should accept the overhead instead of introducing two versions of `gDomain`

. The maximal depth of generated values will be quite low for finite domains.