śĪ!Ą~ŗ`      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_None 8=>?HV? constructA subclass of MonadFixC for monads that can fix a function that handles higher-kinded data constructThis specialized form of ` can be used inside mfix. constructA subclass of  2 for parsers that can switch the input stream type constructLConverts a parser accepting one input stream type to another. The functions forth and backB must be inverses of each other and they must distribute through a: f (s1 <> s2) == f s1 <> f s2 constructGConverts a parser accepting one input stream type to another just like ,, except the argument functions can return Nothing" to indicate they need more input. construct)Methods for parsing textual monoid inputs constructSpecialization of ¦ on textual inputs, accepting an input character only if it satisfies the given predicate, and returning the input atom that represents the character. Equivalent to fmap singleton . Char.satisfy  constructCA parser that succeeds exactly when satisfy doesn't, equivalent to notFollowedBy . Char.satisfy  constructStateful scanner like , but specialized for b inputs.  constructSpecialization of  on bu inputs, accepting the longest sequence of input characters that match the given predicate; an optimized version of &fmap fromString . many . Char.satisfy.NoteL: Because this parser does not fail, do not use it with combinators such as manyh, because such parsers loop until a failure occurs. Careless use will thus result in an infinite loop.  constructSpecialization of  on bu inputs, accepting the longest sequence of input characters that match the given predicate; an optimized version of &fmap fromString . some . Char.satisfy.  construct+Methods for parsing factorial monoid inputs constructNAlways sucessful parser that returns the remaining input without consuming it. construct}A parser that accepts any single atomic prefix of the input stream. > anyToken == satisfy (const True) > anyToken == take 1 construct>A parser that accepts exactly the given number of input atoms. constructMA parser that accepts an input atom only if it satisfies the given predicate. constructDA parser that succeeds exactly when satisfy doesn't, equivalent to c  . satisfy construct»A stateful scanner. The predicate modifies a state argument, and each transformed state is passed to successive invocations of the predicate on each token of the input until one returns d or the input ends.TThis parser does not fail. It will return an empty string if the predicate returns d on the first character.NoteL: Because this parser does not fail, do not use it with combinators such as manyh, because such parsers loop until a failure occurs. Careless use will thus result in an infinite loop. constructAA parser that consumes and returns the given prefix of the input. construct‡A parser accepting the longest sequence of input atoms that match the given predicate; an optimized version of 'concatMany . satisfy'.NoteL: Because this parser does not fail, do not use it with combinators such as manyh, because such parsers loop until a failure occurs. Careless use will thus result in an infinite loop. construct‘A parser accepting the longest non-empty sequence of input atoms that match the given predicate; an optimized version of 'concatSome . satisfy'. construct'Zero or more argument occurrences like many%, with concatenated monoidal results. construct Subclass of e1 that carries an error message in case of failure constructEquivalent to f˜ except it takes an error message it may carry or drop on the floor. The grammatical form of the argument be a noun representing the unexpected value. construct$Sets or modifies the expected value.     SafeGŠ1 construct/The central type. The four type parameters are:m) is the type of the parser for the formatnG is the container type for the serialized form of the value, typically Identity unless something  Alternative is called for.s0 is the type of the serialized value, typically  ByteStringa( is the type of the value in the programThe parse and  serializew fields can be used to perform the two sides of the conversion between the in-memory and serialized form of the value.1g32None &'=>?SXµ‘&4 constructNA literal serialized form, such as a magic constant, corresponding to no value#testParse (literal "Hi") "Hi there"Right [(()," there")]5 constructjModifies the serialized form of the given format by padding it with the given template if it's any shorter=testParse (padded "----" $ takeCharsWhile isDigit) "12--3---"Right [("12","3---")];testSerialize (padded "----" $ takeCharsWhile isDigit) "12" Right "12--"6 construct Modifies the serialized form of the given format by padding it with the given template. The serialized form has to be shorter than the template before padding.7 constructKFormat whose in-memory value is a fixed-size prefix of the serialized valuetestParse (take 3) "12345"Right [("123","45")]testSerialize (take 3) "123" Right "123"testSerialize (take 3) "1234"9Left "expected a value of length 3, encountered \"1234\""8 construct„Format whose in-memory value is the longest prefix of the serialized value smallest parts of which all satisfy the given predicate.$testParse (takeWhile (> "b")) "abcd"Right [("","abcd")]$testParse (takeWhile (> "b")) "dcba"Right [("dc","ba")](testSerialize (takeWhile (> "b")) "dcba"/Left "expected takeWhile, encountered \"dcba\""&testSerialize (takeWhile (> "b")) "dc" Right "dc"$testSerialize (takeWhile (> "b")) ""Right ""9 constructŽFormat whose in-memory value is the longest non-empty prefix of the serialized value smallest parts of which all satisfy the given predicate.%testParse (takeWhile1 (> "b")) "abcd"Left "takeWhile1"%testSerialize (takeWhile1 (> "b")) "",Left "expected takeWhile1, encountered \"\""'testSerialize (takeWhile1 (> "b")) "dc" Right "dc": constructŽFormat whose in-memory value is the longest prefix of the serialized value that consists of characters which all satisfy the given predicate.(testParse (takeCharsWhile isDigit) "a12"Right [("","a12")](testParse (takeCharsWhile isDigit) "12a"Right [("12","a")],testSerialize (takeCharsWhile isDigit) "12a"3Left "expected takeCharsWhile, encountered \"12a\""+testSerialize (takeCharsWhile isDigit) "12" Right "12")testSerialize (takeCharsWhile isDigit) ""Right ""; construct˜Format whose in-memory value is the longest non-empty prefix of the serialized value that consists of characters which all satisfy the given predicate.)testParse (takeCharsWhile1 isDigit) "a12"&Left "takeCharsWhile1 encountered 'a'")testParse (takeCharsWhile1 isDigit) "12a"Right [("12","a")],testSerialize (takeCharsWhile1 isDigit) "12" Right "12"*testSerialize (takeCharsWhile1 isDigit) ""1Left "expected takeCharsWhile1, encountered \"\""< construct=A fixed expected value serialized through the argument format testParse (value char 'a') "bcd"Left "encountered 'b'" testParse (value char 'a') "abc"Right [((),"bc")]= constructRFilter the argument format so it only succeeds for values that pass the predicate.&testParse (satisfy isDigit char) "abc"Left "encountered 'a'"'testParse (satisfy isLetter char) "abc"Right [('a',"bc")]> construct1Converts a format for serialized streams of type s! so it works for streams of type t insteadHtestParse (mapSerialized ByteString.unpack ByteString.pack byte) [1,2,3]Right [(1,[2,3])]? construct1Converts a format for serialized streams of type s! so it works for streams of type t- instead. The argument functions may return NothingC to indicate they have insuficient input to perform the conversion.@ construct/Converts a format for in-memory values of type a so it works for values of type b instead.HtestParse (mapValue (read @Int) show $ takeCharsWhile1 isDigit) "012 34"Right [(12," 34")]?testSerialize (mapValue read show $ takeCharsWhile1 isDigit) 12 Right "12"A construct/Converts a format for in-memory values of type a so it works for values of type bM instead. The argument functions may signal conversion failure by returning Nothing.B construct(A trivial format for a single byte in a h(testParse byte (ByteString.pack [1,2,3])Right [(1,"\STX\ETX")]C construct'A trivial format for a single charactertestParse char "abc"Right [('a',"bc")]D construct>A quick way to format a value that already has an appropriate i instance4testParse (cereal @Word16) (ByteString.pack [1,2,3])Right [(258,"\ETX")]%testSerialize cereal (1025 :: Word16)Right "\EOT\SOH"E constructDSpecifying a formatter explicitly using the cereal getter and putterEtestParse (cereal' getWord16le putWord16le) (ByteString.pack [1,2,3])Right [(513,"\ETX")]F construct6Repeats the argument format the given number of times.6testParse (count 4 byte) (ByteString.pack [1,2,3,4,5])Right [([1,2,3,4],"\ENQ")](testSerialize (count 4 byte) [1,2,3,4,5];Left "expected a list of length 4, encountered [1,2,3,4,5]"&testSerialize (count 4 byte) [1,2,3,4]Right "\SOH\STX\ETX\EOT"G constructLConverts a record of field formats into a single format of the whole record.H constructcConverts a record of field formats into a single format of the whole record, a generalized form of G.I constructSame as the usual  except a 1 is no j.J constructSame as the usual k except a 1 is no j , let alone l.K constructSame as the usual m except a 1 is no j , let alone l.L constructSame as the usual n except a 1 is no j , let alone e.M construct5A discriminated or tagged choice between two formats.N constructSame as the usual o except a 1 is no j , let alone e.O constructLike N5 except with arbitrary default serialization for the Nothing value. -optional = optionWithDefault (literal mempty)P constructSame as the usual p except a 1 is no j , let alone e.Q constructSame as the usual q except a 1 is no j , let alone e.R construct—Represents any number of values formatted using the first argument, separated by the second format argumewnt in serialized form. Similar to the usual r combinator.EtestParse (takeCharsWhile isLetter `sepBy` literal ",") "foo,bar,baz"_Right [([],"foo,bar,baz"),(["foo"],",bar,baz"),(["foo","bar"],",baz"),(["foo","bar","baz"],"")]S construct@Combines two formats into a format for the pair of their values. testParse (pair char char) "abc"Right [(('a','b'),"c")]T constructƒCombines two formats, where the second format depends on the first value, into a format for the pair of their values. Similar to s except 1 is no j let alone t.8testParse (deppair char (\c-> satisfy (==c) char)) "abc"Left "encountered 'b'"8testParse (deppair char (\c-> satisfy (==c) char)) "aac"Right [(('a','a'),"c")]U constructSame as the usual f except a 1 is no j , let alone e.V construct(Name a format to improve error messages.8testParse (takeCharsWhile1 isDigit <?> "a number") "abc")Left "expected a number, encountered 'a'"<testSerialize (takeCharsWhile1 isDigit <?> "a number") "abc"-Left "expected a number, encountered \"abc\""W constructSame as the usual  except a 1 is no j , let alone t.X construct Attempts to 2s the given input with the format with a constrained type, returns either a failure message or a list of successes.Y construct"A less polymorphic wrapper around 3 useful for testing)132456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY)123IJKLMVUNOSTPQRFWGH>?@A=<564BCDE789:;XYI4J4K4L3V0None&'¹ÜZ constructThe list of bits[ construct$The primitive format of a single bit(testParse bit [True, False, False, True]!Right [(True,[False,False,True])]Z[\]^_Z[\]^_u       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkclmcdncdV9opqrstcducdKcdvcdLcdMcwOcdQcdRijScdxcdyz(construct-0.2.0.1-LdXOMTS046NBfKkggPbTjgConstruct.Classes ConstructConstruct.BitsConstruct.Internal Data.Functor<$Control.Monad.FixmfixErrorFixTraversable fixSequenceInputMappableParsingmapParserInputmapMaybeParserInputInputCharParsingsatisfyCharInputnotSatisfyChar scanCharstakeCharsWhiletakeCharsWhile1 InputParsing ParserInputgetInputanyTokentakesatisfy notSatisfyscanstring takeWhile takeWhile1 concatManyAlternativeFailfailure expectedName errorStringconcatExpected oxfordComma$fAlternativeFail[]$fAlternativeFailMaybe$fInputParsingParser$fInputParsingParser0$fInputParsingParser1$fInputParsingReadP$fInputCharParsingParser$fInputCharParsingParser0$fInputCharParsingParser1$fInputCharParsingReadP$fInputMappableParsingParser$fFixTraversableParser$fFixTraversableParser0$fAlternativeFailEither$fAlternativeEither$fSemigroupError $fEqError $fShowErrorFormatparse serializeliteralpaddedpadded1value mapSerializedmapMaybeSerializedmapValue mapMaybeValuebytecharcerealcereal'countrecord recordWith*><*<|><+>optionaloptionWithDefaultmanysomesepBypairdeppairempty testParse testSerializeBitsbitbigEndianBitsOfbigEndianBytesOflittleEndianBitsOflittleEndianBytesOf'rank2classes-1.4-5hc0wd9jotB8uNf3gOG4MvRank2traversebaseGHC.Base<>.monoid-subclasses-1.0.1-BXlHbVMcP39EHwX1MGqHEIData.Monoid.Textual TextualMonoid&parsers-0.12.10-IeFpKZXtg76331l1aj3DeFText.Parser.Combinators notFollowedBy GHC.MaybeNothing Alternativebytestring-0.10.8.2Data.ByteString.Internal ByteString%cereal-0.5.8.1-KRPM4Pfa6l3HK7sjbDz33xData.Serialize SerializeFunctor ApplicativeControl.Applicative>>=Monad