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
> ([EMAIL PROTECTED]) 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)?
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe
