David Feuer

Document the design of All

2

It's not at all obvious to the casual reader why `All` is defined as it is, and in particular what `SListI` is really about. This should be explained.

Sometimes-false dependencies

3

Packages that define orphan instances don't always need all their dependencies to be built. For example, suppose package `compat` depends on package `plain` and just defines instances that appear in...

Document RelativeValidity

1

The explanation is pretty sparse, and there aren't any instances to get a sense of what this class is for. I have no idea what it means.

Add default wrapper

5

```haskell newtype DefaultJSON a = DefaultJSON a instance (Generic a, GToJSON Zero (Rep a), GToEncoding Zero (Rep a)) => ToJSON (DefaultJSON a) where toJSON (DefaultJSON a) = genericToJSON defaultOptions a...

Consider adding a version of `parseWith` with a more informative type

1

`parseWith` runs a parser and returns a `Result`. This `Result` will _always_ be either `Done` or `Fail`, but the type leaves open the possibility of `Partial`. This means that library...

Use array copying primop to append

6

Use `copyAddrToByteArray#` to append (strict) `ByteString`s. In the (admittedly relatively unusual) case where GHC can see that one or both of the arguments have known small length, it may implement...

Unboxable creation

4

Allow GHC to unbox the results of the general `ByteString` creation functions when it's so inclined.

append is a bit inefficient when bytestrings are short

14

`append` unconditionally uses FFI calls to `memcpy` for both bytestrings. If one or both of them are known at compile time to be very short, this is inefficient. I believe...

unsafeCreate isn't unsafe enough for append or times

2

`append` and `times` should be able to get away with `unsafeWithForeignPtr`, but they use `unsafeCreate`, which uses `withForeignPtr`.

Offer direct conversion between short and lazy bytestrings

5

Going through strict bytestrings is totally unnecessary and wasteful. Here's one direction. I don't know if it's as efficient as possible, but it's surely more efficient than performing an unnecessary...