Replying to [ticket:10794#comment:104381 nomeata]:

`fold :: f -> [a] -> a where f :: a -> a -> a`

is certainly confusing, because in the first line

`f`

is used like a type, but in the second,`f`

is used like a value (or`a -> a -> a`

is used like a kindMaybe you meant

`fold :: f -> [a] -> a where f = a -> a -> a`

Good catch. I agree that your suggestion makes more sense and have changed the ticket accordingly.

Some type signatures could be simplified by separating certain elements, either because they are lengthy and can be expressed simpler, to better express intention, or because they are repetitive. A "WhereSignatures" extension would allow for type signatures like the following:

```
fold :: f -> [a] -> a
where f = a -> a -> a
-- expresses intention more clearly than:
fold :: (a -> a -> a) -> [a] -> a
union :: a -> a -> a
where a = Map.Map k v
-- much shorter/more readable than:
union :: Map.Map k v -> Map.Map k v -> Map.Map k v
```

Or maybe even:

```
fmap :: (a -> b) -> f a -> f b
where (Functor f)
-- arguably prettier than:
fmap :: (Functor f) => (a -> b) -> f a -> f b
```

This minor syntactic sugar is essentially equivalent to local "type" definitions, which provides an advantage of making the type's purpose more clear. This seems like a natural development on what the type checker can do.