编写可选的 Aeson 解析器
Composing optional Aeson parsers
这是代表用户的 JSON 对象的一部分:
{ "image": { "url": "http://example.com" } }
我需要将其解析为 User
类型:
data User = User { imgUrl :: Maybe Text }
天真的解决方案:
parseJSON (Object o) = User <$> getImgUrl o
where getImgUrl o = (o .:? "image") >>= maybe (return Nothing) (.:? "url")
但这并不比这些连锁店好多少:
case f m1 of
Nothing -> Nothing
Just m2 -> case f2 m2 of
Nothing -> Nothing
Just m3 -> case f3 m3 ....
经常在 'Why do you need a Monad' 解释中得到证明
因此,我需要编写看起来像 (.:? "url") :: Parser (Maybe a)
的解析器
我试图用 comp
函数描述该组合:
getImgUrl :: Object -> Parser (Maybe Text)
getImgUrl o = o .:? "image" >>= comp (o .:? "url")
comp :: (Monad m) => (a -> m (Maybe b)) -> Maybe a -> m (Maybe b)
comp p Nothing = return Nothing
comp p (Just o) = p o
闻起来像 Functor,但 fmap
对我没有帮助。
然后我决定,那篇作文一定要写下去:
getImgUrl :: Object -> Parser (Maybe Text)
getImgUrl = comp2 (.:? "image") (.:? "url") o
-- Maybe should be changed to a matching typeclass
comp2 :: (Monad m) => (a -> m (Maybe b)) -> (b -> m (Maybe c)) -> a -> m (Maybe c)
comp2 = undefined
Hoogle 搜索对我没有帮助,但浏览 Control.Monad
文档给了我 Kliesli 组合,我没有经验。我看到一些相似之处:
(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
comp2 :: Monad m => (a -> m (f b)) -> (b -> m (f c)) -> a -> m (f c)
不同的是合成时Maybe
应该是'unwrapped'.
看来我已经接近解决方案了,但仍然找不到。请给我一些见解。
[更新]:
我已经决定,实际问题的最佳解决方案是保留原始 JSON 结构并具有嵌套的用户类型:
data User = User { image :: Maybe Image }
data Image = Image { url :: Text }
这完全解决了我的问题,并使 API 与原始来源更加兼容。
但是,仅出于理论目的,很高兴看到原始问题是如何解决的。
我能够根据你的 >>= maybe (return Nothing) (.:? key)
模式制作一个相对简单的组合器,这应该会大大简化你想做的事情:
(/?) :: FromJSON a => Parser (Maybe Object) -> Text -> Parser (Maybe a)
maybeParser /? key = maybeParser >>= maybe (return Nothing) (.:? key)
这可用于通过 JSON 文档将任意数量的级别链接在一起:
instance FromJSON User where
parseJSON (Object o) = User <$> o .:? "image" /? "url"
parseJSON _ = mzero
> decode "{\"image\": {\"url\": \"foobarbaz\"}}" :: Maybe User
Just (User {imgUrl = Just "foobarbaz"})
另一个例子:
data Test = Test (Maybe Int) deriving (Eq, Show)
instance FromJSON Test where
parseJSON (Object o) = Test <$> o .:? "foo" /? "bar" /? "baz" /? "qux"
parseJSON _ = mzero
> decode "{\"foo\": {\"bar\": {\"baz\": {\"qux\": 123}}}}" :: Maybe Test
Just (Test (Just 123))
这可能不是您要找的东西,但我认为它可以解决您眼前的问题。考虑到它是一个复杂度非常低的 1 行函数,它对我来说似乎很惯用。我不认为在这种情况下真的需要更高层次的抽象。
我被指出了一个很好的解决方案
首先,这是我们可以做到的。
parseJSON (Object o) = User . join <$> (traverse (.:? "url") =<< (o .:? "image"))
在这里,我们得到 Parser (Maybe Object)
并将其传递给下一个与 Maybe Object
一起使用的单子操作。在 traverse
的帮助下,如果它是 Just,我们将执行该操作。结果我们得到 Parser (Maybe (Maybe Object)). What's left is to
jointhat result and get
Parser (Maybe Object)`.
不过,最好让它更易于使用。我将从@bheklilr 的回答中获取此运算符并将其应用于此解决方案。
-- The type can be much more generic, but for simplicity I would keep it in domain of the problem
(.:?>) :: FromJSON a => Parser (Maybe Object) -> Text -> Parser (Maybe a)
maybeParser .:?> key = fmap join . traverse (.:? key) =<< maybeParser
之后我们可以使用该运算符来解析可选字段的长链。
getImgUrl :: A.Object -> Parser (Maybe Text)
getImgUrl o = o .:? "image" .:?> "url" .:?> "foo" .:?> "bar"
从实用的角度来看,这个解决方案并不比@bheklilr 的解决方案和我最初的 'naive' 代码示例有用多少。但是,我更喜欢它,因为它不是在 Just/Nothing
上匹配,而是可以转换许多其他类型(例如 Either
)
这是代表用户的 JSON 对象的一部分:
{ "image": { "url": "http://example.com" } }
我需要将其解析为 User
类型:
data User = User { imgUrl :: Maybe Text }
天真的解决方案:
parseJSON (Object o) = User <$> getImgUrl o
where getImgUrl o = (o .:? "image") >>= maybe (return Nothing) (.:? "url")
但这并不比这些连锁店好多少:
case f m1 of
Nothing -> Nothing
Just m2 -> case f2 m2 of
Nothing -> Nothing
Just m3 -> case f3 m3 ....
经常在 'Why do you need a Monad' 解释中得到证明
因此,我需要编写看起来像 (.:? "url") :: Parser (Maybe a)
我试图用 comp
函数描述该组合:
getImgUrl :: Object -> Parser (Maybe Text)
getImgUrl o = o .:? "image" >>= comp (o .:? "url")
comp :: (Monad m) => (a -> m (Maybe b)) -> Maybe a -> m (Maybe b)
comp p Nothing = return Nothing
comp p (Just o) = p o
闻起来像 Functor,但 fmap
对我没有帮助。
然后我决定,那篇作文一定要写下去:
getImgUrl :: Object -> Parser (Maybe Text)
getImgUrl = comp2 (.:? "image") (.:? "url") o
-- Maybe should be changed to a matching typeclass
comp2 :: (Monad m) => (a -> m (Maybe b)) -> (b -> m (Maybe c)) -> a -> m (Maybe c)
comp2 = undefined
Hoogle 搜索对我没有帮助,但浏览 Control.Monad
文档给了我 Kliesli 组合,我没有经验。我看到一些相似之处:
(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
comp2 :: Monad m => (a -> m (f b)) -> (b -> m (f c)) -> a -> m (f c)
不同的是合成时Maybe
应该是'unwrapped'.
看来我已经接近解决方案了,但仍然找不到。请给我一些见解。
[更新]: 我已经决定,实际问题的最佳解决方案是保留原始 JSON 结构并具有嵌套的用户类型:
data User = User { image :: Maybe Image }
data Image = Image { url :: Text }
这完全解决了我的问题,并使 API 与原始来源更加兼容。
但是,仅出于理论目的,很高兴看到原始问题是如何解决的。
我能够根据你的 >>= maybe (return Nothing) (.:? key)
模式制作一个相对简单的组合器,这应该会大大简化你想做的事情:
(/?) :: FromJSON a => Parser (Maybe Object) -> Text -> Parser (Maybe a)
maybeParser /? key = maybeParser >>= maybe (return Nothing) (.:? key)
这可用于通过 JSON 文档将任意数量的级别链接在一起:
instance FromJSON User where
parseJSON (Object o) = User <$> o .:? "image" /? "url"
parseJSON _ = mzero
> decode "{\"image\": {\"url\": \"foobarbaz\"}}" :: Maybe User
Just (User {imgUrl = Just "foobarbaz"})
另一个例子:
data Test = Test (Maybe Int) deriving (Eq, Show)
instance FromJSON Test where
parseJSON (Object o) = Test <$> o .:? "foo" /? "bar" /? "baz" /? "qux"
parseJSON _ = mzero
> decode "{\"foo\": {\"bar\": {\"baz\": {\"qux\": 123}}}}" :: Maybe Test
Just (Test (Just 123))
这可能不是您要找的东西,但我认为它可以解决您眼前的问题。考虑到它是一个复杂度非常低的 1 行函数,它对我来说似乎很惯用。我不认为在这种情况下真的需要更高层次的抽象。
我被指出了一个很好的解决方案
首先,这是我们可以做到的。
parseJSON (Object o) = User . join <$> (traverse (.:? "url") =<< (o .:? "image"))
在这里,我们得到 Parser (Maybe Object)
并将其传递给下一个与 Maybe Object
一起使用的单子操作。在 traverse
的帮助下,如果它是 Just,我们将执行该操作。结果我们得到 Parser (Maybe (Maybe Object)). What's left is to
jointhat result and get
Parser (Maybe Object)`.
不过,最好让它更易于使用。我将从@bheklilr 的回答中获取此运算符并将其应用于此解决方案。
-- The type can be much more generic, but for simplicity I would keep it in domain of the problem
(.:?>) :: FromJSON a => Parser (Maybe Object) -> Text -> Parser (Maybe a)
maybeParser .:?> key = fmap join . traverse (.:? key) =<< maybeParser
之后我们可以使用该运算符来解析可选字段的长链。
getImgUrl :: A.Object -> Parser (Maybe Text)
getImgUrl o = o .:? "image" .:?> "url" .:?> "foo" .:?> "bar"
从实用的角度来看,这个解决方案并不比@bheklilr 的解决方案和我最初的 'naive' 代码示例有用多少。但是,我更喜欢它,因为它不是在 Just/Nothing
上匹配,而是可以转换许多其他类型(例如 Either
)