了解Haskell中的函数定义和类型

Question

I am trying to write a simple tool in Haskell as a learning exercise, and have encountered something that I cannot figure out. Here is a simple sample illustrating it.

idMap :: a -> a
idMap x = map id x

main = do
    print $ idMap [1, 2]

According to my understanding, this example should compile and print [1, 2] when run. However, if fails to compile with the following message:

source_file.hs:2:18: error:
    • Couldn't match expected type ‘[b0]’ with actual type ‘a’
      ‘a’ is a rigid type variable bound by
        the type signature for:
          idMap :: forall a. a -> a
        at source_file.hs:1:10
    • In the second argument of ‘map’, namely ‘x’
      In the expression: map id x
      In an equation for ‘idMap’: idMap x = map id x
    • Relevant bindings include
        x :: a
          (bound at source_file.hs:2:7)
        idMap :: a -> a
          (bound at source_file.hs:2:1)

It kind of makes sense, given that the signature of map is (a -> b) -> [a] -> [b] so the input type is not necessarily the same as the output type, but the signature of id is a -> a so surely it follows that map id would have a signature of (a -> a) -> [a] -> [a] ?

The second part I don't really understand is why this is an exception given that all the types ( a and b as above) are Integer . It would make sense to me that since the signature of idMap is a -> a , there should only be a compile exception if it is used in a situation where the output type is expected to be different from input type.

Finally, how would I make this code actually work? My real code is a little more complicated and I am relying on the output type matching the input type elsewhere in the code so I don't want to change the signature of idMap , I want to know what I would need to do to write a function with that signature.

Answer 1

You are applying idMap to a list. Therefore, we know the argument type should be some list type. Further, you expect the return type to be a list ( [1,2] ), so the return type should be a list as well. Since the id function is fully polymorphic ( a -> a ), we can map it over a list of any type a and return a list of items of the same type a . Thus, your final type signature should be [a] -> [a] .

Regarding your second question, while it's true that the argument type and return type are both the same, the type as a -> a is not true for all types a . Based on the type signature of map , idMap must accept a list argument. We can declare type signatures for functions that are more constrained than necessary, but not less.

Answer 2

Your implementation of idMap ...

idMap x = map id x

... involves applying map id on x . As a consequence, x must be a list.

GHCi> :t map id
map id :: [b] -> [b]

This will work just fine:

idMap :: [a] -> [a]
idMap x = map id x

Note that, thanks to the use of id , x and idMap x do have the same type (as do their elements), as you expected.