Trying to understand function application operator in Haskell

Question

I'm trying to wrap my head around the function application operator ( $ ) in Haskell.

I'm working through the examples in Learn You a Haskell, and I thought I understood the following example:

Prelude> map ($ 3) [(+4), (*10), (^2), sqrt]
[7.0,30.0,9.0,1.7320508075688772] 

I then tried the following variant, which also worked fine:

Prelude> map ($ 3) [(+4), (*10), (\x -> x^2), sqrt]
[7.0,30.0,9.0,1.7320508075688772]

Finally, I tried modifying the third function in the list as follows, which generates an error:

Prelude> map ($ 3) [(+4), (*10), (\x -> 2^x), sqrt] 
<interactive>:53:38:
    Ambiguous type variable `b0' in the constraints:
      (Floating b0)
        arising from a use of `sqrt' at <interactive>:53:38-41
      (Integral b0) arising from a use of `^' at <interactive>:53:33
      (Num b0) arising from the literal `3' at <interactive>:53:8
    Probable fix: add a type signature that fixes these type variable(s)
    In the expression: sqrt
    In the second argument of `map', namely
      `[(+ 4), (* 10), (\ x -> 2 ^ x), sqrt]'
    In the expression: map ($ 3) [(+ 4), (* 10), (\ x -> 2 ^ x), sqrt]
Prelude> 

It seems if the final sqrt function is somehow begin associated with the previous list element, as the following variant works ok:

Prelude> map ($ 3) [(+4), (*10), (\x -> 2^x)]
[7,30,8]

Can someone enlighten me as to what's going on here?

Answer 1

The type of the used exponentiation operator is

(^) :: (Num a, Integral b) => a -> b -> a

so when you use \\x -> 2^x , you get an Integral constraint for the 3 . But sqrt imposes a Floating constraint. So the type of the 3 must satisfy

3 :: (Integral t, Floating t) => t

but there is no instance for both among the default type list, which is Integer and Double , so the defaulting fails, and you're left with an ambiguous type variable.

When you had \\x -> x^2 , there was only a Num constraint from the first functions, and Floating from sqrt , so the type was defaulted to Double .

You can make it work if you use

(**) :: Floating a => a -> a -> a

as your exponentiation operator, then the type can again be defaulted to Double .