2

这是代表用户的 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 ....

这经常在“你为什么需要一个 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

闻起来像仿函数，但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应该“展开”。

似乎我接近解决方案，但仍然找不到。请给我一些见解。

[更新]： 我决定实际问题的最佳解决方案是保留原始 JSON 结构并具有嵌套的用户类型：

data User = User { image :: Maybe Image }
data Image = Image { url :: Text }

这完全消除了我的问题，并使 API 与原始源代码更兼容。

但是，仅出于理论目的，很高兴看到如何解决原始问题。

4

2 回答 2

3

我被指出了一个很好的解决方案

首先，我们可以这样做。

parseJSON (Object o) = User . join <$> (traverse (.:? "url") =<< (o .:? "image"))

在这里，我们获取Parser (Maybe Object)并将其传递给下一个单子动作，该动作与Maybe Object. 在我们的帮助下，traverse如果它是 Just。结果我们得到Parser (Maybe (Maybe Object)). What's left is tojoin that result and getParser (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 的解决方案和我最初的“天真”代码示例有用多少。但是，我更喜欢它，因为Just/Nothing它可以转换许多其他类型（例如Either） ，而不是匹配它

于 2015-02-07T18:08:15.130 回答
2

我能够根据您的>>= 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))

这可能不是您正在寻找的，但我认为它可以解决您的直接问题。考虑到它是一个复杂度非常低的单行函数，这对我来说似乎很惯用。我不认为在这种情况下真的需要更高级别的抽象。

于 2015-02-06T15:50:49.567 回答