Unhelpful error with associated types

[noughtmare]

In this stackoverflow question the asker presents this code:

{-# LANGUAGE TypeFamilies #-}

class Reproductive a where

  -- | A sequence of genetic information for an agent.
  type Strand a

  -- | Full set (both strands) of genetic information for an organism.
  type Genome a = (Strand a, Strand a)

But this produces the unhelpful error message (I was confused for a minute):

Assoc.hs:20:8: error:
    ‘Genome’ is not a (visible) associated type of class ‘Reproductive’
   |
20 |   type Genome a = (Strand a, Strand a)
   |        ^^^^^^

As a user I'm thinking that I'm defining an associated type, but this error message says that it expects the type to already be defined.

I now understand that you can easily solve this by writing a separate "kind signature" where the signature part can be omitted because it defaults to *:

{-# LANGUAGE TypeFamilies #-}

class Reproductive a where

  -- | A sequence of genetic information for an agent.
  type Strand a

  -- | Full set (both strands) of genetic information for an organism.
  type Genome a
  type Genome a = (Strand a, Strand a)

I think this warning can be improved, but I'm not sure how, yet.

[ketzacoatl]

At the least, could GHC provide some recommendations or suggestions for what we're missing or intended to do?

FWIW, I've also run into this when working with code a little over my head - sort of like turning down some road and realizing that dark and foreboding alley isn't the street you had in mind. The error doesn't give us much of anything to go off of, if we don't know more about the required understanding or topics that are relevant.

[goldfirere]

Yes, I agree. I think this should be quite easy to fix within GHC.

The problem in the original code is that classes both allow associated type declarations (type Genome a) and associated type defaults (type Genome a = ...). You can have the latter only when you have the former.

Here is my proposed new error message:

Assoc.hs:20:8: error:
    A default equation for an associated type is not allowed without a
    declaration for that associated type. You may wish to add:
      type Genome a
    to declare associated type `Genome'.
    NB: Any associated type equation (with an `=') in a class describes
    an associated type default.
   |
20 |   type Genome a = (Strand a, Strand a)
   |        ^^^^^^

What do we think? Is it too wordy?

[vanceism7]

How about one of these alternatives. It cuts down the word count a little, and maybe is a little more to the point?

Assoc.hs:20:8: error:
    A default equation was found for an
associated type with no declaration. 
You may wish to add:
      type Genome a
    to declare associated type `Genome'.
    NB: Any associated type equation (with an `=') in a class describes
    an associated type default.
   |
20 |   type Genome a = (Strand a, Strand a)
   |        ^^^^^^

Assoc.hs:20:8: error:
    A default equation for `Genome` was found,
but `Genome` has not yet been declared. 
You may wish to add:
      type Genome a
    to declare associated type `Genome'.
    NB: Any associated type equation (with an `=') in a class describes
    an associated type default.
   |
20 |   type Genome a = (Strand a, Strand a)
   |        ^^^^^^

[goldfirere]

I prefer the second version. Might be good to say

    You may wish to add
      type Genome a
    to class `Reproductive' to declare associated type `Genome'.

That is, let's say that the declaration must be within the class, which might not be otherwise clear.

[vanceism7]

I was thinking about this a little more, and realized this still might not be explicit enough to address the original ask of the ticket.

What if we did something more like this?:

Assoc.hs:20:8: error:
    A default equation for `Genome` was found,
but `Genome` has not yet been declared. 
You can declare the associated type `Genome` by adding:
      type Genome a
to the class `Reproductive` before the default equation:
      type Genome a = (Strand a, Strand a)
NB: Any associated type equation (with an `=') in a class describes
    an associated type default.
   |
20 |   type Genome a = (Strand a, Strand a)
   |        ^^^^^^

[goldfirere]

Order doesn't actually matter (which was a small worry I had about the "not yet been declared" text, but too small a worry to bring up previously). So you could say

class C a where
  type F a = Maybe a
  type F a

and that's fine. I personally think it's poor style, but GHC won't care.

[goldfirere]

Interestingly, the associated type family declaration is redundant; we could imagine changing the syntax so that an associated type family default declares the type family at the same time. (GHC does not currently allow pattern-matching in an associated type family default left-hand side, in contrast to its behavior for a while.)

[vanceism7]

Interestingly, the associated type family declaration is redundant; we could imagine changing the syntax so that an associated type family default declares the type family at the same time. (GHC does not currently allow pattern-matching in an associated type family default left-hand side, in contrast to its behavior for a while.)

Yea I was actually thinking the same thing while I typed that. If the compiler is smart enough to tell the user the exact steps to fix the issue, it seems like the compiler should be smart enough to infer the declaration without the user explicitly adding it.

Order doesn't actually matter (which was a small worry I had about the "not yet been declared" text, but too small a worry to bring up previously)

Although its not technically correct, it still communicates the essential change that needs to happen to fix the problem, and if it encourages good style, that seems ok to me. If we do want to be technically correct though, we could change the wording a bit more:

Assoc.hs:20:8: error:
    A default equation for `Genome` was found, but `Genome` has not been declared. 
You can declare the associated type `Genome` by adding:
      type Genome a
to the class `Reproductive` in addition to the default equation:
      type Genome a = (Strand a, Strand a)
NB: Any associated type equation (with an `=') in a class describes
    an associated type default.
   |
20 |   type Genome a = (Strand a, Strand a)
   |        ^^^^^^

[goldfirere]

I like where we've gotten here. Do we still need the NB line? Now that the text describes the existing code as a default, maybe the NB line is redundant. (This is an honest question -- I'm not sure whether I prefer with or without that line.)

[vanceism7]

I like that the NB makes it explicit that the type foo = bar pattern is the creation of a type default, but I think its probably easy enough for the reader to infer now with the current wording, and it does cut down on the size of the message a bit too. We can probably get away with cutting it out

Assoc.hs:20:8: error:
    A default equation for `Genome` was found, but `Genome` has not been declared. 
You can declare the associated type `Genome` by adding:
      type Genome a
to the class `Reproductive` in addition to the default equation:
      type Genome a = (Strand a, Strand a)
   |
20 |   type Genome a = (Strand a, Strand a)
   |  

[Ericson2314]

Not to derail, but I look forward to erased methods replacing type families with DH (or at least "promoted constraints").

The solution to this problem:

  type Genome a
  type Genome a = (Strand a, Strand a)

looks rather silly, compared to the regular expression analog with the mandatory signature. Will be eager to just see it gone!

[goldfirere]

I believe we have converged on a new error message text! Thanks for the discussion. I have posted https://gitlab.haskell.org/ghc/ghc/-/issues/21100.