Haskell : understanding "No instance for" error messages in ghci

ghc, ghci, haskell, winghci

Solution

My intention is to complement ehird's answer with a little bit more explanation. When you wrote the expression

3 4

Then the Haskell interpreter thinks that you are trying to apply the function `3` to whatever `4` is. In order for Haskell to interpret `3` as a function, it needs to make a call to the function

fromInteger :: Integer -> (a -> b)

in order to get a function (i.e. something of type `a -> b`) from the integer `3`. Now, `fromInteger` is defined in the `Num` typeclass to have the signature

instance Num x where
    fromInteger :: Integer -> x

i.e. when you make the type `x` an instance of the `Num` class, you give an implementation of `fromInteger` which tells Haskell how to convert an integer literal into an `x`. In your case, `x` is the function type `a -> b`. So let's do it!

First, some boilerplate. To make `x` an instance of `Num` Haskell requires that we also make it an instance of `Show` and `Eq`:

instance Show (a -> b) where show f = "<function>"
instance Eq (a -> b) where f == g = False

Now let's say we want to interpret `3 4` as "4 modulo 3". Then we need to tell Haskell how to interpret any integer as a function that calls `mod`. Moreover, since `mod` only accepts integral types (it has the signature `mod :: Integral a => a -> a -> a`) then we need to restrict the types of `a` and `b` to be integral as well:

instance (Integral a, Integral b) => Num (a -> b) where

To make an instance of `Num` we need to give implementations of `(+)`, `(-)`, `(*)` and `fromIntegral` (actually we should define a couple of other functions too, but let's not worry about that now).

There's a fairly natural way to define addition, subtraction and multiplication (all code from here forms part of the `Num` instance and should be indented relative to the instance declaration)

    f + g = \x -> f x + g x
    f - g = \x -> f x - g x
    f * g = \x -> f x * g x

i.e. when you add two functions `f` and `g`, you get a new function that applies both `f` and `g` to its argument, and then adds them together. Since we required that the result of applying `f` and `g` was of integral type, we know that it makes sense to add up their outputs.

To interpret an integer as a function we can write

    fromInteger n = \m -> fromIntegral m `mod` fromIntegral n

i.e. when we have an integer `n`, we return a function of a parameter `m` that, when called, ensures that both arguments are of the same type (by calling `fromIntegral` on both of them) and then uses them as arguments to the function `mod`.

Finally, a bit more boilerplate to stop Haskell complaining:

    abs f = undefined
    signum f = undefined

We can test this out. I have my code in a file called numfun.hs. I boot up the Haskell interpreter and load my file:

Prelude> :l numfun.hs
[1 of 1] Compiling Main             ( numfun.hs, interpreted )
Ok, modules loaded: Main.

Now I can define some functions:

*Main> let f = (+ 1)
*Main> let g = (* 2)

I can add them or subtract them:

*Main> (f + g) 3   -- (3+1) + (3*2)
10
*Main> (f - g) 3   -- (3+1) - (3*2)
-2

And I can call numbers as functions:

*Main> 3 4         -- 4 `mod` 3
1

Problem

Original source