xr6$      !"#None <$%&&$%&NoneC'()*+,-./01234'()*+,-./01234 '()*+,-./01234None5)Public interface for parsing JSON tokens.6vfound element, continuation, actual parsing view - so that we can report the unparsed data when the parsing finishes.57689:;<=>?@AB 57689:;<=>?@A57689:;<=>?@ABNoneVC*Header for the C routing for batch parsingDLimit for maximum size of a number; fail if larger number is found this is needed to make this constant-space, otherwise we would eat all memory just memoizing the number. The lexer fails if larger number is encountered.EBParse number from bytestring to Scientific using JSON syntax rulesFParse particular resultG&Estimate number of elements in a chunkHIJKLMCNOPQRSTUVWXYDZ[\]^EFG_`a&`HIJKLMCNOPQRSTUVWXYDZ[\]^EFG_`a BSD-stylepalkovsky.ondrej@gmail.com experimentalportableNoneF1>Result of parsing. Contains continuations to continue parsing.Returns a value from a parser.+Parser needs more data to continue parsing."Parsing failed, error is reported.,Parsing finished, unparsed data is returned.A representation of the parser.bPrivate parsing resultc#Limit for the size of an object keyd.Yield list of results, finish with last actionMatch items from the first parser, if none is matched, return items from the second parser. Constant-space if second parser returns constant number of items. $ is implemented using this operator. M>>> let json = "[{\"key1\": [1,2], \"key2\": [5,6], \"key3\": [8,9]}]" >>> let parser = arrayOf $ "key1" .: (arrayOf value) >^> "key2" .: (arrayOf value) >>> parseByteString parser json :: [Int] [1,2] >>> let parser = arrayOf $ "key-non" .: (arrayOf value) >^> "key2" .: (arrayOf value) >>> parseByteString parser json :: [Int] [5,6]Match all items of an array.eGenerate start/end objects when an element is found, in between run a parser. The inner parser is not run if an array is not found.Generate start/end values when an object is found, in between run a parser. The inner parser is not run if an array is not found. Generate start/end values when an array is found, in between run a parser. The inner parser is not run if an array is not found. >>> let test = "[[1,2,3],true,[],false,{\"key\":1}]" :: ByteString >>> parseByteString (arrayOf (arrayFound 10 20 (1 .! integer))) test :: [Int] [10,2,20,10,20] Match nith item in an array. 1Match all items of an array, add index to output.fUGo through an object; if once is True, yield only first success, then ignore the restg:Helper function to deduplicate TokMoreData/FokFailed logic Match all key-value pairs of an object, return them as a tuple. If the source object defines same key multiple times, all values are matched. Match all key-value pairs of an object, return only values. If the source object defines same key multiple times, all values are matched. Keys are ignored.Match only specific key of an object. This function will return only the first matched value in an object even if the source JSON defines the key multiple times (in violation of the specification).h1Parses underlying values and generates a AE.ValueipConvert a strict aeson value (no object/array) to a value. Non-matching type is ignored and not parsed (unlike )j:Match a possibly bounded string roughly limited by a limit+Parse string value, skip parsing otherwise.Stops parsing string after the limit is reached. The string will not be matched if it exceeds the size. The size is the size of escaped string including escape characters.*Parse number, return in scientific format.#Parse to bounded integer type (not kX). If you are using integer numbers, use this parser. It skips the conversion JSON -> l -> m and uses an m directly.Parse to float/double.)Parse bool, skip if the type is not bool.Match a null value.*Parses a field with a possible null value.Match FromJSON, value. Calls parseJSON on the parsed value. >>> let json = "[{\"key1\": [1,2], \"key2\": [5,6]}]" >>> parseByteString (arrayOf value) json :: [Value] [Object fromList [("key2",Array (fromList [Number 5.0,Number 6.0])),("key1",Array (fromList [Number 1.0,Number 2.0]))]]Take maximum n matching items. X>>> parseByteString (takeI 3 $ arrayOf integer) "[1,2,3,4,5,6,7,8,9,0]" :: [Int] [1,2,3]n&Skip rest of string + call next parsero5Skip value; cheat to avoid parsing and make it faster'Gather matches and return them as list. 9>>> let json = "[{\"keys\":[1,2], \"values\":[5,6]}, {\"keys\":[9,8], \"values\":[7,6]}]" >>> let parser = arrayOf $ (,) <$> toList ("keys" .: arrayOf integer) <*> toList ("values" .: arrayOf integer) >>> parseByteString parser json :: [([Int], [Int])] [([1,2],[5,6]),([9,8],[7,6])])Let only items matching a condition pass. _>>> parseByteString (filterI (>5) $ arrayOf integer) "[1,2,3,4,5,6,7,8,9,0]" :: [Int] [6,7,8,9]}A back-door for lifting of possibly failing actions. If an action fails with Left value, convert it into failure of parsing Synonym for  . Matches key in an object. The  operators can be chained. z>>> let json = "{\"key1\": {\"nested-key\": 3}}" >>> parseByteString ("key1" .: "nested-key" .: integer) json :: [Int] [3]Returns p@ if value is null or does not exist or match. Otherwise returns q value. 2key .:? val = Just <$> key .: val >^> pure NothingMReturn default value if the parsers on the left hand didn't produce a result. p .| defval = p >^> pure defvalMThe operator works on complete left side, the following statements are equal: zRecord <$> "key1" .: "nested-key" .: value .| defaultValue Record <$> (("key1" .: "nested-key" .: value) .| defaultValue) Synonym for  . Matches n-th item in array. c>>> parseByteString (arrayOf (1 .! bool)) "[ [1,true,null], [2,false], [3]]" :: [Bool] [True,False] (Run streaming parser with initial input.!*Run streaming parser, immediately returns ."aParse a bytestring, generate lazy list of parsed values. If an error occurs, throws an exception. @parseByteString (arrayOf integer) "[1,2,3,4]" :: [Int] [1,2,3,4] iparseByteString (arrayOf ("name" .: string)) "[{\"name\":\"KIWI\"}, {\"name\":\"BIRD\"}]" ["KIWI","BIRD"]#fParse a lazy bytestring, generate lazy list of parsed values. If an error occurs, throws an exception.rsG will run both parsers in parallel yielding from both as the data comes json: [{"key1": [1,2], "key2": [5,6], "key3": [8,9]}] >>> let parser = arrayOf $ "key1" .: (arrayOf value) <|> "key2" .: (arrayOf value) >>> parseByteString parser json :: [Int] [1,2,5,6]tu will run both parsers in parallel and combine results. It behaves as a list functor (produces all combinations), but the typical use is: JSON: text = [{"name": "John", "age": 20}, {"age": 30, "name": "Frank"} ] >>> let parser = arrayOf $ (,) <$> "name" .: string <*> "age" .: integer >>> parseByteString parser text :: [(Text,Int)] [("John",20),("Frank",30)];vwbxyz{cd|e fg hijno} !"#rt~$  !"#$! "#   1vwbxyz{cd|e fg hijno} !"#rt~      !"#$%&'()*+,--./0123456789:;<=>?@ABCDEFGHIJKLMMNOPQHRSTUVWXYYZ[\]^_`abcdefghijklmnopqrstuvwxyzxy{|xy}~xy jsons_Dexgck4XIeI4YrwTMKWJkgData.JsonStream.ParserData.JsonStream.UnescapeData.JsonStream.CLexTypeData.JsonStream.TokenParserData.JsonStream.CLexer ParseOutput ParseYield ParseNeedData ParseFailed ParseDoneParser>^>arrayOf objectFound arrayFoundarrayWithIndexOfindexedArrayOf objectItems objectValues objectWithKeystring safeStringnumberintegerrealbooljNullnullablevaluetakeItoListfilterImapWithFailure.:.:?.|.! runParser' runParserparseByteStringparseLazyByteString c_js_decode unescapeText' unescapeText LexResultType resNumber resStringresTrueresFalseresNull resOpenBrace resCloseBraceresOpenBracketresCloseBracketresStringPartialresNumberPartialresNumberSmall TokenResult PartialResult TokMoreData TokFailedElement ArrayBeginArrayEnd ObjectBegin ObjectEnd StringContent StringEndJValueJInteger$fShowTokenResultHeadernumberDigitLimit parseNumber parseResultsestResultLimitTempData tmpBuffer tmpHeadertmpError tmpNumbershdrCurrentState hdrStateData hdrStateSata2 hdrPosition hdrLength hdrResultNumhdrResultLimit ResultPtrunresPtrlexJson defHeaderpeekResultFieldpeekResultTypecallLexsubstr getNextResult tokenParser$fStorableHeader ParseResultobjectKeyStringLimit yieldResults elemFoundobject'moreDataaeValuejvalue longString integer-gmpGHC.Integer.TypeIntegerscien_1UL7hJs0dy8BYuo3rFsz84Data.Scientific Scientificghc-prim GHC.TypesIntignoreStrRestThen ignoreValbaseGHC.BaseNothingJust$fAlternativeParser<|>$fApplicativeParser<*> callParseMoreDataFailedDoneYieldarray' ignoreVal'$fFunctorParser$fFunctorParseResult