是否可以将不断变化的 JSON 键与较大记录类型中的 aeson 相匹配的总和类型数据构造函数？

Question

所以我有这个数据类型ItemType，它是使用它的数据构造函数名称解码的（参见 FromJSON 实例）。

import           Data.Aeson
import           Data.Aeson.Types
import           Data.Char (toLower)
import           GHC.Generics

data ItemType =
    MkLogin Login
  | MkCard Card
  | MkIdentity Identity
  | MkSecureNote Note
  deriving (Generic, Show)

lowercase :: String -> String
lowercase "" = ""
lowercase (s:ss) = toLower s : ss

stripPrefix :: String -> String
stripPrefix ('M':'k':ss) = ss
stripPrefix str = str

-- | Decode value using ItemType data constructor names
instance FromJSON ItemType where
  parseJSON = genericParseJSON defaultOptions
    { constructorTagModifier = lowercase . stripPrefix
    , sumEncoding = ObjectWithSingleField }

我想做的是将此类型作为字段添加到名为 Item

的更大记录类型中

data Item =
  Item { _object :: String
       , _id :: String
       , _organizationId :: Maybe Int
       , _folderId :: Maybe Int
       , _type :: Int
       , _name :: String
       , _notes :: String
       , _favorite :: Bool
       , ??? :: ItemType -- don't know how to add this without a different field name
       , _collectionIds :: [Int]
       , _revisionDate :: Maybe String
       } deriving (Generic, Show)

instance FromJSON Item where
  parseJSON =
    genericParseJSON defaultOptions { fieldLabelModifier = stripUnderscore }

但是我不想为该类型创建新的字段名称。相反，我想使用 aeson 在 ItemType 上匹配的数据构造函数作为字段名称，因为 JSON 对象中 ItemType 字段的键我正在尝试建模，具体取决于什么ItemType 是的。所以在这种情况下，密钥是“登录”、“卡”、“身份”、“secureNote”。也许我应该为 sumEncoding 使用 TaggedObject，但我不太确定它是如何工作的。

示例 JSON Item 个对象列表：https://i.imgur.com/xzHy9MU.png。在这里，您可以通过键“登录”、“卡”、“身份”看到 ItemType 字段，具体取决于它们的类型。

Answer 1

一种方法是在 Item 数据声明中完全没有 ItemType 字段。然后使用元组或自定义对类型来保存两个部分；所以：

data ItemWithType = ItemWithType ItemType Item

instance FromJSON ItemWithType where
    parseJSON v = liftA2 ItemWithType (parseJSON v) (parseJSON v)

您也可以跳过定义 ItemWithType 而只使用

\o -> liftA2 (,) (parseJSON o) (parseJSON o)

直接解析名称一致的字段和变量key下的对象的元组

Answer 2

你可以使用一个相当丑陋的 hack 来 pre-process 传入的 JSON Value，这样实际的 JSON 输入就像：

{
  "id": "foo",
  "bool": false
}

被解析为：

{
  "id": "foo",
  "itemtype": {"bool" : false}
}

通用解析器可以使用 ObjectWithSingleField 求和编码方法直接处理。

作为一个简化的例子，给定：

data ItemType =
    MkInt Int
  | MkBool Bool
  deriving (Generic, Show)

instance FromJSON ItemType where
  parseJSON = genericParseJSON defaultOptions
    { constructorTagModifier = map toLower . \('M':'k':ss) -> ss
    , sumEncoding = ObjectWithSingleField }

和：

data Item =
  Item { _id :: String
       , _itemtype :: ItemType
       }
  deriving (Generic, Show)

您可以为 Item 编写一个 FromJSON 实例，将 "int" 或 "bool" 字段嵌套在 "itemtype" 字段中。（原始字段的副本保留在原处，但被通用解析器忽略。）

instance FromJSON Item where
  parseJSON v = do
    v' <- withObject "Item" nest v
    genericParseJSON defaultOptions { fieldLabelModifier = \('_':ss) -> ss } v'
    where nest o = Object <$> (HM.insert "itemtype" <$> item <*> pure o)
            where item = subObj "int" <|> subObj "bool" <|> fail "no item type field"
                  subObj k = (\v -> object [(k,v)]) <$> o .: k

完整代码：

{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TupleSections #-}

import           Control.Applicative
import           Data.Aeson
import           Data.Aeson.Types
import           Data.Char (toLower)
import           GHC.Generics
import qualified Data.HashMap.Strict as HM

data ItemType =
    MkInt Int
  | MkBool Bool
  deriving (Generic, Show)

instance FromJSON ItemType where
  parseJSON = genericParseJSON defaultOptions
    { constructorTagModifier = map toLower . \('M':'k':ss) -> ss
    , sumEncoding = ObjectWithSingleField }

data Item =
  Item { _id :: String
       , _itemtype :: ItemType
       }
  deriving (Generic, Show)

instance FromJSON Item where
  parseJSON v = do
    v' <- withObject "Item" nest v
    genericParseJSON defaultOptions { fieldLabelModifier = \('_':ss) -> ss } v'
    where nest o = Object <$> (HM.insert "itemtype" <$> item <*> pure o)
            where item = subObj "int" <|> subObj "bool" <|> fail "no item type field"
                  subObj k = (\v -> object [(k,v)]) <$> o .: k

test1, test2, test3 :: Either String Item
test1 = eitherDecode "{\"id\":\"foo\",\"bool\":false}"
test2 = eitherDecode "{\"id\":\"foo\",\"int\":10}"
test3 = eitherDecode "{\"id\":\"foo\"}"

main = do
  print test1
  print test2
  print test3

不过，一般来说，除非您经常这样做，否则为了清晰度和可读性，最好放弃泛型并编写必要的样板。即使对于您的原始示例，也不是那么繁重。是的，您必须保持类型和实例同步，但是一些简单的测试应该可以发现任何问题。因此，例如，类似于：

instance FromJSON Item where
  parseJSON = withObject "Item" $ \o ->
    Item <$> o .: "object"
         <*> o .: "id"
         <*> o .:? "organizationId"
         <*> o .:? "folderId"
         <*> o .: "type"
         <*> o .: "name"
         <*> o .: "notes"
         <*> o .: "favorite"
         <*> parseItemType o
         <*> o .: "collectionIds"
         <*> o .:? "revisionDate"
    where parseItemType o =
                MkLogin <$> o .: "login"
            <|> MkCard <$> o .: "card"
            <|> MkIdentity <$> o .: "identity"
            <|> MkSecureNote <$> o .: "securenote"

是否可以将不断变化的 JSON 键与较大记录类型中的 aeson 相匹配的总和类型数据构造函数？

Is it possible to match a changing JSON key to a sum type data constructor with aeson inside a larger record type?

parsing

haskell

aeson