How do I parse a JSON in Haskell where the name of the fields can be one of multiple values, but should be converted into a single Haskell type?

Question

Let's say I have the following JSON values.

{
  "fieldName1": 5,
  "value1": "Hello"
}

and

{
  "fieldName2": 7,
  "value1": "Welcome"
}

I have the following type in Haskell.

data Greeting 
  = Greeting
      {
        count :: Int,
        name :: Text
      }
  deriving (Generic, Show, Eq)

How do I parse this JSON into Haskell where fieldName1 or fieldName2 values should be parsed as count value?

I tried to solve this by doing something like shown below.

instance FromJSON Greeting where
  parseJSON = withObject "Greeting" $ \obj -> do
    count1 <- obj .:? "fieldName1"
    count2 <- obj .:? "fieldName2"
    name <- obj .: "value1"
    count <-
      case (count1, count2) of
        (Just count, Nothing) -> return count
        (Nothing, Just count) -> return count
        _ -> fail $ Text.unpack "Field missing"
    return Greeting {count = count, name = name}

It works but is very cumbersome and if there are more than 2 alternative values, it becomes a lot more complex. Is there any way to solve this in a simpler way?

Answer 1

The Parser monad where parseJSON runs is itself an Alternative, so you can use the alternation (<|>) operator within the parser definition:

instance FromJSON Greeting where
  parseJSON = withObject "Greeting" $ \o -> do
    Greeting <$> (o .: "fieldName1" <|> o .: "fieldName2"
                  <|> fail "no count field")
             <*> o .: "value1"

If multiple "count" fields are present, this will take the first one that parses.

If you want to process field names more programmatically (for example, if you want to accept a single field whose name starts with the prefix "field" while rejecting cases with multiple matching fields), then note that o is a KeyMap that can be processed with the functions in the Data.Aeson.KeyMap and Data.Aeson.Key modules:

import Data.Aeson
import qualified Data.Aeson.Key as Key
import qualified Data.Aeson.KeyMap as KeyMap
import Data.List (isPrefixOf)

instance FromJSON Greeting where
  parseJSON = withObject "Greeting" $ \o -> do
    -- get all values for "field*" keys
    let fields = [v | (k, v) <- KeyMap.toList o
                    , "field" `isPrefixOf` Key.toString k]
    case fields of
      [v] -> Greeting <$> parseJSON v <*> o .: "value1"
      []  -> fail "no \"field*\" fields"
      _   -> fail "multiple \"field*\" fields"

Answer 2

A slightly better variant:

import Control.Applicative ((<|>))

instance FromJSON Greeting where
  parseJSON = withObject "Greeting" $ \obj -> do
    count1 <- obj .:? "fieldName1"
    count2 <- obj .:? "fieldName2"
    name <- obj .: "value1"
    count <- maybe
       (fail $ Text.unpack "Field missing") -- fail case
       return                               -- success case
       (count1 <|> count2)                  -- take the first success
    return Greeting {count = count, name = name}

Essentially, c1 <|> ... <|> cn is the first Just if there is one, and Nothing otherwise.

You can also use case of instead of maybe, if you prefer. If this is frequently used, I'd put maybe (fail $ ...) return in a separate definition, so to give it a nice name.