haskelltypestype-familiesderiving# Deriving `Eq` for a data type based on a type family in Haskell

I'm working with type-level programming in Haskell and have encountered an issue with deriving an `Eq`

instance for a data type based on a type family.

Here's a simplified version of my code:

```
{-# LANGUAGE DataKinds, KindSignatures, TypeFamilies, DeriveGeneric #-}
data MyKind = Value1 | Value2
deriving (Eq)
type family MyTypeFamily (k :: MyKind) :: * where
MyTypeFamily 'Value1 = String
MyTypeFamily 'Value2 = [Int]
data MyType (k :: MyKind) = MyType (MyTypeFamily k)
deriving (Eq)
```

When attempting to compile this, I receive the following error:

```
• No instance for (Eq (MyTypeFamily k))
arising from the first field of ‘MyType’ (type ‘MyTypeFamily k’)
```

My goal is to derive separate `Eq`

and other instances for each value of `MyKind`

, without manually writing them out. Since the options for `MyKind`

are finite and all resolve to a type with `Eq`

instance, this feels like it should be possible. I tried using quantified constraints, but received an error about an illegal type synonym family application.

Is there a way in Haskell to derive separate instances based on a type family without manually writing them out or specifying each kind value individually? If not is there a counterexample, why it can't be done?

Solution

Perhaps `StandaloneDeriving`

will get you where you need to go (untested):

```
deriving instance Eq (MyTypeFamily k) => Eq (MyType k)
```

- Comparing lists in Haskell
- Is there a non-identity monad morphism M ~> M that is monadically natural in M?
- Problem with loading module ‘Distribution.Simple’
- Improving efficiency in Stirling numbers calculation
- Does sequencing an infinite list of IO actions by definition result in a never-ending action? Or is there a way to bail out?
- How to call pgQuery from postgresql-query?
- How to avoid whitespace after a tag (link) in Hamlet templates?
- Understanding type-directed resolution in Haskell with existential types
- Why is seq bad?
- Understanding bind function in Haskell
- How to create route that will trigger on any path in Servant?
- How do I use a global state in WAI middleware?
- nixos 23.11 cabal install mysql-simple problem - "Missing (or bad) C libraries"
- Is there a way to kill all forked threads in a GHCi session without restarting it?
- Why can an invalid list expression such as 2:1 be assigned to a variable, but not printed?
- Iterate over a type level list and call a function based on each type in the list
- How does this solution of Project Euler Problem 27 in the Haskell Wiki work?
- Why `Monad` is required to use `pure`?
- Can't do partial function definitions in GHCi
- recommended way to convert Double -> Float in Haskell
- Haskell profiling understanding cost centre summary for anonymous lambda
- Why is Haskell fully declarative?
- GHC Generating Redundant Core Operations
- Question about Event firing in reflex-frp
- Using Haskell's "Maybe", type declarations
- How can I elegantly invert a Map's keys and values?
- Why there is no output for wrapped IO in Haskell?
- What are the definitions of Weather and Memory in xmobar repo?
- Serializing a Data.Text value to a ByteString without unnecessary \NUL bytes
- Using Haskell with VS Code