了解Haskell类型类在类型声明中的使用

Question

When we have a function that compares two things using the == comparison operator we add something like Eq a => a... to the type declaration; but this doesn't always seem to be the case.

For example, given the following function:

tail' xs = if length xs == 0
          then []
          else drop 1 xs

We make use of the == comparison operator, so I assumed the correct type decalaration would be:

tail':: (Eq a) => [a] -> [a]

However, running :t tail' tells me that the correct type decalartion is:

tail':: [a] -> [a]

Why is this the case? Why isn't Eq required in the type declaration?

Answer 1

Eq a => t says that a must be an instance of Eq in the type t . A type being an instance of Eq means that == is defined for that type. But in your definition of tail' , you never use == on an a , not even by proxy. The actual use of == is in length xs == 0 . The type of length xs (and 0 ) is Int , and Int is already an instance of Eq , so we already know it has == defined. Since you never use == on an a , you don't need an Eq a constraint.

If, however, you had said xs == [] , which seems equivalent (both test whether a list is empty), you would have incurred an Eq a constraint. This is because == on [a] requires an Eq a constraint since it uses == on each list's entries to compare the lists. Since you can use length xs == 0 (or, even better, null xs ), though, this added constraint is spurious and should be avoided.

(As an aside, drop 1 [] = [] so you don't even need your if , but that isn't relevant to the question asked.)