[Haskell-cafe] Proposal: deriving ShallowEq?

[Ben Lippmeier]

Hello,

I often find it useful to determine whether two objects are using the 
same constructor, without worrying about the constructors' arguments.

An example, using some arbitrary data type "Thingo":

 > class ShallowEq a where
 >  shallowEq  :: a -> a -> Bool

 > data Thingo a b
 >	= TOne   a
 >	| TTwo   a b Int Char Float
 >	| TThree Int Char b b

 > (TOne 23) `shallowEq` TOne{}
True

 > (TThree 5 'c' True False)  `shallowEq` TTwo{}
False

--
Having some sort of generic shallowEq operator reduces the need for a 
host of predicates such as: (this one from Data.Maybe)

 > isJust x
 >  = case x of
 >	Just {}	-> True
 >	_	-> False

.. which is an approach that is obviously going to be tedious when the 
size of the data type becomes large.

--
There is way to hack together a partial implementation of the ShallowEq 
class within GHC, but it leaves much to be desired:

 > instance Show a => ShallowEq a where
 >  (=@=) a b
 >	= (head $ words $ show a) == (head $ words $ show b)

Notice that in the example the term "TTwo{}" is a partially constructed 
record. The implementation relies on laziniess to avoid trying to show 
the missing fields (which would fail).

--
Questions:
  1) Does anyone know a better/existing way to implement ShallowEq that 
doesn't involve enumerating all the constructors in the data type?

  2) If not, can anyone think of reasons why it wouldn't be a good idea 
for GHC to derive ShallowEq (by expanding said enumeration)?