在函数中键入同义词展开？

Question

Reading book by Simon Marlow " Parallel and Concurrent Programming in Haskell " I encountered a thing I am not sure about why it works the way GHC sees it. Namely:

evalPair :: Strategy a -> Strategy b -> Strategy (a,b)
evalPair sa sb (a,b) = do
  a' <- sa a
  b' <- sb b
  return (a',b')

Has two input arguments (the way I see it Strategy a and Strategy b ) on type level and one output - Strategy (a,b) . But line under there are three arguments: sa , sb and (a,b) . It is confusing.

But since Strategy is type synonym:

type Strategy a = a -> Eval a

I thought that maybe if I unroll Strategies to (a -> Eval a) it will be clearer. So:

evalPair :: (a -> Eval a) -> (b -> Eval b) -> (a,b) -> Eval (a,b)

and (brackets added on the end)

evalPair :: (a -> Eval a) -> (b -> Eval b) -> ((a,b) -> Eval (a,b))

both compile.

Then I wrote it this way and thanks to Stack tooltips found that what is returned from function evalPair (went back to Strategy on purpose to make it more confusing) is not Strategy (a,b) but Eval (a,b) .

evalPair :: Strategy a -> Strategy b -> Strategy (a,b)
evalPair sa sb (a,b) = 
let res = do
          a' <- sa a
          b' <- sb b
          return (a', b')
in res

So clearly compiler unwrapped last argument from its type synonym, but only the last one - since we do not need to provide values for Strategy a and Strategy b

Here are my questions:

1. Where can I get more information on this behaviour of the compiler? Why the function returns Eval a even though it says that it returns Strategy a

2. If unwrapping happens, then why don't I need (and can't in fact) provide values for Strategy a and Strategy b like so:

    evalPair :: Strategy a -> Strategy b -> Strategy (a,b) evalPair a sa a sb (a,b) = do a' <- sa a b' <- sb b return (a',b') 

Answer 1

Given the type synonym

type Strategy a = a -> Eval a

And the type

Strategy a -> Strategy b -> Strategy (a,b)

We can "desugar" the type by replacing each use of the synonym with its definition:

(a -> Eval a) -> (b -> Eval b) -> ((a,b) -> Eval (a,b))

Note that the parens are necessary here to clarify what's going on. The function evalPair still takes two arguments. Its two arguments are two functions . This may be clearer if I visually align the types with their corresponding arguments like so:

evalPair :: (a -> Eval a) -> (b -> Eval b) -> (a,b) -> Eval (a,b)
evalPair    sa               sb               (a,b)  = ...

Therefore the type of sa is a -> Eval a , and the type of sb is b -> Eval b .

Note that the Haskell Report states:

Type synonyms are a convenient, but strictly syntactic, mechanism to make type signatures more readable. A synonym and its definition are completely interchangeable

Therefore, the compiler may freely "wrap" or "unwrap" type synonyms, as they are "completely interchangeable".

You can read about Type Synonyms in the Haskell Report, section 4.2.2: https://www.haskell.org/onlinereport/haskell2010/haskellch4.html#x10-730004.2.2

Answer 2

You are misunderstanding how Haskell functions work.

All Haskell functions have only one argument . If a function f takes a value of type A , and returns something of type B , we write f :: A -> B .

However, of course, we can write functions with multiple arguments, but in a clever way, called currying . If we want a function g that takes an A and a B , and produces a C , we actually write a function that takes an A , and then returns a function that takes a B and returns a C .

We write this as g :: A -> (B -> C) . However, since this is what we usually want to do with functions, the Haskell compiler will read the signature g :: A -> B -> C as the same thing.

This means that when we write A -> B -> C -> ... -> Z , we really mean A -> (B -> (C -> (... -> Z...))) .

However, if we write g :: (A -> B) -> C , this is not the same thing! Brackets matter! g is now a function that takes a function and produces a C .

Now, let's inspect this specific example:

 evalPair :: (a -> Eval a) -> (b -> Eval b) -> (a,b) -> Eval (a,b)

I read this as:

The function evalPair takes the following:

• Something of type a -> Eval a
• Something of type b -> Eval b
• Something of type (a,b)

And produces something of type Eval (a,b) .

So the declaration would naturally look something like

evalPair first_arg second_arg third_arg = -- ...

Writing evalPair a sa a sb (a,b) = -- ... is nonsensical, since that takes 5 arguments, and thus evalPair would have a type of the form a -> b -> c -> (d, e) -> f , which is completely different to what we expect.