Haskell: Variable Type confusion between Double and Int

Question

As an uni assignment, I was supposed to write a function with the type declaration:

pi_approx :: Int -> Double

and this was my first attempt:

pi_approx :: Int -> Double
pi_approx x = let total = sum [1 / (y^2) | y <- [1..x]]
    in sqrt (6 * total)

which threw the below error:

pi_approx.hs:4:8: error:
    * Couldn't match expected type `Double' with actual type `Int'  
    * In the expression: sqrt (6 * total)
      In the expression:
        let total = sum [1 / (y ^ 2) | y <- ...] in sqrt (6 * total)
      In an equation for `pi_approx':
          pi_approx x = let total = sum ... in sqrt (6 * total)
  |
4 |     in sqrt (6 * total)
  |        ^^^^^^^^^^^^^^^^

I went step by step trying to understand why the interpreter treats it as an Int:

level1 :: Fractional a => a -> a
level1 x = 1 / (x^2)

So far so good.

level2 :: (Enum a, Fractional a) => a -> [a]
level2 x = [level1 y | y <- [1..x]]

Also as expected.

level3 :: (Enum a, Fractional a) => a -> a
level3 x = sum (level2 x)

No Int to be seen...

level4 :: (Enum a, Fractional a) => a -> a
level4 x = 6 * (level3 x)

and finally

level5 :: (Floating a, Enum a) => a -> a
level5 x = sqrt (level4 x)

And having gone down this rabbit hole I'm no closer to my answer. I got it running with fromIntegral

pi_approx :: Int -> Double
pi_approx x = let total = sum [(fromIntegral 1) / ((fromIntegral y)^ (fromIntegral 2)) | y <- [1..x]]
    in sqrt (6*total)

but it got me nowhere nearer to understanding what caused the error in the first version. Could someone explain what I'm missing? Why was sqrt (6*total) treated as an Int?

I really like the plan you cooked up for experimenting. An observation: when doing your tests, you switched all the type signatures to be polymorphic instead of concrete. If you had started with the concrete type level1 :: Int -> Double it would have stopped you in your tracks right there (or, if you had started with the concrete type level1 :: Double -> Double then you would have soon discovered that your level5 had no Int anywhere in its type signature). — Daniel Wagner
Numerical constants such as 1, 2, 6, may have any numeric type. You can check this in the_ghci_ interpreter, entering “:type 6”. So you only need the (fromIntegral y) converter. The Int type constraint on the argument x propagates unmitigated to y. Hence the type conflict in your initial code at the level of the “/” operator. Unlike in C C++ Fortran, there is no automatic numeric type promotion. You have to allow it explicitely for it to happen. — jpmarinier
@DanielWagner I suspect the definitions were typed in without signatures, and the polymorphic types were copied from GHCi's :t command, as deduced by it. — Will Ness

luqui luqui · Accepted Answer · 2020-05-13T14:32:51

Because of the way typeclasses are type checked, the type error you were shown is not the most helpful one.

[ 1 / (y^2) | y <- [1..x] ]

So it is probably no surprise that, because x is an Int, [1..x] is a list of Ints and so y is an Int. Nor is it surprising that y^2 is an Int. Where GHC loses us is when it decides that therefore 1 / (y^2) is an Int.

The reason is this: the type of the divide operator is

(/) :: (Fractional a) => a -> a -> a

That is, it takes the same type on both sides, and also returns it. So as soon as the type of y^2 is known to be Int, we infer that 1 and the entire expression are Int also. Only later, during the constraint checking phase, GHC will make sure that Int is Fractional, which of course it is not. For example:

recp :: Int -> Int
recp x = 1 / x

Will give you a better error

• No instance for (Fractional Int) arising from a use of ‘/’
• In the expression: 1 / x
  In an equation for ‘recp’: recp x = 1 / x

But it didn't get that far when checking your function, because there was a type unification failure first.

Sometimes if you can't figure out an error it is helpful to remove the signature and see what type is inferred (more often, it's helpful to add more type signatures, but not always)

ghci> :t pi_approx
pi_approx :: (Floating a, Enum a) => a -> a

Without the signature, the function actually type-checks. It works, too:

ghci> pi_approx 100
3.1320765318091053

Here 100 is defaulted to be a Double to satisfy the Fractional constraint, and the whole definition goes through with everything as Doubles.

It's just that it doesn't accept Ints:

ghci> pi_approx (100 :: Int)

<interactive>:1:1: error:
• No instance for (Floating Int) arising from a use of ‘pi_approx’
• In the expression: pi_approx (1 :: Int)

Haskell: Variable Type confusion between Double and Int

3 Answers