Haskell types frustrating a simple 'average' function

Question

I'm playing around with beginner Haskell, and I wanted to write an average function. It seemed like the simplest thing in the world, right?

Wrong.

It seems like Haskell's type system forbids average from working on a generic numeric type - I can get it to work on a list of Integrals, or an list of Fractionals, but not both.

I want:

average :: (Num a, Fractional b) => [a] -> b average xs = ... 

But I can only get:

averageInt :: (Integral a, Fractional b) => [a] -> b averageInt xs = fromIntegral (sum xs) / fromIntegral (length xs) 

or

averageFrac :: (Fractional a) => [a] -> a averageFrac xs = sum xs / fromIntegral (length xs) 

and the second one seems to work. Until I try to pass a variable.

*Main> averageFrac [1,2,3] 2.0 *Main> let x = [1,2,3] *Main> :t x x :: [Integer] *Main> averageFrac x  <interactive>:1:0:     No instance for (Fractional Integer)       arising from a use of `averageFrac ' at <interactive>:1:0-8     Possible fix: add an instance declaration for (Fractional Integer)     In the expression: average x     In the definition of `it': it = averageFrac x 

Apparently, Haskell is really picky about its types. That makes sense. But not when they could both be [Num]

Am I missing an obvious application of RealFrac?

Is there way to coerce Integrals into Fractionals that doesn't choke when it gets a Fractional input?

Is there some way to use Either and either to make some sort of polymorphic average function that would work on any sort of numeric array?

Does Haskell's type system outright forbid this function from ever existing?

Learning Haskell is like learning Calculus. It's really complicated and based on mountains of theory, and sometimes the problem is so mindbogglingly complex that I don't even know enough to phrase the question correctly, so any insight will be warmly accepted.

(Also, footnote: this is based off a homework problem. Everybody agrees that averageFrac, above, gets full points, but I have a sneaking suspicion that there is a way to make it work on both Integral AND Fractional arrays)

Answer 1

So fundamentally, you're constrained by the type of (/):

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

BTW, you also want Data.List.genericLength

genericLength :: (Num i) => [b] -> i 

So how about removing the fromIntegral for something more general:

import Data.List  average xs = realToFrac (sum xs) / genericLength xs 

which has only a Real constraint (Int, Integer, Float, Double)...

average :: (Real a, Fractional b) => [a] -> b 

So that'll take any Real into any Fractional.

And note all the posters getting caught by the polymorphic numeric literals in Haskell. 1 is not an integer, it is any number.

The Real class provides only one method: the ability to turn a value in class Num to a rational. Which is exactly what we need here.

And thus,

Prelude> average ([1 .. 10] :: [Double]) 5.5 Prelude> average ([1 .. 10] :: [Int]) 5.5 Prelude> average ([1 .. 10] :: [Float]) 5.5 Prelude> average ([1 .. 10] :: [Data.Word.Word8]) 5.5