Suppose I have a parametrized data type with more than one nullary (constant) data constructor, such as:
data Check a = Valid | Invalid | Unsure a
Sometimes I want to manipulate the non-constant constructors with a function that keeps the nullary constants fixed, and I hope to do it like
instance Functor Check where
fmap f (Unsure a) = Unsure (f a)
fmap f c = c
This fails to typecheck because in the declaration fmap f c = c, if f :: a -> b then c needs to be of both types Check a and Check b. Of course I could just write it out fully into
fmap f (Unsure a) = Unsure (f a)
fmap f Valid = Valid
fmap f Invalid = Invalid
which works but gets very unwieldy when there are many nullary constructors. Or, in some cases I could probably derive instances of Show and Read and use read (show c) to coerce c to the necessary type. But is there a more elegant way to approach this?
1
One thing you could do is change the definition of your datatype to factour out the Valid / Invalid part like so:
data Status = StatusValid | StatusInvalid
data Check a = Sure Status | Unsure a
You can then implement Functor without having to inspect the Status:
instance Functor Check where
fmap f (Unsure a) = Unsure (f a)
fmap _ (Sure s) = Sure s
If you are willing to use the PatternSynonyms extension (just stick {-# LANGUAGE PatternSynonyms #-} at the top of your file), you can even recover Valid / Invalid:
pattern Valid = Sure StatusValid
pattern Invalid = Sure StatusInvalid
You can use the DeriveFunctor extension and just write
data Check a = Valid | Invalid | Unsure a deriving Functor