6.8.5. Default method signatures — Glasgow Haskell Compiler 9.0.0.20201227 User's Guide

# 6.8.5. Default method signatures

`DefaultSignatures`

  Since: | 7.2.1

  Allows the definition of default method signatures in class definitions.

Haskell 98 allows you to define a default implementation when declaring a class:

    class Enum a where
      enum :: [a]
      enum = []

The type of the `enum` method is `[a]`, and this is also the type of the default method. You can change the type of the default method by requiring a different context using the extension `DefaultSignatures`. For instance, if you have written a generic implementation of enumeration in a class `GEnum` with method `genum`, you can specify a default method that uses that generic implementation. But your default implementation can only be used if the constraints are satisfied, therefore you need to change the type of the default method

    class Enum a where
      enum :: [a]
      default enum :: (Generic a, GEnum (Rep a)) => [a]
      enum = map to genum

We reuse the keyword `default` to signal that a signature applies to the default method only; when defining instances of the `Enum` class, the original type `[a]` of `enum` still applies. When giving an empty instance, however, the default implementation `(map to genum)` is filled-in, and type-checked with the type `(Generic a, GEnum (Rep a)) => [a]`.

The type signature for a default method of a type class must take on the same form as the corresponding main method’s type signature. Otherwise, the typechecker will reject that class’s definition. By “take on the same form”, we mean that the default type signature should differ from the main type signature only in their contexts. Therefore, if you have a method `bar`:

    class Foo a where
      bar :: forall b. C => a -> b -> b

Then a default method for `bar` must take on the form:

    default bar :: forall b. C' => a -> b -> b

`C` is allowed to be different from `C'`, but the right-hand sides of the type signatures must coincide. We require this because when you declare an empty instance for a class that uses `DefaultSignatures`, GHC implicitly fills in the default implementation like this:

    instance Foo Int where
      bar = default_bar @Int

Where `@Int` utilizes visible type application (Visible type application) to instantiate the `b` in `default bar :: forall b. C' => a -> b -> b`. In order for this type application to work, the default type signature for `bar` must have the same type variable order as the non-default signature! But there is no obligation for `C` and `C'` to be the same (see, for instance, the `Enum` example above, which relies on this).

To further explain this example, the right-hand side of the default type signature for `bar` must be something that is alpha-equivalent to `forall b. a -> b -> b` (where `a` is bound by the class itself, and is thus free in the methods’ type signatures). So this would also be an acceptable default type signature:

    default bar :: forall x. C' => a -> x -> x

But not this (since the free variable `a` is in the wrong place):

    default bar :: forall b. C' => b -> a -> b

Nor this, since we can’t match the type variable `b` with the concrete type `Int`:

    default bar :: C' => a -> Int -> Int

That last one deserves a special mention, however, since `a -> Int -> Int` is a straightforward instantiation of `forall b. a -> b -> b`. You can still write such a default type signature, but you now must use type equalities to do so:

    default bar :: forall b. (C', b ~ Int) => a -> b -> b

We use default signatures to simplify generic programming in GHC (Generic programming).