!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnop q r s t u v w x y z { | } ~                     ! " # $%&'( ) * + , - . / 0 12345 6 7 8 9:;< = > ? @ A B CDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~             !"#$%&'()*+!,!-!.!/!0!1!2!3!4!5!6!7!8!9!:!;!<!=">"?"@#A#B$C$D$E$F$G$H$I$J$K$L%M%N%O%PQRSTUVWXYZ[\]^_`abcdefghijklmnopqrs&t&u&v&w&x&y&z&{&|&}&~&&&&'''''''''''''''''''''((((((((((((()))))))))))**************************++,,,,,,,,,,,,,c BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone*1FT4J - BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableSafe*1FT6JHGI.None*1FT6JKJK/ BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone*1FT8LElement type of a collectionL0 BSD-style Foundation experimentalportableNone *01<CFKTVG M&A set of methods for ordered colectionNCheck if a collection is emptyO,Length of a collection (number of Element c)P1Check if a collection contains a specific elementThis is the inverse of Q.Q;Check if a collection does *not* contain a specific elementThis is the inverse of P.R'Get the maximum element of a collectionS'Get the minimum element of a collectionTADetermine is any elements of the collection satisfy the predicateUADetermine is all elements of the collection satisfy the predicateV1Smart constructor to create a NonEmpty collectionsIf the collection is empty, then Nothing is returned Otherwise, the collection is wrapped in the NonEmpty propertyWsame as VZ, but assume that the collection is non empty, and return an asynchronous error if it is.Y:Return True if all the elements in the collection are TrueZ=Return True if at least one element in the collection is TrueMNORSTUPQVWXYZMNOPQRSTU1 BSD-style foundation experimentalportableNone*1FTP[-Collections that can be built chunk by chunk.Use the  instance of  to chain ^ operations and feed it into _:HrunST $ build 32 (append 'a' >> append 'b' >> append 'c') :: UArray Char"abc"\>Mutable collection type used for incrementally writing chunks.])Unit of the smallest step possible in an ^ operation.qA UTF-8 character can have a size between 1 and 4 bytes, so this should be defined as 1 byte for collections of (._CountOf of a chunk`CountOf of a chunk[\]_^`[\]^_2 BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone*1FTbaIFold1's. Like folds, but they assume to operate on a NonEmpty collection.bLeft associative strict fold.cRight associative lazy fold.d/Give the ability to fold a collection on itselfe%Left-associative fold of a structure.In the case of lists, foldl, when applied to a binary operator, a starting value (typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right: Efoldl f z [x1, x2, ..., xn] == (...((z `f` x1) `f` x2) `f`...) `f` xnNote that to produce the outermost application of the operator the entire input list must be traversed. This means that foldl' will diverge if given an infinite list.#Note that Foundation only provides e, a strict version of foldl, because the lazy version is seldom useful.MLeft-associative fold of a structure with strict application of the operator.f&Right-associative fold of a structure. @foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...)gSRight-associative fold of a structure, but with strict application of the operator.abcdfegabcdefg3 BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone *1;=FTeQh.Collection of elements that can indexed by inthjihij4None*17FTgkKA monomorphic functor that maps the inner values to values of the same typeklkll5 BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone *1;=FTi}m1Collection of things that can be looked up by Keymnopmnop6 BSD-style*Nicolas Di Prima <nicolas@primetype.co.uk> experimentalportableNone*1FT qPFunctors representing data structures that can be traversed from left to right.Mostly like base's  Traversable! but applied to collections only.rMap each element of a structure to an action, evaluate these actions from left to right, and collect the results. For a version that ignores the results see 7.sEvaluate each actions of the given collections, from left to right, and collect the results. For a version that ignores the results, see 8tMap each element of the collection to an action, evaluate these actions from left to right, and collect the results. For a version that ignores the results see 9.uEvaluate each actions of the given collections, from left to right, and collect the results. For a version that ignores the results, see :vMap each element of a collection to an action, evaluate these actions from left to right, and ignore the results. For a version that doesn't ignore the results see ;wEvaluate each action in the collection from left to right, and ignore the results. For a version that doesn't ignore the results see <l. sequenceA_ :: (Mappable col, Applicative f) => col (f a) -> f () sequenceA_ col = sequenceA col *> pure ()Map each element of a collection to a monadic action, evaluate these actions from left to right, and ignore the results. For a version that doesn't ignore the results see =.Evaluate each monadic action in the collection from left to right, and ignore the results. For a version that doesn't ignore the results see >.xx is tI with its arguments flipped. For a version that ignores the results see ?.yy is wP with its arguments flipped. For a version that doesn't ignore the results see @. qrtsuvwxyqrstuA BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone*1FTzjCollection of things that can be made mutable, modified and then freezed into an MutableFreezed collection z{|}~z {|}~ BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone*1FTD      !"#$%&'()*+BNone*1DFT, BSD-style Foundation experimentalportableNone*1FT!Print a string to standard output0Print a string with a newline to standard output+Get the arguments from the terminal commandMNYZYZNMC BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone*1FTT%-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQNone*1;FT/Method to support basic trigonometric functionsthe famous pi valuesinecosinetansine-1cosine-1 tangent-1hyperbolic sinehyperbolic cosinehyperbolic tangenthyperbolic sine-1hyperbolic cosine-1hyperbolic tangent-1 DNone *+1FTVMonad that can ensure cleanup actions are performed even in the case of exceptions, both synchronous and asynchronous. This usually excludes continuation-based monads.iA generalized version of the standard bracket function which allows distinguishing different exit cases.Monad that can catch exceptionMonad that can throw exception(Throw immediatity an exception. Only a 1 monad will be able to catch the exception using acquire some resourcecleanup, no exception thrown>cleanup, some exception thrown. The exception will be rethrown)inner action to perform with the resource None*1FTMESafe *+1FTLKFNone*+1FTBasic Transformer classGLift a computation from an inner monad to the current transformer monadGNone*1FTRIdentity TransformerRSRTSHNone*1FTN  $LK321RNone*1FNT{State TransformerUNone*+1FTReader TransformerVNone*+1FTWINone*1;FTTIEEE754 Floating Point BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone *1;=FTRound up, to the next integral.Also known as ceiling$Round down, to the previous integralAlso known as floorGTruncate to the closest integral to the fractional number closer to 0.TThis is equivalent to roundUp for negative Number and roundDown for positive NumberRound to the nearest integral roundNearest 3.64 > roundNearest 3.4 3-types that have sign and can be made absoluteSign of a signed number(    %$'&(%$'&    None *016FT n act performs the action n times, gathering the results.LKXWV321LK321XWVJNone *1FQTVk<A component of a conduit pipeline, which takes a stream of input, produces a stream of output&, performs actions in the underlying monad, and produces a value of result( when no more output data is available.W%A pipe producing and consuming values A basic intuition is that every Pipe produces a stream of outputO values and eventually indicates that this stream is terminated by sending a result. On the receiving end of a Pipe, these become the input and upstream parameters.XWProvide new output to be sent downstream. This constructor has three fields: the next Pipe< to be used, a finalization function, and the output value.Y^Request more input from upstream. The first field takes a new input value and provides a new Pipei. The second takes an upstream result value, which indicates that upstream is producing no more results.ZProcessing with this Pipe) is complete, providing the final result.[4Require running of a monadic action to get the next Pipe.\EReturn leftover input, which should be provided to future operations. Await for a value from upstream.Send a value downstream.Same as W, but additionally takes a finalizer to be run if the downstream component terminates.\Provide leftover input to be consumed by the next component in the current monadic binding.%Run a conduit pipeline to completion.*Run a pure conduit pipeline to completion.Run a conduit pipeline in a ! context for acquiring resources.]Internal: run a PipePSend the output of the first Conduit component to the second Conduit component. finalizer^_`abcWXYZ[\d^_efghijk`abcWXYZ[\K BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone*1FTѻl?Simple helper to split a list repeatly when the predicate matchlmnopqrL BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone*017;<=>FKT%&A set of methods for ordered colection*Take the first @n elements of a collection)Take the last @n elements of a collection*Drop the first @n elements of a collection)Drop the last @n elements of a collection*Split the collection at the @n'th elements7Split the collection at the @n'th elements from the end:Split on a specific elements returning a list of colletion1Split a collection when the predicate return true1Split a collection when the predicate return trueYSplit a collection when the predicate return true starting from the end of the collectionFReturn the longest prefix in the collection that satisfy the predicateFReturn the longest prefix in the collection that satisfy the predicateThe v function takes an element and a list and `intersperses' that element between the elements of the list. For example, &intersperse ',' "abcde" == "a,b,c,d,e"   xs xss is equivalent to ( ( xs xss)). It inserts the list xs in between the lists in xss and concatenates the result. 2Split a collection while the predicate return true ZSplit a collection while the predicate return true starting from the end of the collection 2Filter all the elements that satisfy the predicate GPartition the elements thtat satisfy the predicate and those that don'tReverse a collectionyDecompose a collection into its first element and the remaining collection. If the collection is empty, returns Nothing.Decompose a collection into a collection without its last element, and the last element If the collection is empty, returns Nothing.+Prepend an element to an ordered collection*Append an element to an ordered collection(Find an element in an ordered collection=Sort an ordered collection using the specified order function)Create a collection with a single element/get the first element of a non-empty collection.get the last element of a non-empty collectionGExtract the elements after the first element of a non-empty collection.GExtract the elements before the last element of a non-empty collection.ECreate a collection where the element in parameter is repeated N timeZTakes two collections and returns True iff the first collection is a prefix of the second.ZTakes two collections and returns True iff the first collection is a suffix of the second.ZTakes two collections and returns True iff the first collection is an infix of the second.'Try to strip a prefix from a collection'Try to strip a suffix from a collection%     '     M BSD-style foundation experimentalportableNone *01;=>?FKT:!! takes two collections and returns a collections of corresponding pairs. If one input collection is short, excess elements of the longer collection are discarded."Like !, but works with 3 collections.#Like !, but works with 4 collections.$Like !, but works with 5 collections.%Like !, but works with 6 collections.&Like !, but works with 7 collections.''q transforms a collection of pairs into a collection of first components and a collection of second components.(Like '0, but works on a collection of 3-element tuples.)Like '0, but works on a collection of 4-element tuples.*Like '0, but works on a collection of 5-element tuples.+Like '0, but works on a collection of 6-element tuples.,Like '0, but works on a collection of 7-element tuples... generalises !j by zipping with the function given as the first argument, instead of a tupling function. For example, . (+)U is applied to two collections to produce the collection of corresponding sums./Like ., but works with 3 collections.0Like ., but works with 4 collections.1Like ., but works with 5 collections.2Like ., but works with 6 collections.3Like ., but works with 7 collections. !"'(#$%&)*+,-./0123 !"#$%&'()*+,-./0123 BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone *1;=FTaJKLMNORSTUPQVWXYZ[\]_^`abcdfeghjiklmnopqrtsuvwxyz{|}~      !"'(#$%&)*+,-./0123 !"#$%&'()*+,LklldefgabcqrstuvwxyMNOPQRSTUYZVWX     z{|}~hijmnop-./0123[\]^_`JK BSD-style*Nicolas Di Prima <nicolas@primetype.co.uk>statbleportableNone*1FT444st BSD-styleHaskell Foundation experimentalportableNone *1;<=FT\AUExtending the Storable type class to the types that can be sequenced in a structure.D&Storable type of self determined size.Hlike E but at a given offset.Ilike F but at a given offset.;oACBDEFGHIJKLMDEFABC;GoHIJKLMABCDEF None*1FT#ZUnsafe Shift Left OperatorUnsafe Shift Right Operator&Round up (if needed) to a multiple of  alignment closst to m alignment needs to be a power of two.alignRoundUp 16 8 = 16 alignRoundUp 15 8 = 16(Round down (if needed) to a multiple of  alignment closest to m alignment needs to be a power of two /alignRoundDown 15 8 = 8 alignRoundDown 8 8 = 8Number to AlignAlignment (power of 2)Number to AlignAlignment (power of 2)~}|{zyxwvutsrqp~}|{zyxwvutsrqpN BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone*1FT-[u5Return the element at a specific index from a Bitmap.5If the index @n is out of bounds, an error is raised.vMReturn the element at a specific index from an array without bounds checking.NReading from invalid memory can return unpredictable and invalid values. use u if unsure.w&make an array from a list of elements.xtransform an array to a list.y"Check if two vectors are identicalzCompare 2 vectors{7Append 2 arrays together by creating a new bigger arrayTODO completely non optimized |}~uv{O BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone*1FKT5_BAn error related to the evaluation of a Partial value that failed.?it contains the name of the function and the reason for failurePartialiality wrapper."Throw an asynchronous PartialErrorCCreate a value that is partial. this can only be unwrap using the  functionDewrap a possible partial value*Partial function to get the head of a list1Partial function to grab the value inside a Maybe   BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone *1;=FT7/! #"0/.-,+*)(5678>=<A@?B00/.-,+*)(B>=<65A@?87#"!  PIBSD-style -- Maintainer : Alfredo Di Napoli <alfredo.dinapoli@gmail.com> experimentalportableNone %*1CDFQTVCReturns the length of this 8, by summing each inner length. Complexity: O(n) where n0 is the number of chunks, as U.length u is O(1).Returns @* if the given element is contained in the . Complexity: O(n) where n0 is the number of chunks, as U.length u is O(1).Fold a  leftwards strictly. Implemented internally using a double fold on the nested Array structure. Other folds implemented analogously.Equality between X. This function is fiddly to write as is not enough to compare for equality the inner /(s), we need an element-by-element comparison. BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone*1DFTE+  QNone*1FTQ 9Incremental Hashing state. Represent an hashing algorithm$the base primitive of this class is ", append mix a Word8 in the stateThe class allow to define faster mixing function that works on bigger Word size and any unboxed array of any PrimType elements.Associate type when finalizing the state with ?Associate type when initializing the state (e.g. a Key or seed)Create a new Hashing contextCreate a new Hashing context.Finalize the state and returns the hash result:Mix a Word8 (Byte) into the state and return the new state4Mix a Word16 into the state and return the new state4Mix a Word32 into the state and return the new state4Mix a Word64 into the state and return the new state=Mix an arbitrary sized unboxed array and return the new state  R BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalgoodNone*1DFTW5Sip State 1-3 (1 compression rounds, 3 digest rounds)5Sip State 2-4 (2 compression rounds, 4 digest rounds)Siphash Hash value SigHash Keysame as hash], except also specifies the number of sipround iterations for compression (C) and digest (D).S BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalgoodNone*1DFT_7 FNV1a 64 bit stateFNV1a 32 bit stateFNV1 64 bit stateFNV1 32 bit stateFNV1(a) hash (64 bit variants)FNV1(a) hash (32 bit variants)6compute FNV1 (32 bit variant) of a raw piece of memory7compute FNV1a (32 bit variant) of a raw piece of memory6compute FNV1 (64 bit variant) of a raw piece of memory7compute FNV1a (64 bit variant) of a raw piece of memory BSD-style FoundationstableportableSafe*1FT`  BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone*1FTb* BSD-styleHaskell Foundation experimentalportableNone *1<FQTV Foundation's Parser monad.-Its implementation is based on the parser in memory.result of executing the parser over the given input!the parser failed with the given  ParserError3the parser complete successfuly with the remaining Chunk+the parser needs more input, pass an empty Chunk or mempty3 to tell the parser you don't have anymore inputs.common parser error definition meaning the parser was short of CountOf Element of input.-The parser needed more data, only when using  parseOnly when using element when using elements or stringthe satisfy or satisfy_ function failed,"Run a parser on an @initial input.|If the Parser need more data than available, the @feeder function is automatically called and fed to the More continuation.*Run a Parser on a ByteString and return a parse only the given inputrThe left-over `Element input` will be ignored, if the parser call for more data it will be continuously fed with > (up to 256 iterations).4helper function to report error when writing parserstThis way we can provide more detailed error when building custom parsers and still avoid to use the naughty _fail_. kmyParser :: Parser input Int myParser = reportError $ Satisfy (Just "this function is not implemented...") ,Get the next `Element input` from the parser/take one element if satisfy the given predicate/take one element if satisfy the given predicateCTake the remaining elements from the current position in the stream!consume every chunk of the stream.repeat the given parser a given amount of timeUnlike some or many`, this operation will bring more precision on how many times you wish a parser to be sequenced. ## Repeat Exactly a number of time 8repeat (Exactly 6) (takeWhile ((/=) ',') <* element ',') ## Repeat Between lower `@And@` upper times Crepeat (Between $ 1 `And` 10) (takeWhile ((/=) ',') <* element ',')+U+UNone*1FT[$Split conduit of string to its linesIThis is very similar to Prelude lines except it work directly on Conduit|Note that if the newline character is not ever appearing in the stream, this function will keep accumulating data until OOM"TODO: make a size-limited function BSD-style FoundationNone*1FTrun the builder and return a  alias to "This function is not safe, prefer . None*1FTTNone  *1DFTU BSD-style*Nicolas Di Prima <nicolas@primetype.co.uk> provisionalportableNone*1FTPVSafe*1FT W(c) Vincent Hanquez 2014-2017 BSD-styleVincent Hanquez provisionalnon-portable (requires POSIX)None *1FT      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXXNone*1FT      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY(c) Vincent Hanquez 2014-2017 BSD-styleVincent Hanquez provisionalnon-portable (requires Linux)None*1FTYZ[\]^_`abcdefghijklmnopqrstuvwZHaskell foundationNone*1FTxyz{|}~[ BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone*1FT\ BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalGoodNone *1FTVqtry to fill the ptr with the amount of data required. Return the number of bytes, or a negative number otherwise BSD-style FoundationstablegoodNone*1FTjGet some of the system entropy]None*1FT7A monad constraint that allows to generate random bytes^None*1FTc[A simple Monad class very similar to a State Monad with the state being a RandomGenerator.,A Deterministic Random Generator (DRG) class!Initialize a new random generator5Initialize a new random generator from a binary seed.If >S is returned, then the data is not acceptable for creating a new random generator.)Generate N bytes of randomness from a DRGGenerate a Word64 from a DRG6Run a pure computation with a Random Generator in the  _ BSD-styleNone*1DFTState of Xoroshiro128 plus`None*1FTRNG based on ChaCha core.The algorithm is identical to the arc4random found in recent BSDs, namely a ChaCha core provide 64 bytes of random from 32 bytes of key. BSD-style experimentalGoodNone *1FTVGAn alias to the default choice of deterministic random number generatorUnless, you want to have the stability of a specific random number generator, e.g. for tests purpose, it's recommended to use this alias so that you would keep up to date with possible bugfixes, or change of algorithms.aNone &'*1CFQTVGenerator monad bNone*1FT-optional user specified seedParameters for the generatoradefault: * 32bits long numbers; * array of 512 elements max; * string of 8192 bytes max.1the number of tests to perform on every property. default: 100 create the default configurationsee Config for detailscNone %*1;=FT'How to generate an arbitrary value for a"Call one of the generator weighteddNone *1;=FT^'A linked-list of arguments to this test.The type of check this test did for a property8Running a generator for a specific type under a property4A property that check for equality of its 2 members.BA property that check for a specific comparaison of its 2 members.This is equivalent to  but with @A conjuctive property composed of 2 properties that need to pass3name of the function used for comparaison, e.g. (<)#function used for value comparaisonvalue left of the operatorvalue right of the operator4e BSD-styleFoundation maintainersNone&'*1CFKQTV@!different type of tests supportednumber of tests and failuresName of a test FollowedResult of a property runName of a testfNone&'*1<CFQTVȦ BSD-styleFoundation maintainersNone &'*1CFQTV  BSD-styleFoundation maintainersNone&'*1CFKQTV9internal check monad for facilitating the tests traversal Run tests BSD-style foundation experimentalportableNone*1FT 4Enumeration of the known GHC supported architecture.9get the operating system on which the program is running.Either return the known  or a strict  of the OS name.This function uses the base's  function.<get the machine architecture on which the program is running1Either return the known architecture or a Strict  of the architecture name.This function uses the base's  function.get the compiler nameKget the compilerName from base package but convert it into a strict String*returns the number of CPUs the machine hasOTSRQ4;:9    ;:94OTSRQ  ! BSD-styleFoundation maintainersNone*1FKTٸ+An amount of nanoseconds-An amount of nanoseconds+,-.-.+,+,-."None*1FT=A precise stop watchThe precision is higher than a normal stopwatch, but also on some system it might not be able to record longer period of time accurately (possibly wrapping)>Create a new precise stop watch record the time at start of call?1Get the number of nano seconds since the call to >=>?=>?=#None*1FTߩ@A@A$ BSD-styleFoundation maintainersNone*1FTJGSimple one-time measurement of time & other metrics spent in a functionK6In depth timing & other metrics analysis of a function BCDEFGHIJK FGHIBCDEJKBCDEFGHI% BSD-styleFoundation maintainersNone *1FKT#LLg BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone*16FT1P0Class of product types that have a third elementS1Class of product types that have a second elementV0Class of product types that have a first elementYStrict tuple (a,b,c,d)[Strict tuple (a,b,c)]Strict tuple (a,b)PQRSTUVWXYZ[\]^PQRSTUVWXYZ[\]^h BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalgoodNone*1FT$_"Type with the ability to be hashedHashable doesn't have any specific rules, and it's made for raw speed. More specifically don't expect different type representing the same data to hash to the same value .hashMix (1 :: Integer) /= hashMix (1 :: Word8)True_`_` BSD-style*Nicolas Di Prima <nicolas@primetype.co.uk> experimentalportableNone *1;=FT aIPv6 data typebequivalent to `::`cequivalent to `::1`d serialise to human readable IPv6/toString (fromString "0:0:0:0:0:0:0:1" :: IPv6)e#create an IPv6 from the given tuplefdecompose an IPv6 into a tupleg#IPv6 Parser as described in RFC4291for more details: 4https://tools.ietf.org/html/rfc4291.html#section-2.2which is exactly:``` ipv6ParserPreferred  | ipv6ParserIPv4Embedded  | ipv6ParserCompressed ```h1IPv6 parser as described in RFC4291 section 2.2.11The preferred form is x:x:x:x:x:x:x:x, where the xPs are one to four hexadecimal digits of the eight 16-bit pieces of the address.)`ABCD:EF01:2345:6789:ABCD:EF01:2345:6789``2001:DB8:0:0:8:800:200C:417A`i'IPv6 address with embedded IPv4 address`when dealing with a mixed environment of IPv4 and IPv6 nodes is x:x:x:x:x:x:d.d.d.d, where the xZs are the hexadecimal values of the six high-order 16-bit pieces of the address, and the dls are the decimal values of the four low-order 8-bit pieces of the address (standard IPv4 representation).`0:0:0:0:0:0:13.1.68.3``0:0:0:0:0:FFFF:129.144.52.38` `::13.1.68.3``::FFFF:129.144.52.38`j1IPv6 parser as described in RFC4291 section 2.2.2The use of "::" indicates one or more groups of 16 bits of zeros. The "::" can only appear once in an address. The "::" can also be used to compress leading or trailing zeros in an address.`2001:DB8::8:800:200C:417A` `FF01::101``::1``::` abcdefghij abcdefghjia& BSD-style*Nicolas Di Prima <nicolas@primetype.co.uk> experimentalportableNone *1;<=FKT sIPv4 data typet "0.0.0.0"u "127.0.0.1"yParse a IPv4 addressstuvwxystuvwxys BSD-style FoundationNone*1FT _` _` BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone*1FT :Alias to Prelude String ([Char]) for compatibility purposeF  !"#$%&'=@()*+,-./012>?3CDE456789:<ABJHGIP[_^]\`abcdegfih    %$'&CEDGFIHMNORSTUPQVYZdfeg     PQRSTUVWXYZ[\]^h]^[\YZVWXSTUPQRid!  EDGFIHJIHG$ #F%$'&   2>?3CDE'=@(5<AB,-./789:6+014*) %&`MNOPQRSTUYZ     VdefgacbP_^]\"[gfeC' BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone *-1;=>?FTRA generalized version of indexed accessor allowing access to tuples n'th element.Indexing starts at 1, as X is used to get first element.(None *1<FT=) BSD-style foundation experimentalportableNone*1<FT8 Path type classddefines the Path associated types and basic functions to implement related to the path manipulation # TODO, add missing enhancement: ~splitExtension :: PathEnt path -> (PathEnt path, PathEnt path) addExtension :: PathEnt path -> PathEnt path -> PathEnt path ( .$) :: path -> PathEnt path -> path (- .") :: path -> PathEnt path -> path 'the associated PathEntity of the given path this type is the minimal element contained in the Path a Path is not a collection but it is possible to see this associated type equivalent to the i type family#the associated prefix of the given pathin the case of a jk-, it is a void (i.e. `()`) in the case of a jl!, it is the schema, host, port...'the associated suffix of the given pathin the case of the jk/, it is a void (i.e. `()`) in the case of the jl!, it is a the query, the fragment"join a path entity to a given path+split the path into the associated elements+build the path from the associated elements*parent is only going to drop the filename.Gif you actually want to reference to the parent directory, simply uses:  parent "." = "." <> ".." parent ("foo.hs" :: FilePath).%parent ("foo/bar/baz.hs" :: FilePath)foo/bar"get the filename of the given path.If there is no filename, you will receive the  of the filename ("foo.hs" :: FilePath)foo.hs'filename ("foo/bar/baz.hs" :: FilePath)baz.hsget the path prefix information prefix ("/home/tab" :: FilePath)Absoluteprefix ("home/tab" :: FilePath)Relative#or for URI (TODO, not yet accurate) prefix " .http://github.com/vincenthz/hs-foundation?w=1"; == URISchema http Nothing Nothing "github.com" Nothing get the path suffix information suffix ("/home/tab" :: FilePath)()#or for URI (TODO, not yet accurate) suffix " .http://github.com/vincenthz/hs-foundation?w=1"' == URISuffix (["w", "1"], Nothing)  * BSD-style foundation experimentalportableNone*1FTQ'errors related to FileName manipulation0this means a null byte was found in the FileName5this means a path separator was found in the FileNameencoding error"some unknown trainling bytes found+A filename (or path entity) in the FilePath  Authorised"""."".." "foundation" Unauthorised"/""file/""/file" "file/path")error associated to filepath manipulation2this mean there were 2 contiguous path separators.9This is not valid in Foundation's FilePath specifications$FilePath is a collection of FileNameTODO: Eq and Ord are implemented using Show This is not very efficient and would need to be improved Also, it is possible the ordering is not necessary what we want in this case.#A FilePath is one of the following:  An Absolute:#starts with one of the follwing "/" A relative:don't start with a "/" authorised:"/""filepath"".""..""workhaskellhs-foundation" unauthorised"path//""information about type of FilePathA file path being only  or ..define the Path separator for POSIX systems : / convert a FileName into a String?This function may throw an exception associated to the encoding*conversion of FileName into a list of Char"this function may throw exceptions,conversion of a FilePath into a list of Char"this function may throw exceptions/build a file path from a given list of filename7this is unsafe and is mainly needed for testing purpose(build a file name from a given ByteArray7this is unsafe and is mainly needed for testing purpose  j BSD-style foundation experimentalportableNone*1FTSm BSD-style Foundation experimentalportableNone*1FTh2list the file name in the given FilePath directoryqTODO: error management and not implemented yet getDirectory :: FilePath -> IO [FileName] getDirectory = undefinedOpen a new handle on the fileClose a handle-Read binary data directly from the specified .First argument is the Handle to read from, and the second is the number of bytes to read. It returns the bytes read, up to the specified size, or an empty array if EOF has been reached. is implemented in terms of hGetBuf.hGetNonBlocking is similar to , except that it will never block waiting for data to become available, instead it returns only whatever data is available. If there is no data available to be read,  returns an empty array.7Note: on Windows, this function behaves identically to .Like , except that a shorter array may be returned if there are not enough bytes immediately available to satisfy the whole request. N only blocks if there is no data available, and EOF has not yet been reached. filepath mode act opens a file using the mode and run acta. the by-product handle will be closed when act finish, either normally or through an exception.(The value returned is the result of act@IRead a binary file and return the whole content in one contiguous buffer.nmlkj BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone*1FTjRYZnmlkjYZnmlkjNone*1FTlOperator version of .Send values downstream.2n BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone*1FTqgContains all the information related to a file mapping, including the size and the finalizer function.kFrom a file mapping, create a final ptr which will automatically unmap memory when the pointer is garbage.  o(c) Vincent Hanquez 2014 BSD-styleVincent Hanquez provisionalnon-portable (requires POSIX)None*1FT Memory synchronization flags perform asynchronous write. perform synchronous write. invalidate cache data.Advice to put on memory.only define the posix one. no specific advice, the default.BExpect page references in random order. No readahead should occur.RExpect page references in sequential order. Page should be readahead aggressively.IExpect access in the near future. Probably a good idea to readahead early(Do not expect access in the near future.Memory protection Mapping flag)memory changes are shared between process%memory changes are private to processMap pages of memory.vIf fd is present, this memory will represent the file associated. Otherwise, the memory will be an anonymous mapping.use mmapUnmap pages of memoryuse munmap7give advice to the operating system about use of memorycall madvise%lock a range of process address spacecall mlock'unlock a range of process address spacecall munlock set protection of memory mappingcall mprotect4memorySync synchronize memory with physical storage.FOn an anonymous mapping this function does not have any effect. call msync&Return the operating system page size.call sysconf*The address to map to if MapFixed is used.The length of the mapping1the memory protection associated with the mapping     !"#$     !"#pNone*1FTA $+ BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone*1FTJ*Map in memory the whole content of a file.COnce the array goes out of scope, the memory get (eventually) unmap*Map in memory the whole content of a file,, BSD-style foundation experimentalportableNone*1FT TODO this is not implemented yet  %qrstuvtuwtxytxztx{tx|q}~q}tutututututtttttttututututututxtxq}tutuq}ttttuttuqqqqqttttttuqtqqttttttqtutuqttqqqtttttttttttttttttttttttttttttttttttttttttttttttttt t t t t tttttttttttttttxtxtx tx!tx"tx#t$%t$&t$'t$(t$)t$*t$+t$,t-.t-/t-0tu1tu2tu3tu4tu5tu6tu7tu8tu9tu:tu;tu<t=>t?q}@q}Aq}Bq}Cq}Dq}Eq}Fq}Gq}Hq}IJKLJKMJKNJKOJKPJKQJKRJKSJKTJKUJKVJKWJKXJKYJKZJK[JK\JK]JK^JK_JK`JKaJKbJKcJKdJKeJfgJhiJjkJlmJnoJnpJnqJnrJnsJtuJvwJvxJvyJvzJv{Jv|J}~J}JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ../i000000000000001 1 1 1 1 1222222233344555566;6<6=6>67696@6?A A!A"A#A$A%A&A'A(A)A*A+A,-.g/0123456789:;<=>D?D@DADBDCDD E FFGFHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghhijklmnopIqIrIsItIuIvwxyz{|}~JJJJJJJJJJJJJJJLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMM      !"#$ % & ' (N)N*O+O,O-O.P/Q0R1R2S3S4S5S6789:;<==>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqXW\Yrs]t]u]v]w]x^y^y^z^{^|^}^~^^^^acccccXcdddddddddddeeeeeee      !!!!!!!!!!!!!!!!!!"""##$$$$$$$$$$%%%%ggggggggggggggghhr&&&&r&&&&&&&&& & &   '''''''''''''''''' '!'"'#($($(%(&('((()(*(+(,(-(.(/)0)1)2)3)4)5)6)7)8)9):*;*k*<*=*>*?*@*A*B*C*D*E*F*G*H*I*J*K*L*M*N*O*P*Q*R*SmTmUmVmWmXmYZ[\]^_`+a+b,c,c,d,d,e,e,f,f,g,g,l,l,h1i6:tjktjktjltjltmntmntmotmotmptmptmqtmqtmrtmrtmstmstmttmttmutmutmvtmvtmwtmwtmxtmxtmytmytmztmztm{tm|tm|tm}tm}tm~tm~tmtmtmtmtmtmtmtmtmtmtmtmtmtmtmtmtmtmJJJJJJJJJJJBJJJJJJJJJJJJJJJJJJJJJJ JJJJJJJJJJ9J=JJJJGGGIYJJJJJJJJJJJJJJJJJJJJJKKKKKKKNNNNNNN NNNNNNNNN)N*OOOOOO+O,PPPPP/QQQQQQQQQQRRRRRRRRRRRRRRRRRRR1R2SSSSSSSSS3S4S5S6AJJJJJTUUUUUVVVVVVVVWWWWWWWWWWWWWWWWWWW W W W W WWWWWWWWWWWWWWWWWWW W!W"W#W$W%W&W'W(W)W*W+W,W-W.W/W0W1W2W3W4W5W6W7W8W9W:W;W<W=W>W?W@WAWBWCWDWEWFWGWHWIWJWKWLWMWNWOWPWQWRWSWTWUWVWWWXWYWZW[W\W]W^W_W`WaWbWcWdWeWfWgWhWiWjWkWlWmWnWoWpWqWrWsWtWuWvWwWxWyWzW{Y|Y}Y~YYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZ[[\\\\\\\_L_____L`L`L`aaaaaaaaaaaabbbbbbbbbbbbbbbbbddddddddddeeeeeeeeeeeeeeeeeeff           tt"%%%%%%%%%&********* * *;*kt  m mnnnnnnnoooooooooooo o!o"o#o$o%o&o'o(o)o*o+o,o-o.oa/(foundation-0.0.19-65vqo38dzL1HFlldz5mMCC FoundationFoundation.Network.IPv6Foundation.Class.StorableFoundation.MonadFoundation.IO.TerminalFoundation.System.InfoFoundation.Parser Foundation.IOFoundation.BitsFoundation.ExceptionFoundation.StringFoundation.String.ReadFoundation.PrimitiveFoundation.Array.InternalFoundation.ForeignFoundation.ArrayFoundation.CollectionFoundation.NumericalFoundation.Math.TrigonometryFoundation.Monad.StateFoundation.Monad.ReaderFoundation.Monad.ExceptFoundation.ConduitFoundation.List.DListFoundation.HashingFoundation.StrictFoundation.Conduit.TextualFoundation.String.BuilderFoundation.System.EntropyFoundation.RandomFoundation.CheckFoundation.Check.MainFoundation.Time.TypesFoundation.Time.StopWatchFoundation.Time.BindingsFoundation.TimingFoundation.Timing.MainFoundation.Network.IPv4Foundation.Tuple.NthFoundation.UUIDFoundation.VFS.PathFoundation.VFS.FilePathFoundation.IO.FileMapFoundation.VFS.URIFoundation.Class.BifunctorFoundation.Collection.CopyFoundation.Collection.Element Foundation.Collection.CollectionFoundation.Collection.BuildableFoundation.Collection.FoldableFoundation.Collection.Indexed"Foundation.Collection.InnerFunctorFoundation.Collection.KeyedFoundation.Collection.Mappable traverse_ sequenceA_mapM_ sequence_traverse sequenceAmapMsequenceforM_forMFoundation.Collection.MutableFoundation.Foreign.AllocFoundation.List.ListNFoundation.Monad.ExceptionFoundation.Monad.MonadIOFoundation.Monad.TransformerFoundation.Monad.IdentityFoundation.Monad.BaseFoundation.Numerical.FloatingFoundation.Conduit.InternalFoundation.Collection.List Foundation.Collection.SequentialFoundation.Collection.ZippableFoundation.Array.BitmapFoundation.Partial Foundation.Array.Chunked.UnboxedFoundation.Hashing.HasherFoundation.Hashing.SipHashFoundation.Hashing.FNVFoundation.System.Bindings.Hs"Foundation.System.Bindings.Network#Foundation.System.Bindings.PosixDef Foundation.System.Bindings.PosixFoundation.System.Bindings Foundation.System.Bindings.LinuxFoundation.System.Bindings.Time Foundation.System.Entropy.CommonFoundation.System.Entropy.UnixFoundation.Random.ClassFoundation.Random.DRGFoundation.Random.XorShiftFoundation.Random.ChaChaDRGFoundation.Check.GenFoundation.Check.ConfigFoundation.Check.ArbitraryFoundation.Check.PropertyFoundation.Check.TypesFoundation.Check.PrintFoundation.TupleFoundation.Hashing.HashableElementFoundation.VFSFilePathURIFoundation.IO.File"Foundation.Foreign.MemoryMap.Types"Foundation.Foreign.MemoryMap.PosixFoundation.Foreign.MemoryMapghc-primGHC.PrimseqbaseGHC.Base otherwise$GHC.EnumenumFrom enumFromThen enumFromToenumFromThenTo GHC.Classes==>=fail>>=>>fmapreturn Data.String fromStringGHC.Real fromIntegral realToFracGHC.ExtsIsListfromList fromListNtoListmemptymappendmconcat<*>pure*>BoundedEnumEqMonadFunctorOrdGHC.ShowShowData.Typeable.InternalTypeableIsString ApplicativeData.Semigroup SemigroupMonoid GHC.TypesBoolCharDoubleFloatIntGHC.IntInt8Int16Int32Int64 integer-gmpGHC.Integer.TypeInteger GHC.NaturalNaturalMaybeOrderingRationalIOWordGHC.WordWord8Word16Word32Word64GHC.PtrPtr Data.EitherEitherFalseNothingJustTrueLeftRightLTEQGTItemData.Bifunctorsecondfirstbimap BifunctorControl.Monad.IO.ClassliftIOMonadIO System.Exit exitSuccess exitFailure System.InfocompilerVersion Control.Monad>=> Data.Version versionTags versionBranchVersionControl.ApplicativeoptionalData.Functor.Identity runIdentityIdentityGHC.IO.Handle.FDstdinstdoutGHC.IO.Exception IOException GHC.ExceptiondisplayException fromException toException Exception Data.Monoid<>partitionEithersrightsleftseither Data.Proxy asProxyTypeOfProxyControl.Category.id GHC.IO.IOMode ReadWriteMode AppendMode WriteModeReadModeIOModecastPtr Data.BitspopCountrotateRrotateL unsafeShiftRshiftR unsafeShiftLshiftLisSignedbitSize bitSizeMaybetestBit complementBitclearBitsetBitbitzeroBitsrotateshift complementxor.|..&.Bits Data.Functionon Data.Functor<$>^^maxBoundminBoundfromEnumtoEnumpredsucc Data.MaybemapMaybe catMaybes listToMaybe maybeToList fromMaybe isNothingisJustmaybe Data.TupleswapuncurrycurryasTypeOfuntil$!flipconst=<<<$<*liftA2manysome<|>GHC.Err undefined SomeException/=compare<=&&||not<>maxmin%basement-0.0.6-99d81r6tcUO7TJoRhzEM14Basement.StringtoBase64OpenBSD toBase64URLtoBase64lowerupperreadFloatingExact readRational readDouble readNatural readInteger readIntegralwordslinestoBytesfromBytesUnsafefromBytesLenient fromBytesreplaceindices breakLine ISO_8859_1UTF32UTF16UTF8ASCII7EncodingBasement.EnvironmentgetArgsBasement.Errorerror Basement.ShowshowBasement.UTF8.BaseStringBasement.UTF8.TypesBuildingFailure MissingByteInvalidContinuation InvalidHeaderValidationFailureBasement.Types.AsciiString AsciiStringBasement.UArray toHexadecimalrecastwithPtr copyToPtrfromForeignPtr foreignMemBasement.UArray.MutablewithMutablePtrmutableForeignMemBasement.BoxedArrayArrayMArrayBasement.UArray.Basenew newPinnedMUArrayUArrayBasement.Block.BaseBlock MutableBlockBasement.TheseTheseThatThisBasement.NormalFormforcedeepseq toNormalForm NormalFormBasement.NonEmpty getNonEmptyNonEmptyBasement.Exception OutOfBoundBasement.MutableBuilder runBuilderBuilder chunkSizecurChunkprevChunksSize prevChunks BuildingStateBasement.PrimType primAddrWrite primAddrRead primAddrIndex primMbaUWrite primMbaURead primBaUIndexprimShiftToBytesprimSizeInBytesPrimSizePrimTypeBasement.Types.OffsetSizeOffsetCountOf!Basement.Numerical.Multiplicativerecip^* midentityMultiplicativedivModmoddiv IDivisible/ DivisibleBasement.Numerical.Additivescale+azeroAdditiveBasement.Numerical.Subtractive- Difference SubtractiveBasement.Types.Word256Word256Basement.Types.Word128Word128Basement.Types.Char7Char7Basement.IntegralConvintegralDownsizeCheckintegralDownsizeIntegralDownsizeintegralUpsizeIntegralUpsizeBasement.Numerical.Number toInteger IsIntegral toNatural IsNaturalBasement.Monad primVarWrite primVarRead primVarNew unPrimMonad primThrow primitivePrimVar PrimState PrimMonadmFailFailure MonadFailureBasement.Endianness endiannessfromLEtoLEfromBEtoBE BigEndian LittleEndian EndiannessunLELEunBEBEByteSwapBasement.Compat.Base ifThenElseBasement.Compat.NumLiteral fromIntegerIntegral fromRational Fractionalnegate HasNegationCopycopy CollectionnulllengthelemnotElemmaximumminimumanyallnonEmpty nonEmpty_ nonEmptyFmapandor BuildableMutableStepappendbuildbuild_ Fold1ablefoldl1'foldr1Foldablefoldl'foldrfoldr'IndexedCollection! findIndex InnerFunctorimapKeyedCollectionKeyValuelookupMappableMutableCollectionMutableFreezed MutableKey MutableValue unsafeThaw unsafeFreezethawfreezemutNewmutUnsafeWritemutWrite mutUnsafeReadmutReadputStrputStrLn Trigonometrypisincostanasinacosatansinhcoshtanhasinhacoshatanh$fTrigonometryDouble$fTrigonometryFloat MonadBracketgeneralBracket MonadCatchcatch MonadThrowthrowfinallytry MonadTransliftStateT runStateT MonadStateState withStategetput$fMonadStateStateT$fMonadCatchStateT$fMonadThrowStateT$fMonadFailureStateT$fMonadIOStateT$fMonadTransStateT $fMonadStateT$fApplicativeStateT$fFunctorStateTReaderT runReaderT MonadReader ReaderContextask$fMonadReaderReaderT$fMonadBracketReaderT$fMonadCatchReaderT$fMonadThrowReaderT$fMonadFailureReaderT$fMonadIOReaderT$fMonadTransReaderT$fMonadReaderT$fApplicativeReaderT$fFunctorReaderTExceptT runExceptT$fMonadIOExceptT$fMonadTransExceptT$fMonadReaderExceptT$fMonadExceptT$fMonadFailureExceptT$fApplicativeExceptT$fFunctorExceptT FloatingPoint floatRadix floatDigits floatRange floatDecode floatEncodeIntegralRoundingroundUp roundDown roundTruncate roundNearestSignedabssignumSign SignNegativeSignZero SignPositive$fSignedDouble $fSignedFloat $fSignedInt64 $fSignedInt32 $fSignedInt16 $fSignedInt8 $fSignedInt$fSignedInteger$fIntegralRoundingFloat$fIntegralRoundingDouble$fIntegralRoundingRatio$fEqSign replicateM ResourceTZipSink getZipSinkConduitawait awaitForeveryieldyieldOrleftover runConduitrunConduitPure runConduitResbracketConduitfuse SequentialtakerevTakedroprevDropsplitAt revSplitAtsplitOnbreakbreakEnd breakElem takeWhile dropWhile intersperse intercalatespanspanEndfilter partitionreverseunconsunsnocsnocconsfindsortBy singletonheadlasttailinit replicate isPrefixOf isSuffixOf isInfixOf stripPrefix stripSuffix BoxedZippablezipzip3zip4zip5zip6zip7unzipunzip3unzip4unzip5unzip6unzip7ZippablezipWithzipWith3zipWith4zipWith5zipWith6zipWith7DList$fSequentialDList$fCollectionDList$fFoldableDList $fMonadDList$fApplicativeDList$fFunctorDList $fMonoidDList$fSemigroupDList $fIsListDList $fShowDList $fOrdDList $fEqDList StorableFixedsize alignmentStorablepeekpokeplusPtrpeekOffpokeOff peekArraypeekArrayEndedBy pokeArraypokeArrayEndedBy $fStorablePtr $fStorableLE $fStorableBE$fStorableWord256 $fStorableLE0 $fStorableBE0$fStorableWord128 $fStorableLE1 $fStorableBE1$fStorableWord64 $fStorableLE2 $fStorableBE2$fStorableWord32 $fStorableLE3 $fStorableBE3$fStorableWord16$fStorableWord8$fStorableInt64$fStorableInt32$fStorableInt16$fStorableInt8$fStorableFloat$fStorableDouble$fStorableChar$fStorableCUChar$fStorableCChar$fStorableFixedPtr$fStorableFixedLE$fStorableFixedBE$fStorableFixedWord256$fStorableFixedLE0$fStorableFixedBE0$fStorableFixedWord128$fStorableFixedLE1$fStorableFixedBE1$fStorableFixedWord64$fStorableFixedLE2$fStorableFixedBE2$fStorableFixedWord32$fStorableFixedLE3$fStorableFixedBE3$fStorableFixedWord16$fStorableFixedWord8$fStorableFixedInt64$fStorableFixedInt32$fStorableFixedInt16$fStorableFixedInt8$fStorableFixedFloat$fStorableFixedDouble$fStorableFixedChar$fStorableFixedCUChar$fStorableFixedCChar.<<..>>. alignRoundUpalignRoundDown MutableBitmapBitmap PartialErrorPartialpartial fromPartial ChunkedUArrayHasherSip1_3Sip2_4FNV1a_64FNV1a_32FNV1_64FNV1_32strict1strict2strict3strict4strict5strict6And ConditionBetweenExactlyParser ParserSourceChunk nullChunk appendChunksubChunk spanChunkResult ParseFailedParseOk ParseMore ParseError NotEnoughNotEnoughParseOnlyExpectedElementExpectedSatisfy parseFeedparse parseOnly reportError anyElementelementelementssatisfysatisfy_takeAllskip skipWhileskipAllstringrepeat$fParserSource[]$fParserSourceString$fShowParseError$fExceptionParseError$fFunctorResult $fShowResult$fAlternativeParser$fMonadPlusParser $fMonadParser$fApplicativeParser$fFunctorParser $fShowAnd $fShowNoMore $fEqNoMore$fEqAnd$fShowCondition $fEqConditiontoString getEntropy MonadRandomgetRandomBytesgetRandomWord64 getRandomF32 getRandomF64MonadRandomStaterunRandomState RandomGen randomNew randomNewFromrandomGeneraterandomGenerateWord64randomGenerateF32randomGenerateF64withRandomGeneratorRNGv1RNGGen Arbitrary arbitrary frequencyoneofbetween IsPropertypropertyPropertyPropunProp PropertyCheckforAll===propertyCompare propertyAnd propertyFailTestUnitGroup CheckPlanChecktestNamevalidatepickiterateProperty defaultMain$fMonadStateCheckMain$fFunctorCheckMain$fApplicativeCheckMain$fMonadCheckMain$fMonadIOCheckMainArchI386X86_64PowerPC PowerPC64SparcSparc64ARMARM64OSWindowsOSXLinuxAndroidBSDosarch compilerNamecpus$fShowOS$fEqOS$fOrdOS$fEnumOS $fBoundedOS$fDataOS $fShowArch$fEqArch $fOrdArch $fEnumArch $fBoundedArch $fDataArchSeconds NanoSeconds$fPrimTypeNanoSeconds$fPrimTypeSeconds$fShowNanoSeconds$fEqNanoSeconds$fOrdNanoSeconds$fAdditiveNanoSeconds$fEnumNanoSeconds$fBoundedNanoSeconds $fShowSeconds $fEqSeconds $fOrdSeconds$fAdditiveSeconds $fEnumSeconds$fBoundedSecondsStopWatchPrecise startPrecise stopPrecisemeasuringNanoSecondsgetMonotonicTimeMeasure measurementsitersTimingtimeDifftimeBytesAllocated stopWatchmeasure$fFunctorTimingPlan$fApplicativeTimingPlan$fMonadTimingPlanThdable ProductThirdthdSndable ProductSecondsndFstable ProductFirstfstTuple4Tuple3Tuple2HashablehashMixIPv6loopback fromTupletoTuple ipv6Parseripv6ParserPreferredipv6ParserIpv4Embeddedipv6ParserCompressed$fStorableFixedIPv6$fStorableIPv6$fIsStringIPv6 $fShowIPv6$fHashableIPv6$fNormalFormIPv6$fEqIPv6 $fOrdIPv6IPv4 ipv4Parser$fStorableFixedIPv4$fStorableIPv4$fIsStringIPv4$fNormalFormIPv4 $fShowIPv4$fEqIPv4 $fOrdIPv4$fHashableIPv4LString fromCounttoCountNthableNthTynth$fNthable4Tuple4$fNthable3Tuple4$fNthable2Tuple4$fNthable1Tuple4$fNthable4(,,,)$fNthable3(,,,)$fNthable2(,,,)$fNthable1(,,,)$fNthable3Tuple3$fNthable2Tuple3$fNthable1Tuple3$fNthable3(,,)$fNthable2(,,)$fNthable1(,,)$fNthable2Tuple2$fNthable1Tuple2 $fNthable2(,) $fNthable1(,)UUIDnilnewUUID fromBinary uuidParser$fStorableFixedUUID$fStorableUUID$fHashableUUID$fNormalFormUUID $fShowUUID$fEqUUID $fOrdUUIDPathPathEnt PathPrefix PathSuffix splitPath buildPathparentfilenameprefixsuffixFileName RelativityAbsoluteRelativefilePathToStringfilePathToLStringunsafeFilePathunsafeFileName extension$fExceptionFilePath_Invalid$fMonoidFileName$fSemigroupFileName$fShowFileName$fPathFilePath$fIsStringFilePath $fOrdFilePath $fEqFilePath$fShowFilePath$fIsStringFileName$fExceptionFileName_Invalid$fEqRelativity$fShowRelativity$fShowFilePath_Invalid $fEqFileName$fShowFileName_InvalidopenFile closeFilehGethPutwithFilereadFile.| sourceFile sourceHandleyieldssinkFile sinkHandlesinkList fileMapReadfileMapReadWithURIPath URIFragmentURIQuery URIAuthority URISchema $fPathURI builderLiftSystem.Posix.TypesCModeCOffForeign.C.TypesCCharCSCharCUCharCShortCUShortCIntCUIntCLongCULongCLLongCULLongCBoolCFloatCDoubleCPtrdiffCSizeCWchar CSigAtomicCClockCTime CUSeconds CSUSecondsCIntPtrCUIntPtrCIntMaxCUIntMaxBasement.FinalPtrwithUnsafeFinalPtr touchFinalPtr withFinalPtrwithFinalPtrNoTouch castFinalPtrtoFinalPtrForeign toFinalPtrfinalPtrSameMemoryFinalPtr FinalForeign allocaBytesBasement.Sized.Listfoldlmapindex indexStatic createFromcreateemptytoListNListNunListN IdentityT runIdentityTPipeYieldAwaitDonePipeMLeftoverrunPipe MonadResource liftResourceT unResourceT unConduit runResourceT ReleaseType ReleaseEarly ReleaseNormalReleaseException ReleaseMapReleaseMapClosed wordsWhenunDList unsafeIndex vFromListvToListequalvCompare unsafeWrite unsafeReadwritereadconcat partialErrorfromJust fromRightfromLefthashMix8 HashResulthashEnd HashInitParamhashNew hashNewParam hashMix16 hashMix32 hashMix64 hashMixBytesSipHashSipKeymixBaSipIncrementalSipIncremental0SipIncremental1SipIncremental2SipIncremental3SipIncremental4SipIncremental5SipIncremental6SipIncremental7 InternalStateSip FNV1Hash64 FNV1Hash32 fnv1_32_mixBafnv1a_32_mixBa fnv1_64_mixBafnv1a_64_mixBa runParserNoMoreMoreBasement.String.Builder runUnsaferunemitCharemitsysHsCoreGetErrno getHErrnoherr_HostNotFound herr_NoDataherr_NoRecovery herr_TryAgain COpenFlags CSysconfName CMemSyncFlags CMemAdviceCMemMappingFlags CMemProtFlagsCFdCErrnoCDirentCDir sysPosixDirfdsysPosixClosedirsysPosixRewinddirsysPosixSeekdirsysPosixTelldirsysPosixReaddirRsysPosixReaddirsysPosixFdopendirsysPosixOpendirsysPosixFtruncatesysPosixFnctlPtrsysPosixFnctlNoArg sysPosixClosesysPosixOpenAt sysPosixOpensysPosixSysconfsysPosixMunlock sysPosixMlocksysPosixMprotect sysPosixMsyncsysPosixMadvisesysPosixMunmap sysPosixMmapsysPosix_E2BIGsysPosix_EACCESsysPosix_EADDRINUSEsysPosix_EADDRNOTAVAILsysPosix_EAFNOSUPPORTsysPosix_EAGAINsysPosix_EALREADYsysPosix_EBADFsysPosix_EBUSYsysPosix_ECANCELEDsysPosix_ECHILDsysPosix_ECONNABORTEDsysPosix_ECONNREFUSEDsysPosix_ECONNRESETsysPosix_EDEADLKsysPosix_EDESTADDRREQ sysPosix_EDOMsysPosix_EDQUOTsysPosix_EEXISTsysPosix_EFAULTsysPosix_EFBIGsysPosix_EHOSTUNREACHsysPosix_EIDRMsysPosix_EILSEQsysPosix_EINPROGRESSsysPosix_EINTRsysPosix_EINVAL sysPosix_EIOsysPosix_EISCONNsysPosix_EISDIRsysPosix_ELOOPsysPosix_EMFILEsysPosix_EMLINKsysPosix_EMSGSIZEsysPosix_ENAMETOOLONGsysPosix_ENETDOWNsysPosix_ENETRESETsysPosix_ENETUNREACHsysPosix_ENFILEsysPosix_ENOBUFSsysPosix_ENODEVsysPosix_ENOENTsysPosix_ENOEXECsysPosix_ENOLCKsysPosix_ENOMEMsysPosix_ENOMSGsysPosix_ENOPROTOOPTsysPosix_ENOSPCsysPosix_ENOSYSsysPosix_ENOTCONNsysPosix_ENOTDIRsysPosix_ENOTEMPTYsysPosix_ENOTSOCKsysPosix_ENOTSUPsysPosix_ENOTTYsysPosix_ENXIOsysPosix_EOPNOTSUPPsysPosix_EOVERFLOWsysPosix_EPERMsysPosix_EPIPEsysPosix_EPROTONOSUPPORTsysPosix_EPROTOTYPEsysPosix_ERANGEsysPosix_EROFSsysPosix_ESPIPEsysPosix_ESRCHsysPosix_ESTALEsysPosix_ETIMEDOUTsysPosix_ETXTBSYsysPosix_EWOULDBLOCKsysPosix_EXDEVsysPosix_ENODATAsysPosix_ENOSRsysPosix_ENOSTRsysPosix_ETIMEsysPosix_EBADMSGsysPosix_EMULTIHOPsysPosix_ENOLINKsysPosix_ENOTRECOVERABLEsysPosix_EOWNERDEADsysPosix_EPROTOsysPosix_O_RDONLYsysPosix_O_WRONLYsysPosix_O_RDWRsysPosix_O_NONBLOCKsysPosix_O_APPENDsysPosix_O_CREATsysPosix_O_TRUNCsysPosix_O_EXCLsysPosix_O_NOFOLLOWsysPosix_O_CLOEXECsysPosix_PROT_NONEsysPosix_PROT_READsysPosix_PROT_WRITEsysPosix_PROT_EXECsysPosix_MAP_SHAREDsysPosix_MAP_PRIVATEsysPosix_MAP_FIXEDsysPosix_MAP_ANONYMOUSsysPosix_MADV_NORMALsysPosix_MADV_RANDOMsysPosix_MADV_SEQUENTIALsysPosix_MADV_WILLNEEDsysPosix_MADV_DONTNEEDsysPosix_MS_ASYNCsysPosix_MS_SYNCsysPosix_MS_INVALIDATEsysPosix_SC_PAGESIZECWatchDescriptor CInotifyMask CInotifyFlagssysLinuxInotifyRmWatchsysLinuxInotifyAddWatchsysLinuxInotifyInitsysLinux_O_TMPFILEsysLinux_IN_NONBLOCKsysLinux_IN_CLOEXECsysLinux_IN_ACCESSsysLinux_IN_ATTRIBsysLinux_IN_CLOSE_WRITEsysLinux_IN_CLOSE_NOWRITEsysLinux_IN_CREATEsysLinux_IN_DELETEsysLinux_IN_DELETE_SELFsysLinux_IN_MODIFYsysLinux_IN_MOVE_SELFsysLinux_IN_MOVED_FROMsysLinux_IN_MOVED_TOsysLinux_IN_OPENsysLinux_IN_DONT_FOLLOWsysLinux_IN_MASK_ADDsysLinux_IN_ONESHOTsysLinux_IN_ONLYDIRsysLinux_IN_EXCL_UNLINKsysLinux_IN_IGNOREDsysLinux_IN_ISDIRsysLinux_IN_Q_OVERFLOWsysLinux_IN_UNMOUNTcinotifyEventSize CTimeZoneCTimeVal CTimeSpecCClockIdsysTimeGetTimeOfDaysysTimeClockGetTimesysTimeClockGetRessize_CTimeSpecofs_CTimeSpec_Secondsofs_CTimeSpec_NanoSeconds size_CTimeValsize_CTimeZone size_CTimeTsysTime_CLOCK_REALTIMEsysTime_CLOCK_MONOTONIC sysTime_CLOCK_PROCESS_CPUTIME_IDsysTime_CLOCK_THREAD_CPUTIME_IDsysTime_CLOCK_MONOTONIC_RAWsysTime_CLOCK_REALTIME_COARSEsysTime_CLOCK_BOOTTIMEsysTime_CLOCK_REALTIME_ALARMsysTime_CLOCK_BOOTTIME_ALARMEntropySystemMissing entropyGather EntropyCtx entropyOpen entropyCloseentropyMaximumSizeEntropySyscall initializenextnextList nextDoublekeySizerunGenGenRng GenParamsgenMaxSizeIntegralgenMaxSizeArraygenMaxSizeStringgenRng genWithRng genWithParamsudfSeed getGenParamsnumTests defaultConfigConfig listTests testNameMatchdisplayOptions helpRequested DisplayOptionDisplayTerminalErrorOnlyDisplayGroupOnlyDisplayTerminalVerboseSeed parseArgs configHelpPropertyTestArg PropertyEOA PropertyArgPropertyBoolean PropertyNamedPropertyBinaryOp PropertyAnd PropertyFailcheckHasSucceedcheckHasFailedHasTests TestResultPropertyResultrunCheck PlanStateplanRngplanValidations planParams planFailures HasFailures GroupResultPropertySuccessPropertyFailed fqTestNamegroupHasSubGrouppropertyToResult diffBlame CheckMain runCheckMain TestStateconfiggetSeedindent testPassed testFailedtestPath TimingPlan runTimingPlan MainConfigmainHelpmainListBenchs mainVerbose mainOtherFileName_InvalidContainsNullByteContainsSeparator EncodingErrorUnknownTrailingBytesFilePath_InvalidContiguousPathSeparatorpathSeparatorPOSIXfileNameToStringfileNameToLStringGHC.IO.Handle.TypesHandlehGetNonBlockinghGetSome FileMappingfileMappingToFinalPtr FileMapReadFfileMappingPtrfileMappingSizefileMappingUnmapMemorySyncFlagMemorySyncAsyncMemorySyncSyncMemorySyncInvalidate MemoryAdviceMemoryAdviceNormalMemoryAdviceRandomMemoryAdviceSequentialMemoryAdviceWillNeedMemoryAdviceDontNeedMemoryProtection MemoryMapFlagMemoryMapSharedMemoryMapPrivate memoryMap memoryUnmap memoryAdvise memoryLock memoryUnlock memoryProtect memorySyncsysconfPageSizeMemoryProtectionNoneMemoryProtectionReadMemoryProtectionWriteMemoryProtectionExecute