In particular, I would like to see concepts like `Indexed`

included into `base`

(and ditto `Biindexed`

for `Bifunctor`

).

Several commonly-used modules have functions specific to their data structures, such as `Map.mapWithKey`

and `Vector.imap`

, and there exists a disparate set of classes in `lens`

, `indexed-traversable`

, `keys`

, `mono-traversable-keys`

, but they are un-unified, which can be an impediment to their use. If brought into `base`

, their implementation and use could be made consistent for better integration (eg, the same reason for having Functor be a superclass of Bifunctor), instead of having a scattered set of unrelated modules.

I personally would like to see them implemented in the following manner:

```
type family Index (f :: * -> *) :: *
class Indexed f where
indexed :: f a -> f (Index f, a)
class (Indexed f, Functor f) => IndexedFunctor f where
imap :: (Index f -> a -> b) -> f a -> f b
class (Indexed f, Foldable f) => IndexedFoldable f where
ifoldMap :: (Monoid m) => (Index f -> a -> m) -> f a -> m
-- NOTE: Or just (Indexed t, Traversable t) => ...
class (IndexedFunctor t, IndexedFoldable t, Traversable t) => IndexedTraversable t where
itraverse :: (Applicative f) => (Index t -> a -> f b) -> t a -> f (t b)
```

I would also like to see the concepts from `recursion-schemes`

(and `Fix`

`Free`

and `Cofree`

) pulled into `base`

as well - I have less justification for this other than that recursion is a really important concept, and I am always annoyed when I remember that they aren’t already in base and so I am forever pulling them in.

*However*, I also see recursion as an accompaniment to the whole `Category, Monoid, Monad`

triplet, for reasons that take a bit more explaining so I’ll just gesticulate wildly at how deeply Turing-completeness and computational complexity are related to it in general, and wonder how it could possibly be missing from `base`

.

I’m biased, because I work with both of these a lot.

*Edited to add more context, and then a tad more.*