unexpected difference between newtype and data

The following code compiles fine

-- | A referable class
-- An object can only have one reference.
-- For example, a function is either referenced by name of by signature but not both.
class ( Eq (Ref a)
      , Ord (Ref a)
      , Hashable (Ref a)
      , Show (Ref a)
      , Read (Ref a)
      , Data (Ref a)
      ) => Referable a where
    type Ref a
    toRef :: a -> Ref a

data Referable a => 
            RefMap a = RefMap { -- | the HashMap
                                toHashMap :: HashMap.Map (Ref a) a
                              } deriving (Eq, Ord, Show, Read, Data)

yet following the hlint hint to replace data by the equivalent newtype results in the following issues:

  src\TorXakis\Referable.hs:59:43: error:
        * Could not deduce (Eq (Ref a))
            arising from the 'deriving' clause of a data type declaration
          from the context: Eq a
            bound by the deriving clause for `Eq (RefMap a)'
            at src\TorXakis\Referable.hs:59:43-44
          Possible fix:
            use a standalone 'deriving instance' declaration,
              so you can specify the instance context yourself
        * When deriving the instance for (Eq (RefMap a))
       |
    59 |                               } deriving (Eq, Ord, Show, Read, Data)
       |                                           ^^

    src\TorXakis\Referable.hs:59:47: error:
        * Could not deduce (Ord (Ref a))
            arising from the 'deriving' clause of a data type declaration
          from the context: Ord a
            bound by the deriving clause for `Ord (RefMap a)'
            at src\TorXakis\Referable.hs:59:47-49
          Possible fix:
            use a standalone 'deriving instance' declaration,
              so you can specify the instance context yourself
        * When deriving the instance for (Ord (RefMap a))
       |
    59 |                               } deriving (Eq, Ord, Show, Read, Data)

I assume this is a bug...

Trac metadata

Trac field	Value
Version	8.2.2
Type	Bug
TypeOfFailure	OtherFailure
Priority	normal
Resolution	Unresolved
Component	Compiler
Test case
Differential revisions
BlockedBy
Related
Blocking
CC
Operating system
Architecture

changed weight to 5

added Tbug Trac import labels

Hm. It looks like the newtype deriving strategy (which is what would be used for Eq and Ord but not for others) ignores datatype contexts.

Indeed, GeneralizedNewtypeDeriving (and DerivingVia) have never taken the "stupid theta" (i.e., DatatypeContexts) into account when generating code for whatever reason. Fixing this wouldn't be too difficult (I think you'd just need to change the relevant bits in TcDeriv), but is it really worth it? DatatypeContexts is a deprecated feature:

λ> :set -XDatatypeContexts

<no location info>: warning:
    -XDatatypeContexts is deprecated: It was widely considered a misfeature, and has been removed from the Haskell language.

And I'm not sure if it's worthwhile to continue to maintain it.

mentioned in issue #16323 (closed)

added Pnormal label

I agree with @RyanGlScott, since DatatypeContexts are deprecated I don't think it is worthwhile to maintain it.

As a workaround, one can use StandaloneDeriving to derive instances when using the newtype declaration:

class ( Eq (Ref a)
      , Ord (Ref a)
      , Hashable (Ref a)
      , Show (Ref a)
      , Read (Ref a)
      , Data (Ref a)
      ) => Referable a where
    type Ref a
    toRef :: a -> Ref a

newtype Referable a => 
            RefMap a = RefMap { -- | the HashMap
                                toHashMap :: HashMap.Map (Ref a) a
                              }

deriving instance (Referable a, Eq a  ) => Eq (RefMap a)
deriving instance (Referable a, Ord a ) => Ord (RefMap a)
deriving instance (Referable a, Show a) => Show (RefMap a)
deriving instance (Referable a, Read a) => Read (RefMap a)
deriving instance (Referable a, Data a) => Data (RefMap a)

closed

added deriving label