Haskell：我不知道如何匹配类型

Question

So, I have this Haskell question to resolve:

Define a mapIO function that receives a function f and an input and output action a and results in an input and output action that, when executed, performs the given action a and returns the application of f to the return of a .

Here's my code:

mapIO f a = do b <- a
               return f(b);

It compiles but it doesn't work. When I try to do the same as the following execution example, it doesn't work. Please, can someone help me?

Prelude Data.Char> mapIO even readLn
75
False

Answer 1

In many other languages, g(x) is the syntax for applying function g to argument x . In Haskell, juxtaposition suffices, so that gx applies g to x . By coincidence, this means g(x) is also valid syntax that applies g to the value (x) , which is the same as x , so to a beginner it may seem that g(x) is the correct syntax for function application. But it ain't, and that confusion has bitten you here.

When you write return f(b) , you probably assume this means to use the special syntax return and the thing to return should be the function application f(b) . However, return is itself a function in Haskell. So what it actually means is to apply return to the function f , then apply the result to the term (b) . (Function application is "left-associative" in that sense.)

Luckily the fix for function application associativity problems, as with other associativity problems, is to use parentheses. So:

return (f(b))

Or, without the coincidentally correct extra parentheses:

return (f b)

This leaves only the question of why it "worked" (in the sense of compiled and type-checked) in return f(b) form. This is a bit of an advanced topic; but it turns out that functions also form a Monad with return = const , and so return f(b) actually meant const f(b) , which threw away the (b) term. (Aside: in addition to being allowed to use the function instance of Monad , we also must be using the function instance of Monad here. Since we are applying return f to (b) , the type of return f must be a function.) So your definition was the same as:

mapIO' f a = do b <- a
                f

That is: first do a , throw away its result, then do f as if it were another input/output action . If you check the type inferred for mapIO you will see it matches this intuition:

mapIO :: Monad m => m b -> m t -> m b

Whoops!