No instance arising [GHC-39999]

This error happens when an expression in the code has a type constraint (e.g. Eq a => a -> a) requiring an instance of a type class but GHC can‘t find it. This most commonly happens for two reasons: Either the type is too polymorphic (i.e. general) e.g. forall a. a and there is no type signature declaring that the type should have the instance. Or the type is specific e.g. Bool, but there is no instance for the desired type class defined for this type.

Examples

A usage of (==) on a data type which doesn‘t have an instance for Eq.

Error message

Main.hs:4:15: error: [GHC-39999]
    • No instance for (Eq Foo) arising from a use of ‘==’
    • In the expression: foo == A
      In an equation for ‘isA’: isA foo = foo == A
  |
4 | isA foo = foo == A
  |               ^^

Explanation

The operator == is only defined on types which have an instance for the Eq type class. The data type Foo does not have an instance. So GHC doesn‘t know how to compare values of Foo. To make this example compile we can create an Eq instance by using a derive statement.

Main.hs
Before
data Foo = A | B

isA :: Foo -> Bool
isA foo = foo == A
After
data Foo = A | B deriving Eq

isA :: Foo -> Bool
isA foo = foo == A
A usage of `+` on a too polymorphic variable.

Error message

Main.hs:2:11: error: [GHC-39999]
    • No instance for (Num a) arising from a use of ‘+’
      Possible fix:
        add (Num a) to the context of
          the type signature for:
            add :: forall a. a -> a -> a
    • In the expression: x + y
      In an equation for ‘add’: add x y = x + y
  |
2 | add x y = x + y
  |           ^

Explanation

The operator + is only defined on types which have an instance of the Num type class. If the function has the signature a -> a -> a someone could e.g. pass in a String for a and GHC wouldn‘t know how to add two Strings. Too fix it, like the compiler suggests, we add the Num a => constraint to the type signature to make sure that all users of add provide a suitable Num instance.

Main.hs
Before
add :: a -> a -> a
add x y = x + y
After
add :: Num a => a -> a -> a
add x y = x + y
A usage of `x.foo` with the field `foo` not being in scope

Error message

src/Main.hs:6:12: error: [GHC-39999]
    • No instance for ‘GHC.Records.HasField "foo" MyData Int’
        arising from selecting the field ‘foo’
      Perhaps you want to add ‘foo’ to the import list in the import of
      ‘DataType’ (src/Main.hs:3:1-24).
    • In the expression: x.foo
      In an equation for ‘getFoo’: getFoo x = x.foo
  |
6 | getFoo x = x.foo
  |

Explanation

This error arises when using the OverloadedRecordDot extension. Given a module exporting a record:

module DataType where

data MyData = MyData { foo :: Int, bar :: String }

When MyData is imported into a module without also importing the fields, attempting to access fields using OverloadedRecordDot will result in an error.

Adding the field to the import list will resolve the issue.

Main.hs
Before
module Main where

import DataType (MyData)

getFoo :: MyData -> Int
getFoo x = x.foo
After
module Main where

import DataType (MyData(foo))

getFoo :: MyData -> Int
getFoo x = x.foo
Missing superclass declaration

Error message on GHC 9.6.2

Main.hs:5:10: error: [GHC-39999]
    • Could not deduce ‘Show (Foo a)’
        arising from the head of a quantified constraint
        arising from the superclasses of an instance declaration
      from the context: Show a
        bound by a quantified context at Main.hs:5:10-18
    • In the instance declaration for ‘Show1 Foo’
  |
5 | instance Show1 Foo where
  |          ^^^^^^^^^

Explanation

The Show1 class has changed in GHC 9.6 to require a quantified superclass constraint Show. To fix this error, for every instance Show1 declaration add a corresponding instance Show declaration for the same data type.

Main.hs
Before
import Data.Functor.Classes (Show1(..))

newtype Foo a = Foo a

instance Show1 Foo where
  liftShowsPrec showsPrec _showList prec (Foo a) rest = "Foo " ++ showsPrec prec a rest
After
import Data.Functor.Classes (Show1(..))

newtype Foo a = Foo a

instance Show a => Show (Foo a) where
   show (Foo a) = "Foo " ++ show a

instance Show1 Foo where
  liftShowsPrec showsPrec _showList prec (Foo a) rest = "Foo " ++ showsPrec prec a rest