Portability | non-portable (GHC Extensions) |
---|---|

Stability | experimental |

Maintainer | Patrick Bahr <paba@diku.dk> |

Safe Haskell | Safe-Infered |

This module provides functionality to number the components of a functorial value with consecutive integers.

- newtype Numbered a = Numbered (Int, a)
- unNumbered :: Numbered a -> a
- number :: Traversable f => f a -> f (Numbered a)
- class (Functor t, Foldable t) => Traversable t

# Documentation

This type is used for numbering components of a functorial value.

unNumbered :: Numbered a -> aSource

number :: Traversable f => f a -> f (Numbered a)Source

This function numbers the components of the given functorial value with consecutive integers starting at 0.

class (Functor t, Foldable t) => Traversable t

Functors representing data structures that can be traversed from left to right.

Minimal complete definition: `traverse`

or `sequenceA`

.

Instances are similar to `Functor`

, e.g. given a data type

data Tree a = Empty | Leaf a | Node (Tree a) a (Tree a)

a suitable instance would be

instance Traversable Tree where traverse f Empty = pure Empty traverse f (Leaf x) = Leaf <$> f x traverse f (Node l k r) = Node <$> traverse f l <*> f k <*> traverse f r

This is suitable even for abstract types, as the laws for `<*>`

imply a form of associativity.

The superclass instances should satisfy the following:

- In the
`Functor`

instance,`fmap`

should be equivalent to traversal with the identity applicative functor (`fmapDefault`

). - In the
`Foldable`

instance,`foldMap`

should be equivalent to traversal with a constant applicative functor (`foldMapDefault`

).

Traversable [] | |

Traversable Maybe | |

Traversable Identity | |

Ix i => Traversable (Array i) | |

Traversable (Map k) | |

(Traversable f, Traversable g) => Traversable (Compose f g) | |

Traversable f => Traversable (:&: f a) | |

(Traversable f, Traversable g) => Traversable (:+: f g) | |

Traversable f => Traversable (Cxt h f) |