Deriving Aeson type classes with two different possible types in the same field

Question

I have an API which returns JSON results in the following form:

{
  "data": [1, 2, 3]
}

The data field can be the encoding of two distinct records which are shown below:

newtype ResultsTypeA = ResultsTypeA [ResultTypeA]
newtype ResultsTypeB = ResultsTypeB [ResultTypeB]

When I query this API from Haskell, I know in advance whether I'm dealing with a ResultsTypeA or a ResultsTypeB because I'm explicitly asking for it in the query.

The part where I'm struggling is with the Aeson ToJSON and FromJSON instances. Since both result types A and B are ultimately lists of Int, I can't use pattern matcher in FromJSON, because I could only match a [Int] in both cases.

This is why I thought of doing the following:

newType ApiResponse a =
    ApiResponse {
        data :: a
    }

newtype ResultsTypeA = ResultsTypeA [ResultTypeA]
newtype ResultsTypeB = ResultsTypeB [ResultTypeB]

However I can't get my head around how to write the ToJSON and FromJSON instances for the above, because now ApiResponse has a type parameter, and nowhere in Aeson docs seem to be a place where it is explained how to derive these instances with a type parameter involved.

Another alternative, avoiding a type parameter, would be the following:

newtype Results =
    ResultsTypeA [ResultTypeA]
  | ResultsTypeB [ResultTypeB]

newtype ApiResponse =
    ApiResponse {
        data :: Results
    }

In this case the ToJSON is straightforward:

instance ToJSON ApiResponse where
    toJSON = genericToJSON $ defaultOptions

But the FromJSON gets us back to the problem of not being able to decide between result types A and B...

It is also possible that I'm doing it wrong entirely and there is a third option I wouldn't see.

• how would the FromJSON / ToJSON instances look like with a type parameter on ApiResponse?
• is there a better alternative completely different from anything exposed above to address this?

Answer 1

Since both result types A and B are ultimately lists of Int, I can't use pattern matcher in FromJSON, because I could only match a [Int] in both cases.

If you have a parameterized type, and you are writing a FromJSON instance by hand, you can put the precondition that the parameter must itself have a FromJSON instance.

Then, when you are writing the parser, you can use the parser for the type parameter as part of your definition. Like this:

{-# LANGUAGE OverloadedStrings #-}
import Data.Aeson

data ApiResponse a =
    ApiResponse {
        _data :: a,
        other :: Bool
    } 

instance FromJSON a => FromJSON (ApiResponse a) where
    parseJSON = withObject "" $ \o -> 
          ApiResponse <$> o .: "data" -- we are using the parameter's FromJSON 
                      <*> o .: "other"

Now, let's define two newtypes that borrow their respective FromJSON instances from that of Int, using GeneralizedNewtypeDeriving:

{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE DerivingStrategies #-}
-- Make the instances for the newtypes exactly equal to that of Int
newtype ResultTypeA = ResultTypeA Int deriving newtype FromJSON
newtype ResultTypeB = ResultTypeB Int deriving newtype FromJSON

If we load the file in ghci, we can supply the type parameter to ApiResponse and interrogate the available instances:

ghci> :instances ApiResponse [ResultTypeA]
instance FromJSON (ApiResponse [ResultTypeA])

---

You can also auto-derive FromJSON for ApiResponse, if you also derive Generic:

{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DerivingStrategies #-}
import Data.Aeson
import GHC.Generics

data ApiResponse a =
    ApiResponse {
        _data :: a,
        other :: Bool
    } 
    deriving stock Generic
    deriving anyclass FromJSON

deriving stock Generic makes GHC generate a representation of the datatype's structure that can be used to derive implementations for other typeclasses—here, FromJSON. For those derivations to be made through the Generic machinery, they need to use the anyclass method.

The generated instance will be of the form FromJSON a => FromJSON (ApiResponse a), just like the hand-written one. We can check it again in ghci:

ghci> :set -XPartialTypeSignatures
ghci> :set -Wno-partial-type-signatures
ghci> :instances ApiResponse _
instance FromJSON w => FromJSON (ApiResponse w)
instance Generic (ApiResponse w)