Question

I’m translating several programs from Standard ML to Haskell for a class, and I’m confused about the way Haskell is parsing this pattern matching.

I have this data type:

data Term = A | B
          | F Term | G Term | H Term Term
          | Var String
           deriving (Show)

And this is part of the function I am defining:

unify :: [(Term, Term)] -> Bool
 -- argument represents a list of term equations,
 -- result indicates whether they have a solution
unify nil = True
unify ((A, A):eqns) = unify eqns
unify ((B, B):eqns) = unify eqns
unify ((F(t1), F(t2)):eqns) = unify((t1,t2):eqns)
unify ((G(t1), G(t2)):eqns) = unify((t1,t2):eqns)
unify ((H s1 t1, H s2 t2):eqns) = unify((s1,s2):(t1,t2):eqns)
unify ((Var v1, t):eqns) =
        (case t of 
              Var v2    -> if v1 == v2 then unify(eqns)
                           else unify(map (substEqn v1 t) eqns)
          _     -> unify(map (substEqn v1 t) eqns))
unify ((t, Var v):eqns) = unify(map (substEqn v t) eqns)
unify _ = False

ghci gives me this output when I import the module:

Warning: Pattern match(es) are overlapped
             In an equation for `unify':
                 unify ((A, A) : eqns) = ...
                 unify ((B, B) : eqns) = ...
                 unify ((F (t1), F (t2)) : eqns) = ...
                 unify ((G (t1), G (t2)) : eqns) = ...
                 ...

I certainly understand how pattern matching works, but I don’t understand why Haskell considers these four arguments identical. They are different data types, so shouldn’t they not be equivalent patterns? This worked in Standard ML, but something must be lost in translation. Thanks for the help!

Answer 1

I am not sure what nil is (in the first pattern), but I assume you have the empty list in mind. If that is the case, replacing it with [] will do the trick and your pattern matching problem goes away.