These instances are pretty obvious, and no more or less trivial than the existing instances for Prelude types. I have found them to be useful.
instance Foldable ((,) a) where foldMap f (_, y) = f y foldr f z (_, y) = f y z foldl f z (_, y) = f z y foldr1 _ (_, y) = y foldl1 _ (_, y) = y
instance Traversable ((,) a) where traverse f (x, y) = (,) x <$> f y
In the spirit of the world's finest legislative bodies, I am attaching two unrelated amendments to this proposal. One amendment is to add a few additional explicit method implementations in the Foldable and Traversable instances for Prelude types. These might sometimes be slightly more efficient, and they better match the strictness and style of the existing explicit method implementations. For lists:
sequence = Control.Monad.sequence
For Maybe:
foldMap _ Nothing = mempty foldMap f (Just x) = f x
foldr1 _ Nothing = error "foldr1 of Nothing" foldr1 _ (Just x) = x
foldl1 _ Nothing = error "foldl1 of Nothing" foldl1 _ (Just x) = x
For arrays:
foldl f z = Prelude.foldl f z . elems foldr1 f = Prelude.foldr1 f . elems foldl1 f = Prelude.foldl1 f . elems
The other amendment is to fix the documentation for the functions fmapDefault and foldMapDefault in Data.Traversable. Contrary to what is stated, these cannot be used as methods in superclasses, since the superclasses must already exist before these functions can be defined. Instead, I have paraphrased what is stated in the documentation above: that the corresponding superclass methods should be equivalent to these. http://hackage.haskell.org/trac/ghc/ticket/3324 Discussion period: two weeks.