是否有错误折叠的类型类？

Question

Let's say T is a type that is an instance of Foldable . If I need to perform a fold that can fail, I can use foldM with a function that returns a Maybe .

But, what if the fallibility of the fold is inherent to T itself? Is there a type class for this? In other words, is there a type class for types that can be folded, but where fold cannot be defined for all values?

Can this be generalized to other Monads (or other type constructors) other than Maybe ?

Update

I'm looking for something like this:

{-# LANGUAGE TypeFamilies #-}
class FoldableT t where
    type F t :: * -> *
    foldMap  :: Monoid m => (a -> m) -> t a -> F t m 

Then Foldable would just be a special case of FoldableT where F is Identity.

Answer 1

One possibility you may not have considered is to wrap the non-foldable type with something that is trivially foldable:

newtype Trivial a = Trivial a
    deriving (Functor)
instance Foldable Trivial where
    foldMap _ _ = mempty

Then you can derive Foldable on the whole type and it will make the non-foldable branch appear empty.