通过Data.Typeable.TypeRep进行模式匹配和大小写表达式的问题

Question

I am trying to pattern match on Data.Typeable.TypeRep in the following code:

import Data.Typeable (TypeRep, typeOf)

tyI = typeOf (1    :: Int)
tyD = typeOf (3.14 :: Double)
tyB = typeOf (True :: Bool)

func1 :: TypeRep -> Bool
func1 tyI = False
func1 tyD = False
func1 _ = True

func2 :: TypeRep -> Bool
func2 tr = case tr of
    tyI -> False
    tyD -> False
    _   -> True

func3 :: TypeRep -> Bool
func3 tr = if tr == tyI then False else
           if tr == tyD then False else
           True

... and I get these warnings on compilation:

[1 of 1] Compiling Main             ( /home/[..]/test.hs, interpreted )

/home/[..]/test.hs:8:1: Warning:
    Pattern match(es) are overlapped
    In an equation for ‘func1’:
        func1 tyD = ...
        func1 _ = ...

/home/[..]/test.hs:23:12: Warning:
    Pattern match(es) are overlapped
    In a case alternative:
        tyD -> ...
        _ -> ...
Ok, modules loaded: Main.

Also, I get the surprising results:

*Main> func1 tyI
False
*Main> func1 tyD
False
*Main> func1 tyB
False -- !!!

*Main> func2 tyI
False
*Main> func2 tyD
False
*Main> func2 tyB
False -- !!!

*Main> func3 tyI
False
*Main> func3 tyD
False
*Main> func3 tyB
True -- Ok!

So only the last function func3 seems to produce the expected results. What should I do to use the pattern matching (func1) and case (func2) functions to work properly over TypeReps?

Answer 1

The issue is that tyI and tyD are being considered as ordinary variables (as opposed to being compared to the global constants of the same name) in the pattern match. The code below is completely equivalent to yours.

func1 :: TypeRep -> Bool
func1 x = False
func1 y = False
func1 _ = True

func2 :: TypeRep -> Bool
func2 tr = case tr of
    x -> False
    y -> False
    _ -> True

As you've observed in func3 , the way to solve this is to make the comparison explicit. You could also do it with guards:

func4 :: TypeRep -> Bool
func4 tr | tr == tyI = False
         | tr == tyD = False
         | otherwise = True

---

In general, the only things permitted on the left hand side of the equals against which you can pattern match are constructors. The one exception is number literals, and you'll notice that using these in patterns incurs an Eq constraint on the function as a whole

even :: (Num a, Eq a) => a -> Bool
even 0 = True
even 1 = False
even n = even (n-2)

Similar exceptions to this rule are added if you add OverloadedLists and OverloadedStrings . The rule still holds for almost all cases.

Answer 2

The tyI here:

func1 :: TypeRep -> Bool
func1 tyI = False

has nothing to do with the tyI defined here:

tyI = typeOf (1    :: Int)

In fact, your definition of func1 could have been written:

func1 :: TypeRep -> Bool
func1 x = False

And the same holds for func2 - the variables tyI , tyB and tyD there are just pattern variable names and do not refer to your global bindings.

However, your use of tyI and tyD in func3 do refer to the global definitions, so that's why func3 tyB returns True.