Question

Here is a function that takes a pair of Integral
values and divides them:

divide_v1 :: Integral a => (a, a) -> a
divide_v1 (m, n) = (m + n) `div` 2

I invoke the function with a pair of Integral
values and it works as expected:

divide_v1 (1, 3)

Great. That’s perfect if my numbers are always Integrals.

Here is a function that takes a pair of Fractional
values and divides them:

divide_v2 :: Fractional a => (a, a) -> a
divide_v2 (m, n) = (m + n) / 2

I invoke the function with a pair of Fractional
values and it works as expected:

divide_v2 (1.0, 3.0)

Great. That’s perfect if my numbers are always Fractionals.

I would like a function that works regardless of whether the
numbers are Integrals or Fractionals:

divide_v3 :: Num a => (a, a) -> a
divide_v3 (m, n) = (m + n) ___ 2

What operator do I use for _?

Answer 1

To expand on what AndrewC said, div doesn’t have the same properties that / does. For example, in maths, if a divided by b = c, then c times b == a. When working with types like Double and Float, the operations / and * satisfy this property (to the extent that the accuracy of the type allows). But when using div with Ints, the property doesn’t hold true. 5 div 3 = 1, but 1*3 /= 5! So if you want to use the same “divide operation” for a variety of numeric types, you need to think about how you want it to behave. Also, you almost certainly wouldn’t want to use the same operator /, because that would be misleading.

If you want your “divide operation” to return the same type as its operands, here’s one way to accomplish that:

class Divideable a where
  mydiv :: a -> a -> a

instance Divideable Int where
  mydiv = div

instance Divideable Double where
  mydiv = (/)

In GHCi, it looks like this:

λ> 5 `mydiv` 3 :: Int
1
λ> 5 `mydiv` 3 :: Double
1.6666666666666667
λ> 5.0 `mydiv` 3.0 :: Double
1.6666666666666667

On the other hand, if you want to do “true” division, you would need to convert the integral types like this:

class Divideable2 a where
  mydiv2 :: a -> a -> Double

instance Divideable2 Int where
  mydiv2 a b = fromIntegral a / fromIntegral b

instance Divideable2 Double where
  mydiv2 = (/)

In GHCi, this gives:

λ> 5 `mydiv2` 3
1.6666666666666667
λ> 5.0 `mydiv2` 3.0
1.6666666666666667