Haskell Json数据处理

json的基本类型为——string, numbers, Booleans以及null，定义json类型如下

-- file: Json.hs

module Json where

data JValue = JString String

           |  JNumber Double

           |  JBool Bool

           |  JNull 

           |  JObject [(String, JValue)]

           |  JArray [JValue]

              deriving(Eq, Ord, Show)

打印Json类型数据

-- file: PutJson.hs

module PutJson where

import Data.List (intercalate)

import Json

renderJValue :: JValue –> String

renderJValue (JString s) = show s

renderJValue (JNumber n) = show n

renderJValue (JBool True) = “true”

renderJValue (JBool False) = “false”

renderJValue JNull         = “null”

renderJValue (JObject o) = "{" ++ pairs o ++ "}"

    where pairs [] = ""

          pairs ps = intercalate "," (map renderPair ps)

          renderPair (k, v) = show k ++ ":" ++ renderJValue v

renderJValue (JArray a) = "[" ++ values a ++ "]"

    where values [] = ""

          values vs = intercalate "," (map renderJValue vs)

putJValue :: JValue –> IO()

putJValue v = putStrLn (renderJValue v)

最后编写调用文件

-- file: Main.hs

module Main where

main = putJValue (JObject [("foo", JNumber 1), ("bar", JBool False)])

在命令行中输入如下指令

ghc –o demo Json.hs PutJson.hs Main.hs

生成demo.exe，然后在命令行中输入demo，即可得到JValue的打印字符串。如果JValue的值结构非常复杂，则通过这种方法打印出来显得对人类不够友好。那么，如何友好的打印出来呢？

假设我们有一个模块Prettify，这个模块的API将JValue转换为Doc而不是上面的String，我们重写render函数如下，

-- file: PrettyJson.hs

renderJValue :: JValue –> Doc

renderJValue (JBool True)  = text “true”

renderJValue (JBool False) = text “false”

renderJValue JNull         = text “null”

renderJValue (JNumber num) = double num

renderJValue (JString str) = string str

其中，Doc类型，text，double和string函数由我们的Prettify模块实现。

先给出string函数的定义

-- file: PrettyJson.hs

string :: String –> Doc

string = enclose '"' '"' . hcat . map oneChar

这个定义中使用了自由点风格（自由点风格），本来函数是从左向右运算的，使用自由点风格后，等价于

-- file: PrettyJson.hs

string :: String –> Doc

string s = enclose '"' '"' (hcat (map oneChar s))                                          （1）

可以看出，使用这种风格，省去参数s，并将小括号替换为点号。这个定义中，出现了各种函数，现在来依次分解。enclose函数是在一个Doc对象的前面和后面分别附加字符，其定义如下

-- file: PrettyJson.hs

enclose :: Char –> Char –> Doc –> Doc

enclose left right x = char left <> x <> char right

char是一个函数，用于将一个Char字符类型转换为Doc类型，目前我们还不知道其方法体，先用undefined表示其方法体，这样， 签名如下，

-- file: PrettyJson.hs

char :: Char –> Doc

char c = undefined

<>是一个中缀函数，写在两个运算分量中间时，看作一个运算符，其运算优先级比作为函数的char底，故enclose函数方法体可以这么看，char函数将Char字符类型参数left和right转换为两个Doc类型参数，然后与另一个Doc类型参数 x 用两个 <> 运算符连接，容易知道，<>连接两个Doc类型参数，得到另一个Doc类型结果，签名如下，其实，这个<>运算符类似于String类型的(++)运算符，即连接两个Doc参数，生成一个新的Doc类型结果。

-- file: PrettyJson.hs

(<>) :: Doc –> Doc –> Doc

a <> b = undefined

我们再看（1），现在可以知道string函数的作用就是对(hcat (map oneChar s)) 这个Doc类型值两边添加双引号 (")，于是我们接着看hcat函数，这个函数类似于list的连接函数concat （注意跟 <> 的区别），签名如下

-- file: PrettyJson.hs

hcat :: [Doc]-> Doc

hcat xs = undefined

接下来，由于map函数是对列表s的每个元素应用oneChar函数，故我们只要看一下oneChar函数是干什么用的就可以了。由于s是一个String类型，故oneChar函数是将一个Char类型转为一个Doc类型，给出函数的详细定义如下，

-- file: PrettyJson.hs

oneChar :: Char –> Doc

oneChar c = case lookup c simpleEscapes of 

              Just r –> text r

              Nothing | mustEscape –> hexEscape c

                      | otherwise  ->  char c

    where mustEscape c = c < ' ' || c == '\x7f' || c > '\xff'

simpleEscapes :: [(Char, String)]

simpleEscapes = zipWith ch "\b\n\f\r\t\\\"/" "bnfrt\\\"/"

    where ch a b = (a, ['\\', b]

这段函数定义篇幅稍微有点大，我们一点一点来看，首先simpleEscapes是一个二元元组的列表，元组的第一项为一个简单转义字符（\b, \n, \f, \r, \t, \\, \", /)，第二项是将第一项表现出来，比如 '\b' ，表现为 "\\b" ,可以写一个测试如下

Prelude> :load PrettyJson.hs

Prelude> take 8 simpleEscapes

[('\b',"\\b"),('\n',"\\n"),('\f',"\\f"),('\r',"\\r"),('\t',"\\t"),('\\',"\\\\"),('"',"\\\""),('/',"\\/")]

lookup函数是检查字符c是否在simpleEscapes中某一元组的第一项，如果是，则返回这个转义字符的字符串表现形式，如果字符c不是简单的转义字符，则如果是其他需要转义的字符，对字符c应用hexEscape函数，否则，就是简单的字符，不需要转义，直接应用char函数将Char类型转为Doc类型。

还有一个函数hexEscape还未给出解析。我们直接给出定义如下

-- file: PrettyJson.hs

hexEscape :: Char –> Doc

hexEscape c | d < 0x10000 = smallHex d

            | otherwise   = astral (d – 0x10000)

    where d = ord c

根据字符c的ascii码值是否小于0x10000，对字符c的码值进行不同的处理。

-- file: PrettyJson.hs

smallHex :: Int –> Doc

smallHex x = text "\\u"

          <> text (replicate (4 – length h) ‘0’)

          <> text h

    where h = showHex x ""

其中，showHex函数来自Numeric库，需要在文件的开头import这个库。showHex函数的功能是以16进制打印一个数。replicate函数是将一个指定类型a重复n次，生成一个a类型的列表

replicate :: Int –> a –> [a]

根据hexEscape的定义，字符c的ascii码值（16进制）的长度不超过4位（根据guard表达式为d< 0x10000得到），故4 – length h 的范围为[0, 4]，smallHex函数的作用是这样打印参数x，先打印"\\u"， 然后x的16进制位数如果不足4位，补0使得满足4位，然后打印x的16进制值。

smallHex函数能打印的值最大不超过0xffff，而有效的unicode字符范围上限一直到0x10ffff，对 (0xffff, 0x10ffff) 的字符，应用 astral 函数，其定义给出如下

-- file: PrettyJson.hs

astral :: Int –> Doc

astral n = smallHex (a + 0xd800) <> smallHex (b + 0xdc00)

    where a = (n `shiftR` 10).&. 0x3ff

          b = n .&. 0x3ff

其中，shiftR是右移函数，(.&.)是按位与。我们看一下astral函数是如何处理参数n的，对于参数n，取其低10位作为b，取其第11位到第20位（次低10位）作为a，当然了，前面说到参数的范围为 (0xffff, 0x10ffff) ，值位数就是17位到20位，故 a 是高10位，b 是低10位。