Question

对于Haskell来说，我还比较陌生，现在我正试图加深了解并试图适应不同的流行图书馆。

现在我正在尝试“ aeson”。

我想做的是解析来自https://www.alphavantage.co/query?function=GLOBAL_QUOTE&symbol=MSFT&apikey=demo的MSFT报价请求

这就是它的样子

{
    "Global Quote": {
        "01. symbol": "MSFT",
        "02. open": "105.3500",
        "03. high": "108.2400",
        "04. low": "105.2700",
        "05. price": "107.6000",
        "06. volume": "23308066",
        "07. latest trading day": "2018-10-11",
        "08. previous close": "106.1600",
        "09. change": "1.4400",
        "10. change percent": "1.3564%"
    }
}

这是我到目前为止所得到的

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

import           Data.Aeson
import qualified Data.ByteString.Lazy as B
import           GHC.Exts
import           GHC.Generics
import           Network.HTTP
import           Network.URI

jsonURL :: String
jsonURL = "http://www.alphavantage.co/query?function=GLOBAL_QUOTE&symbol=MSFT&apikey=demo"

getRequest_ :: HStream ty => String -> Request ty
getRequest_ s = let Just u = parseURI s in defaultGETRequest_ u

jsonReq = getRequest_ jsonURL

data Quote = Quote {quote         :: String,
                    symbol        :: String,
                    open          :: Float,
                    high          :: Float,
                    low           :: Float,
                    price         :: Float,
                    volume        :: Float,
                    ltd           :: String,
                    previousClose :: Float,
                    change        :: Float,
                    changePerct   :: Float
                   } deriving (Show, Generic)

instance FromJSON Quote
instance ToJSON Quote


main :: IO ()
main = do
  d <- simpleHTTP jsonReq
  body <- getResponseBody d
  print (decode body :: Maybe Quote)

我在做什么错了？

编辑：答案中的固定版本。

Answer 1

首先，Aeson不是对于初学者来说最简单的库。当然，还有更多困难的问题，但是前提是您已经对语言有了很多了解。首先，您没有选择“最简单的任务”。我知道这可能令人惊讶，您可能会认为解析JSON应该很简单，但是使用强类型保证来解析JSON实际上并不是那么简单。

但是我可以告诉您一些帮助：

首先，使用eitherDecode而不是decode：您会收到一条错误消息，而不是简单的Nothing，这将对您有所帮助。
通过Generic派生很整齐，而且通常可以节省时间，但这也不是魔术。对象键的名称和数据类型字段的名称必须完全匹配。可悲的是，这里不是这种情况，由于haskell语法，您无法像对象的键一样命名字段。最好的解决方案是手动实现FromJSON（请参见下面的推荐链接）。查看通用FromJSON的“期望值”的一个好方法是也派生ToJSON，创建一个虚拟Quote并查看encode的结果。
您的第一个字段（quote）不是对象本身的键，而是该对象的名称。因此，您就有了动态键（这里是“全局报价”）。再一次，这通常是您要手动编写FromJSON实例的情况。

我建议您阅读Aeson上这本著名的tutorial written by Artyom Kazak。这将极大地帮助您，并且可能是我能提供的最佳建议。

对于您的手动实例，假设它恰好是您要解析的文档，并且只有“全局报价”要处理，那么它看起来或多或少是这样的：

instance ToJSON Quote where
  parseJSON = withObject "Document" $
    \d -> do
        glob <- d .: "Global Quote"
        withObject "Quote" v (\gq ->
          Quote <$> gq .: "01. symbol"
                <*> pure "Global Quote"
                <*> gq .: "02. open"
                <*> gq .: "03. high"
          -- ... and so on
         ) v

（这不是最漂亮的方法，也不是最好的方法，但这应该是一种可能的方法。）

还要注意，正如一位敏锐的评论者所写，字段的类型并不总是与示例JSON文档的类型一致。 “ volume”是一个Int（字节有限的整数），可能是一个Integer（“数学”整数，没有限制），但不是Float。您的“ ltd”可以解析为字符串-但它可能应该是一个日期（Day中的Data.Time是首选-它已经有一个FromJSON实例，因此应该按原样解析）。更改百分比很可能无法像Float那样解析，您需要为此类型编写一个专用的解析器（并确定如何存储它-Ratio是一个潜在的解决方案）。

Answer 2

@Raveline及其上面的答案为我指明了正确的方向。我能够解决所有这些问题，这是最终产品！

{-# LANGUAGE DeriveGeneric     #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards   #-}

module Test where

import           Data.Aeson
import qualified Data.ByteString.Lazy as B
import           GHC.Exts
import           GHC.Generics
import           Network.HTTP.Conduit (simpleHttp)

jsonURL :: String
jsonURL = "https://www.alphavantage.co/query?function=GLOBAL_QUOTE&symbol=MSFT&apikey=demo"

getJSON :: IO B.ByteString
getJSON = simpleHttp jsonURL

data Quote = Quote {
                   symbol        :: String,
                   open          :: String,
                   high          :: String,
                   low           :: String,
                   price         :: String,
                   volume        :: String,
                   ltd           :: String,
                   previousClose :: String,
                   change        :: String,
                   changePercent :: String
                   } deriving (Show, Generic)


instance FromJSON Quote where
  parseJSON = withObject "Global Quote" $
    \o -> do
      globalQuote   <- o           .: "Global Quote"
      symbol        <- globalQuote .: "01. symbol"
      open          <- globalQuote .: "02. open"
      high          <- globalQuote .: "03. high"
      low           <- globalQuote .: "04. low"
      price         <- globalQuote .: "05. price"
      volume        <- globalQuote .: "06. volume"
      ltd           <- globalQuote .: "07. latest trading day"
      previousClose <- globalQuote .: "08. previous close"
      change        <- globalQuote .: "09. change"
      changePercent <- globalQuote .: "10. change percent"
      return Quote {..}


main :: IO ()
main = do
  d <- (eitherDecode <$> getJSON) :: IO (Either String Quote)
  case d of
    Left e   -> print e
    Right qt -> print (read (price qt) :: Float)

Haskell-Aeson：尝试解码JSON URL Req时获取“无”

2 个答案: