Is it possible to define different behaviour for generic types depending on which typeclasses are implemented?

Question

There is actually an extra layer to what I'm trying to ask, but the wording is a bit awkward. Here's an example using the YesNo typeclass from "Learn You a Haskell".

class YesNo a where
    yesno :: a -> Bool

instance YesNo Bool where
    yesno = id

instance YesNo [a] where
    yesno lst = length lst > 0

Here, the generic type is [a]. Could this code be changed so that yesno uses different logic (e.g. returns False) when a implements YesNo?

Answer 1

The typical, and usually best, thing to do when you have a need for type classes to behave differently based on a contained element is to actually make a newtype wrapper and manually wrap the list up at the call site.

The newtype declarations would look like:

newtype AllOf a = AllOf { unAllOf :: [a] }

newtype AnyOf a = AnyOf { unAnyOf :: [a] }

And, unsurprisingly, the instances use all or any on the underlying list:

instance YesNo a => YesNo (AllOf a) where
    yesno = all yesno . unAllOf


instance YesNo a => YesNo (AnyOf a) where
    yesno = any yesno . unAnyOf

Then when you want to use the instance:

*Main> yesno (AllOf [True, True, False, True])
False
*Main> yesno (AnyOf [True, True, False, True])
True