Text.HJson.Query

Documentation

type Jsons = [Json]

type JFilter = Json -> Jsons

jEmpty :: Json

create empty JSON object

jMerge :: Json -> Json -> Json

merge two JSON Objects

jMergeRec :: Json -> Json -> Json

recursive merge two JSON Objects

jMerges :: [Json] -> Json

merge list JSON Objects

jMergesRec :: [Json] -> Json

recursive merge lists JSON Objects

Example:

 import Text.HJson  hiding (toString)
 import Text.HJson.Query
 import Text.HJson.Pretty
 
 --  Parse JSON
 jParse :: String -> Json
 jParse jstr = case (fromString  jstr) of
     Left l  -> error l
     Right json -> json
 
 j0 = jParse "{}"
 j1 = jParse "{\"Europa\": {\"Ukraine\": [\"Kiyv\", \"Gitomir\", \"Lviv\"]}}"
 j2 = jParse "{\"Asia\": {\"Japan\": [\"Tokyo\"]}}"
 j3 = jParse "{\"Europa\": {\"UnitedKingdom\": [\"London\", \"Glasgow\"]}}"
 j4 = jParse "{\"Europa\": {\"Germany\": [\"Berlin\", \"Bonn\"]}}"
 j5 = jParse "{\"Africa\": {}}"
 j6 = jParse"{\"America\": {\"USA\": [], \"Canada\": [\"Toronto\"]}}"
 j7 = jParse "{\"Australia\": [\"Melburn\", \"Adelaida\"]}"
 merg = jMergesRec [j0, j1, j2, j3, j4, j5, j6, j7]
 ex0 = putStrLn $ toString "   " merg

Result:

{
   "Africa": {
   },
   "America": {
      "Canada": ["Toronto"],
      "USA": []
   },
   "Asia": {
      "Japan": ["Tokyo"]
   },
   "Australia": ["Melburn", "Adelaida"],
   "Europa": {
      "Germany": ["Berlin", "Bonn"],
      "Ukraine": ["Kiyv", "Gitomir", "Lviv"],
      "UnitedKingdom": ["London", "Glasgow"]
   }
}

isObj :: JFilter

filter JSON objects

isArr :: JFilter

filter JSON arrays Example

isStr :: JFilter

filter JSON strings

isNum :: JFilter

filter JSON numbers

isBool :: JFilter

filter JSON Bool

isNull :: JFilter

filter JSON null

isPrimitive :: JFilter

filter primitive types

getFromKey :: String -> JFilter

get elements from object with key

getFromKeys :: [String] -> JFilter

get elements from object with keys

Example:

 pprint js = mapM_ putStrLn $ map (toString "   ") js --pretty print 

 query1 = getFromKeys ["Europa", "America", "Africa"] 
 json1 = query1 merg 
 ex1 = pprint json1

Result:

 {
    "Germany": ["Berlin", "Bonn"],
    "Ukraine": ["Kiyv", "Gitomir", "Lviv"],
    "UnitedKingdom": ["London", "Glasgow"]
 }
 {
    "Canada": ["Toronto"],
    "USA": []
 }
 {
 
 }

getFromObj :: JFilter

get all elements from object

getFromArr :: JFilter

get all elements from array

getFromIndex :: Int -> JFilter

get element from array with index

getFromIndexes :: [Int] -> JFilter

get elements from array with indexes

getChildern :: JFilter

get all elements from object and array

(>>>) :: JFilter -> JFilter -> JFilter

filter combinators

Example:

 query2 = query1 >>> getFromObj 
 json2 = query2 merg
 ex2 = pprint json2

Result:

 ["Berlin", "Bonn"]
 ["Kiyv", "Gitomir", "Lviv"]
 ["London", "Glasgow"]
 ["Toronto"]
 []

(<+>) :: JFilter -> JFilter -> JFilter

filter combinators

orElse :: JFilter -> JFilter -> JFilter

filter combinators

when :: JFilter -> JFilter -> JFilter

filter combinators

guards :: JFilter -> JFilter -> JFilter

filter combinators

deepObj :: JFilter -> JFilter

tree traversal filter for object

deepArr :: JFilter -> JFilter

tree traversal filter for array

deep :: JFilter -> JFilter

tree traversal filter for objects and arrays

Example:

 -- Qwery:  All city Europa, America, Australia and Africa
 -- q31, q32, q33 is equal
 
 q31 = getFromKeys ["Europa", "America", "Africa", "Australia"] 
   >>> (getFromArr `orElse`  getFromObj)
   >>> (isStr `orElse` getFromArr)
 
 q32 = getFromKeys ["Europa", "America", "Africa", "Australia"] 
   >>> (getFromObj `when` isObj)
   >>> getFromArr
 
 q33 = getFromKeys ["Europa", "America", "Africa", "Australia"] 
   >>> 
 deep getFromArr

See also: www.haskell.org/haskellwiki/HXT |

debug :: JFilter -> String -> String

pretty print query from JSON string

 debug (deep isPrimitive) "[1, [false, true, [null]]]" == "[1, false, true, null]"