Haskell - “应用程序中的类型错误”：“统一会给出无限类型”

Question

I'm beginning work with Haskell, but this equality check I'm attempting to make isn't working out.

I have a function, countLetter a [b] c , where a is a char, b is a list of chars and c is an int. (The type declarations passed through fine.) But I run into problems with this expression:

if a == head(b)

Gives me the following message:

Type error in application

*** Expression     : a == head b
*** Term           : a
*** Type           : [a]
*** Does not match : a
*** Because        : unification would give infinite type

My code in full, if it's needed, is this:

countLetter :: char -> [char] -> int

countLetter a [b] c = if null b

                       then []
                       else
                       if a == head(b)
                       then countLetter a tail(b) c+1
                    else
                    countLetter head(b) tail(b) c

Any help or advice would be greatly appreciated. Thank you.

Answer 1

First of all, types in Haskell start with capital letters. If you use identifiers starting with lower case letters in a type signature, they're interpreted as type variables. So your type char -> [char] -> int is the same as a -> [a] -> b , which is not a sensible type for your function. Your want Char -> [Char] -> Int .

Secondly [] is not a valid value of type Int . Fixing your type signature should produce an error message that tells you this in less ambiguous terms.

It should then also tell you that null b is a type error because b is of type Char (the second argument of your function is of type [Char] and you've matched it against the pattern [b] , binding b to the single Char contained in that list) and null takes a list, not a Char, as its argument.

To clarify the last point a bit:

The second argument to your function is a list. By writing [b] in your parameter list, you're matching that argument against the pattern [b] . In other words writing countLetter a [b] c = blabla is the same as writing:

countLetter a theList c =
    case theList of
        [b] -> blabla

So you're saying: "the second argument to the function must be a list with one single element and that element shall be called b ". That is not what you want to be saying. What you want to be saying is "the second argument to the function (which, incidentally, is a list) shall be called b ". For that you simply writie countLetter abc = blabla .

Parameters of type list don't have to be denoted any differently than other types of parameters.

Answer 2

Another error you will encounter is this:

countLetter head(b) tail(b) c

This is, by the rules, the same as

countLetter head b tail b c

ie you call your countLetter function with 5 arguments, when it only takes 3 (according to the first equation) or 2 (according to your type signature). (This is another point the compiler will be very unhappy with.)

You probably want this:

countLetter (head b) (tail b) c

Likewise:

countLetter a tail(b) c+1

is the same as

(countLetter a tail b c) + 1

but you probably want:

countLetter a (tail b) (c+1)

Answer 3

Aside from the other answers, which provide ways to fix your function, you may want to consider writing this in a more compositional style. Specifically, look for ways you could write a function by building up other, standard functions. Suppose you have a function that will remove everything that isn't equal to the test letter from a list.

myFilter :: Char -> [Char] -> [Char
myFilter = ...

After using myFilter , you'd be left with a list with only the element you're checking for. At this point, you can just use length to get the length of the list:

countLetter :: Char -> [Char] -> Int
countLetter a b = length $ myFilter a b

So now you just need to define myFilter , which can be done with the standard Prelude function filter

myFilter a b = filter (==a) b

For a function this small, creating our own definition is hardly worth it, as you can just write

countLetter a b = length $ filter (== a) b

Now, define this in ghci to see what type it finds for the function countLetter

Prelude> let countLetter a b = length $ filter (== a) b
Prelude> :t countLetter
countLetter :: Eq a => a -> [a] -> Int

No Char in sight! The implementation doesn't depend on the elements being letters, only that they can be compared for equality (this is true of your approach also). So ghci reflects that in the calculated type. But you can see that this is exactly the type you want by substituting Char for a .

Many functional programmers tend to find this approach, ie building functions by composing smaller parts, particularly easy to reason about, so it can be quite common. Especially when working with lists, you might want to see if you can write an implementation using so-called higher-order functions, such as map , filter , or a fold, instead of using recursion. Sometimes recursion is the clearest way, but I expect you will frequently find function composition to be a better approach.