!/9       !"#$%&'()*+,-./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{|}~                               !"#$%&!'!(!)!*!+!,-./0123456789:;<=>?@ABCDEFGHIJK"L"M"N"O"P"Q"R"S"T"U"V"W"X"Y"Z"["\"]#^#_#`$a$b%c%d%e%f%g%h%i%j%k%l&m&n&o&pqrstuvwxyz{|}~'''''''''''''''((((((((((((((((((((()))))))))))))***********++++++++++++++++++++++++++     ,,--------- - - - -g BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone*1FT6+ . BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableSafe*1FT7KIHJ/None *1FT8JK0 BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone*1FT:L foundationElement type of a collectionL1 BSD-style Foundation experimentalportableNone *01<CFKTVK M foundation&A set of methods for ordered colectionN foundationCheck if a collection is emptyO foundation,Length of a collection (number of Element c)P foundation1Check if a collection contains a specific elementThis is the inverse of Q.Q foundation;Check if a collection does *not* contain a specific elementThis is the inverse of P.R foundation'Get the maximum element of a collectionS foundation'Get the minimum element of a collectionT foundationADetermine is any elements of the collection satisfy the predicateU foundationADetermine is all elements of the collection satisfy the predicateV foundation1Smart constructor to create a NonEmpty collectionsIf the collection is empty, then Nothing is returned Otherwise, the collection is wrapped in the NonEmpty propertyW foundationsame as VZ, but assume that the collection is non empty, and return an asynchronous error if it is.Y foundation:Return True if all the elements in the collection are TrueZ foundation=Return True if at least one element in the collection is TrueMNORSTUPQVWXYZ2 BSD-style foundation experimentalportableNone*1FTU[ foundation-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"\ foundation>Mutable collection type used for incrementally writing chunks.] foundation)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 )._ foundationCountOf of a chunk` foundationCountOf of a chunk[]\_^ `3 BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone *-1FSTha foundationIFold1's. Like folds, but they assume to operate on a NonEmpty collection.b foundationLeft associative strict fold.c foundationRight associative lazy fold.d foundation/Give the ability to fold a collection on itselfe foundation%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 foundation&Right-associative fold of a structure. @foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...)g foundationSRight-associative fold of a structure, but with strict application of the operator.abcdfeg4 BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone *1;=FTikyh foundation.Collection of elements that can indexed by inthji5None*17FTmZk foundationKA monomorphic functor that maps the inner values to values of the same typekl6 BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone *1;=FTom foundation1Collection of things that can be looked up by Keymnop7 BSD-style*Nicolas Di Prima <nicolas@primetype.co.uk> experimentalportableNone*1FT q foundationPFunctors representing data structures that can be traversed from left to right.Mostly like base's  Traversable! but applied to collections only.r foundationMap 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 8.s foundationEvaluate each actions of the given collections, from left to right, and collect the results. For a version that ignores the results, see 9t foundationMap 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 :.u foundationEvaluate each actions of the given collections, from left to right, and collect the results. For a version that ignores the results, see ;v foundationMap 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 <w foundationEvaluate 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 >. foundationEvaluate each monadic action in the collection from left to right, and ignore the results. For a version that doesn't ignore the results see ?.x foundationx is tI with its arguments flipped. For a version that ignores the results see @.y foundationy is wP with its arguments flipped. For a version that doesn't ignore the results see A. qrtsuvwxyB BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone*1FTz foundationjCollection of things that can be made mutable, modified and then freezed into an MutableFreezed collection z{|}~ BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone*1FTD !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPCNone*1DFTTQ BSD-style Foundation experimentalportableNone*1FT foundation!Print a string to standard output foundation0Print a string with a newline to standard output foundation+Get the arguments from the terminal commandNOZ[Z[OND BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone*1FT3RSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None*1;FT foundation/Method to support basic trigonometric functions foundationthe famous pi value foundationsine foundationcosine foundationtan foundationsine-1 foundationcosine-1 foundation tangent-1 foundationhyperbolic sine foundationhyperbolic cosine foundationhyperbolic tangent foundationhyperbolic sine-1 foundationhyperbolic cosine-1 foundationhyperbolic tangent-1ENone *+1FTV foundationMonad that can ensure cleanup actions are performed even in the case of exceptions, both synchronous and asynchronous. This usually excludes continuation-based monads. foundationiA generalized version of the standard bracket function which allows distinguishing different exit cases. foundationMonad that can catch exception foundationMonad that can throw exception foundation(Throw immediatity an exception. Only a 1 monad will be able to catch the exception using  foundationacquire some resource foundationcleanup, no exception thrown foundation>cleanup, some exception thrown. The exception will be rethrown foundation)inner action to perform with the resource None*1FT4FSafe *+1FTMLGNone*+1FT% foundationBasic Transformer class foundationGLift a computation from an inner monad to the current transformer monadHNone*1FT foundationIdentity TransformerINone*1FT %ML321None*1FNT foundationState TransformerNone*+1FT foundationReader TransformerNone *+1FTJNone*1;FT foundationIEEE754 Floating Point BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone *1;=FT foundationRound up, to the next integral.Also known as ceiling foundation$Round down, to the previous integralAlso known as floor foundationGTruncate to the closest integral to the fractional number closer to 0.TThis is equivalent to roundUp for negative Number and roundDown for positive Number foundationRound to the nearest integral roundNearest 3.64 > roundNearest 3.4 3 foundation-types that have sign and can be made absolute foundationSign of a signed number(    %$'&(%$'&    None *016FT foundation n act performs the action n times, gathering the results.MLYXW321ML321YXWKNone *1FQTVލ foundation<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. foundation%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. foundationWProvide new output to be sent downstream. This constructor has three fields: the next Pipe< to be used, a finalization function, and the output value. foundation^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. foundationProcessing with this Pipe) is complete, providing the final result. foundation4Require running of a monadic action to get the next Pipe. foundationEReturn leftover input, which should be provided to future operations. foundation Await for a value from upstream. foundationSend a value downstream. foundationSame as W, but additionally takes a finalizer to be run if the downstream component terminates. foundation\Provide leftover input to be consumed by the next component in the current monadic binding. foundation%Run a conduit pipeline to completion. foundation*Run a pure conduit pipeline to completion. foundationRun a conduit pipeline in a ! context for acquiring resources. foundationInternal: run a Pipe foundationPSend the output of the first Conduit component to the second Conduit component. foundation finalizerL BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone*1FT foundation?Simple helper to split a list repeatly when the predicate matchM BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone*017;<=>FKT% foundation&A set of methods for ordered colection foundation*Take the first @n elements of a collection foundation)Take the last @n elements of a collection foundation*Drop the first @n elements of a collection foundation)Drop the last @n elements of a collection foundation*Split the collection at the @n'th elements foundation7Split the collection at the @n'th elements from the end foundation:Split on a specific elements returning a list of colletion foundation1Split a collection when the predicate return true foundationYSplit a collection when the predicate return true starting from the end of the collection foundation'Split a collection at the given element  foundationFReturn the longest prefix in the collection that satisfy the predicate  foundationFReturn the longest prefix in the collection that satisfy the predicate  foundationThe  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"  foundation  xs xss is equivalent to ( (  xs xss)). It inserts the list xs in between the lists in xss and concatenates the result.  foundation2Split a collection while the predicate return true foundationZSplit a collection while the predicate return true starting from the end of the collection foundation2Filter all the elements that satisfy the predicate foundationFPartition the elements that satisfy the predicate and those that don't foundationReverse a collection foundationyDecompose a collection into its first element and the remaining collection. If the collection is empty, returns Nothing. foundationDecompose a collection into a collection without its last element, and the last element If the collection is empty, returns Nothing. foundation+Prepend an element to an ordered collection foundation*Append an element to an ordered collection foundation(Find an element in an ordered collection foundation=Sort an ordered collection using the specified order function foundation)Create a collection with a single element foundation/get the first element of a non-empty collection foundation.get the last element of a non-empty collection foundationGExtract the elements after the first element of a non-empty collection. foundationGExtract the elements before the last element of a non-empty collection. foundationECreate a collection where the element in parameter is repeated N time foundationZTakes two collections and returns True iff the first collection is a prefix of the second. foundationZTakes two collections and returns True iff the first collection is a suffix of the second.  foundationZTakes two collections and returns True iff the first collection is an infix of the second.! foundation'Try to strip a prefix from a collection" foundation'Try to strip a suffix from a collection%   !   "N BSD-style foundation experimentalportableNone *01;=>?FKT'R$ foundation$ takes two collections and returns a collections of corresponding pairs. If one input collection is short, excess elements of the longer collection are discarded.% foundationLike $, but works with 3 collections.& foundationLike $, but works with 4 collections.' foundationLike $, but works with 5 collections.( foundationLike $, but works with 6 collections.) foundationLike $, but works with 7 collections.* foundation*q transforms a collection of pairs into a collection of first components and a collection of second components.+ foundationLike *0, but works on a collection of 3-element tuples., foundationLike *0, but works on a collection of 4-element tuples.- foundationLike *0, but works on a collection of 5-element tuples.. foundationLike *0, but works on a collection of 6-element tuples./ foundationLike *0, but works on a collection of 7-element tuples.1 foundation1 generalises $j by zipping with the function given as the first argument, instead of a tupling function. For example, 1 (+)U is applied to two collections to produce the collection of corresponding sums.2 foundationLike 1, but works with 3 collections.3 foundationLike 1, but works with 4 collections.4 foundationLike 1, but works with 5 collections.5 foundationLike 1, but works with 6 collections.6 foundationLike 1, but works with 7 collections.#$%*+&'(),-./0123456 BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone *1;=FT)%JKLMNORSTUPQVWXYZ[]\_^`abcdfeghjiklmnopqrtsuvwxyz{|}~   !   "#$%*+&'(),-./0123456#$%*+&'(),-./LkldfegabcqrtsuvwxyMNORSTUPQYZVWX   !   "z{|}~hjimnop0123456[]\_^`JK BSD-style*Nicolas Di Prima <nicolas@primetype.co.uk>statbleportableNone*1FT.77 BSD-styleHaskell Foundation experimentalportableNone *1;<=FT3D foundationUExtending the Storable type class to the types that can be sequenced in a structure.G foundation&Storable type of self determined size.K foundationlike H but at a given offset.L foundationlike I but at a given offset.<oDFEGHIJKLMNOPGHIDFE<JoKLMNOP None*1FT< foundationUnsafe Shift Left Operator foundationUnsafe Shift Right Operator foundation&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 foundation(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 = 8 foundationNumber to Align foundationAlignment (power of 2) foundationNumber to Align foundationAlignment (power of 2)~}|{zyxwvutsrqp~}|{zyxwvutsrqpO BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone*1FTG foundation5Return the element at a specific index from a Bitmap.5If the index @n is out of bounds, an error is raised. foundationMReturn the element at a specific index from an array without bounds checking.NReading from invalid memory can return unpredictable and invalid values. use  if unsure. foundation&make an array from a list of elements. foundationtransform an array to a list. foundation"Check if two vectors are identical foundationCompare 2 vectors foundation7Append 2 arrays together by creating a new bigger arrayTODO completely non optimized P BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone*1FKTQ foundationBAn error related to the evaluation of a Partial value that failed.?it contains the name of the function and the reason for failure foundationPartialiality wrapper. foundation"Throw an asynchronous PartialError foundationCCreate a value that is partial. this can only be unwrap using the  function foundationDewrap a possible partial value foundation*Partial function to get the head of a list foundation1Partial function to grab the value inside a Maybe   BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone *1;=FTR/! #"0/.-,+*)(5678>=<A@?B/0/.-,+*)(B>=<65A@?87#"! QIBSD-style -- Maintainer : Alfredo Di Napoli <alfredo.dinapoli@gmail.com> experimentalportableNone %*1CDFQTV_ foundationReturns 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). foundationReturns A* 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). foundationFold a  leftwards strictly. Implemented internally using a double fold on the nested Array structure. Other folds implemented analogously. foundationEquality 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*1DFTa_  RNone*1FTo  foundation9Incremental 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 foundation.Associate type when finalizing the state with  foundation?Associate type when initializing the state (e.g. a Key or seed) foundationCreate a new Hashing context foundationCreate a new Hashing context foundation.Finalize the state and returns the hash result foundation:Mix a Word8 (Byte) into the state and return the new state foundation4Mix a Word16 into the state and return the new state foundation4Mix a Word32 into the state and return the new state foundation4Mix a Word64 into the state and return the new state foundation=Mix an arbitrary sized unboxed array and return the new state S BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalgoodNone*1DFTv: foundation5Sip State 1-3 (1 compression rounds, 3 digest rounds) foundation5Sip State 2-4 (2 compression rounds, 4 digest rounds) foundationSiphash Hash value foundation SigHash Key foundationsame as hash], except also specifies the number of sipround iterations for compression (C) and digest (D).T BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalgoodNone*1DFT!  foundationFNV1a 64 bit state foundationFNV1a 32 bit state foundationFNV1 64 bit state foundationFNV1 32 bit state foundationFNV1(a) hash (64 bit variants) foundationFNV1(a) hash (32 bit variants) foundation6compute FNV1 (32 bit variant) of a raw piece of memory foundation7compute FNV1a (32 bit variant) of a raw piece of memory foundation6compute FNV1 (64 bit variant) of a raw piece of memory foundation7compute FNV1a (64 bit variant) of a raw piece of memory BSD-style FoundationstableportableSafe*1FT8  BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone*1FT BSD-styleHaskell Foundation experimentalportableNone *1;<=FQTV foundation Foundation's Parser monad.-Its implementation is based on the parser in memory. foundationresult of executing the parser over the given input foundation!the parser failed with the given  ParserError foundation3the parser complete successfuly with the remaining Chunk foundation+the parser needs more input, pass an empty Chunk or mempty3 to tell the parser you don't have anymore inputs. foundationcommon parser error definition foundation meaning the parser was short of CountOf Element of input. foundation-The parser needed more data, only when using  parseOnly foundation when using element foundation when using elements or string foundationthe satisfy or satisfy_ function failed, foundation"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. foundation*Run a Parser on a ByteString and return a  foundationparse 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). foundation4helper 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...")  foundation,Get the next `Element input` from the parser foundationApeek the first element from the input source without consuming itReturns ?$ if there is no more input to parse. foundation/take one element if satisfy the given predicate foundation/take one element if satisfy the given predicate foundationCTake the remaining elements from the current position in the stream foundation!consume every chunk of the stream foundation.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 ','),V,VNone*1FT; foundation$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*1FT foundationrun the builder and return a  alias to "This function is not safe, prefer . None*1FTUNone  *1DFTV BSD-style*Nicolas Di Prima <nicolas@primetype.co.uk> provisionalportableNone*1FTVWSafe*1FT X(c) Vincent Hanquez 2014-2017 BSD-styleVincent Hanquez provisionalnon-portable (requires POSIX)None *1FT      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdeYNone*1FT      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdeZ(c) Vincent Hanquez 2014-2017 BSD-styleVincent Hanquez provisionalnon-portable (requires Linux)None*1FTfghijklmnopqrstuvwxyz{|}~[Haskell foundationNone*1FT\ BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone*1FT] BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalGoodNone *1FTV foundationqtry to fill the ptr with the amount of data required. Return the number of bytes, or a negative number otherwise BSD-style FoundationstablegoodNone*1FTÞ foundationGet some of the system entropy^None*1FT" foundation7A monad constraint that allows to generate random bytes_None*1FT foundation[A simple Monad class very similar to a State Monad with the state being a RandomGenerator. foundation,A Deterministic Random Generator (DRG) class foundation!Initialize a new random generator foundation5Initialize a new random generator from a binary seed.If ?S is returned, then the data is not acceptable for creating a new random generator. foundation)Generate N bytes of randomness from a DRG foundationGenerate a Word64 from a DRG foundation6Run a pure computation with a Random Generator in the  ` BSD-styleNone*1DFT0 foundationState of Xoroshiro128 plusaNone*1FTu foundationRNG 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 *1FTV- foundationGAn 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.bNone &'*1CFQTV foundationGenerator monad cNone*1FTw foundationoptional user specified seed foundationParameters for the generatoradefault: * 32bits long numbers; * array of 512 elements max; * string of 8192 bytes max. foundation1the number of tests to perform on every property. default: 100 foundation create the default configurationsee Config for detailsdNone %*1;=FT foundation'How to generate an arbitrary value for a foundation"Call one of the generator weightede BSD-style Foundation experimentalportableNone *1;<=FKT foundationCSV Type foundationCSV Row foundation CSV field foundationhelper function to create a  foundation'heler function to create a FieldString.This function will findout automatically if an escaping is needed. if you wish to perform the escaping manually, do not used this functionf BSD-style Foundation experimentalportableNone *1;<=FT`  foundation-serialise the CSV document into a UTF8 string  foundation<serialise the CSV document into a UTF8 encoded (Block Word8)     gNone *1;=FTF foundation'A linked-list of arguments to this test foundation.The type of check this test did for a property foundation8Running a generator for a specific type under a property foundation4A property that check for equality of its 2 members. foundationBA property that check for a specific comparaison of its 2 members.This is equivalent to  but with  foundationBA property that check for a specific comparaison of its 2 members.This is equivalent to  but with 0 and a given method to pretty print the values. foundation@A conjuctive property composed of 2 properties that need to pass foundation3name of the function used for comparaison, e.g. (<) foundation#function used for value comparaison foundationvalue left of the operator foundationvalue right of the operator foundation3name of the function used for comparaison, e.g. (<) foundation#function used for value comparaison foundation(function used to pretty print the values foundationvalue left of the operator foundationvalue right of the operator4h BSD-styleFoundation maintainersNone&'*1CFKQTV foundation!different type of tests supported foundationnumber of tests and failures foundationName of a test Followed foundationResult of a property run" foundationName of a test !"iNone&'*1<CFQTV BSD-styleFoundation maintainersNone &'*1CFQTV !"#$% "!#$%! BSD-styleFoundation maintainersNone&'*1CFKQTV foundation9internal check monad for facilitating the tests traversal& foundation Run tests&& BSD-style foundation experimentalportableNone*1FT, foundation4Enumeration of the known GHC supported architecture.; foundation9get the operating system on which the program is running.Either return the known 5 or a strict  of the OS name.This function uses the base's  function.< foundation<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.= foundationget the compiler nameKget the compilerName from base package but convert it into a strict String> foundation*returns the number of CPUs the machine hasPUTSR4;9:,-./0123458679:;<=>58679:;,-./01234<>;9:4=PUTSR" BSD-styleFoundation maintainersNone *-1FKTK foundationAn amount of nanosecondsM foundationAn amount of nanosecondsKLMNMNKL#None*1FT] foundationA 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)^ foundationCreate a new precise stop watch record the time at start of call_ foundation1Get the number of nano seconds since the call to ^]^_]^_$None*1FTG`a`a% BSD-styleFoundation maintainersNone*1FTj foundationGSimple one-time measurement of time & other metrics spent in a functionk foundation6In depth timing & other metrics analysis of a function bcdefghijk fghibcdejk& BSD-styleFoundation maintainersNone *1FKTllj BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone*16FT$p foundation0Class of product types that have a third elements foundation1Class of product types that have a second elementv foundation0Class of product types that have a first elementy foundationStrict tuple (a,b,c,d){ foundationStrict tuple (a,b,c)} foundationStrict tuple (a,b)pqrstuvwxyz{|}~k BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalgoodNone*1FT* foundation"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;=FTC  foundationIPv6 data type foundationequivalent to `::` foundationequivalent to `::1` foundation serialise to human readable IPv6/toString (fromString "0:0:0:0:0:0:0:1" :: IPv6) foundation#create an IPv6 from the given tuple foundationdecompose an IPv6 into a tuple foundation#IPv6 Parser as described in RFC4291for more details: 4https://tools.ietf.org/html/rfc4291.html#section-2.2which is exactly:``` ipv6ParserPreferred  | ipv6ParserIPv4Embedded  | ipv6ParserCompressed ``` foundation1IPv6 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` foundation'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` foundation1IPv6 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``::`  ' BSD-style*Nicolas Di Prima <nicolas@primetype.co.uk> experimentalportableNone *1;<=FKTG foundationIPv4 data type foundation "0.0.0.0" foundation "127.0.0.1" foundationParse a IPv4 address BSD-style FoundationNone*1FTH   BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone*1FTKx foundation:Alias to Prelude String ([Char]) for compatibility purposeG !"#$%&'(>A)*+,-./0123@?4DEF56789:;=CBKIHJQ\`_^]abcdegfih    %$'&CEDGFIHMNORSTUPQVYZdfeg   !   "pqrstuvwxyz{|}~h}~{|yzvwxstupqrid"! EDGFIHKIHJ% $G%$'&   3@?4DEF(>A)6=CB-./089:;7,125+* &'MNORSTUPQYZ   !   "VdfegacbQ`_^]#\gfeC( BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone *-1;=>?FTW foundationRA 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<FTX#* BSD-style foundation experimentalportableNone*1<FTx,  foundationPath 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  foundation'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 l type family foundation#the associated prefix of the given pathin the case of a mn-, it is a void (i.e. `()`) in the case of a mo!, it is the schema, host, port... foundation'the associated suffix of the given pathin the case of the mn/, it is a void (i.e. `()`) in the case of the mo!, it is a the query, the fragment foundation"join a path entity to a given path foundation+split the path into the associated elements foundation+build the path from the associated elements foundation*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 foundation"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.hs foundationget 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  foundationget 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*1FT foundation'errors related to FileName manipulation foundation0this means a null byte was found in the FileName foundation5this means a path separator was found in the FileName foundationencoding error foundation"some unknown trainling bytes found foundation+A filename (or path entity) in the FilePath  Authorised"""."".." "foundation" Unauthorised"/""file/""/file" "file/path" foundation)error associated to filepath manipulation foundation2this mean there were 2 contiguous path separators.9This is not valid in Foundation's FilePath specifications foundation$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//" foundation"information about type of FilePathA file path being only  or . foundation.define the Path separator for POSIX systems : / foundation convert a FileName into a String?This function may throw an exception associated to the encoding foundation*conversion of FileName into a list of Char"this function may throw exceptions foundation,conversion of a FilePath into a list of Char"this function may throw exceptions foundation/build a file path from a given list of filename7this is unsafe and is mainly needed for testing purpose foundation(build a file name from a given ByteArray7this is unsafe and is mainly needed for testing purpose  m BSD-style foundation experimentalportableNone*1FTp BSD-style Foundation experimentalportableNone*1FT foundation2list 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 file foundationClose a handle foundation-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. foundationhGetNonBlocking 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 . foundationLike , 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. foundation 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@ foundationIRead a binary file and return the whole content in one contiguous buffer.nmlkj BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone*1FT_Z[nmlkjZ[nmlkjNone*1FTb foundationOperator version of . foundationSend values downstream.2qNone *1<FTVi  BSD-style Foundation experimentalportableNone *1;<=FKT          r BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone*1FT foundationgContains all the information related to a file mapping, including the size and the finalizer function. foundationkFrom a file mapping, create a final ptr which will automatically unmap memory when the pointer is garbage.s(c) Vincent Hanquez 2014 BSD-styleVincent Hanquez provisionalnon-portable (requires POSIX)None*1FT foundationMemory synchronization flags foundationperform asynchronous write. foundationperform synchronous write. foundationinvalidate cache data. foundationAdvice to put on memory.only define the posix one. foundation no specific advice, the default. foundationBExpect page references in random order. No readahead should occur. foundationRExpect page references in sequential order. Page should be readahead aggressively. foundationIExpect access in the near future. Probably a good idea to readahead early foundation(Do not expect access in the near future. foundationMemory protection foundation Mapping flag foundation)memory changes are shared between process  foundation%memory changes are private to process  foundationMap pages of memory.vIf fd is present, this memory will represent the file associated. Otherwise, the memory will be an anonymous mapping.use mmap  foundationUnmap pages of memoryuse munmap  foundation7give advice to the operating system about use of memorycall madvise  foundation%lock a range of process address spacecall mlock foundation'unlock a range of process address spacecall munlock foundation set protection of memory mappingcall mprotect foundation4memorySync synchronize memory with physical storage.FOn an anonymous mapping this function does not have any effect. call msync foundation&Return the operating system page size.call sysconf  foundation*The address to map to if MapFixed is used. foundationThe length of the mapping foundation1the memory protection associated with the mapping foundation     tNone*1FTӪ, BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone*1FT foundation*Map in memory the whole content of a file.COnce the array goes out of scope, the memory get (eventually) unmap foundation*Map in memory the whole content of a file,- BSD-style foundation experimentalportableNone*1FT  foundation TODO this is not implemented yet       uvwxyzxy{x|}x|~x|x|uuxyxyxyxyxyxxxxxxxxyxyxyxyxyxyxyx|x|uxyxyuxxxxyxyxyuuuuuxxxxxxyuxuuxxxxxxuxyxyuxxuuuxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx x x x x xxxxxxxxxxxxxxxxx| x|!x|"x|#x|$x|%x&'x&(x&)x&*x&+x&,x&-x&.x/0x/1x/2xy3xy4xy5xy6xy7xy8xy9xy:xy;xy<xy=xy>x?@xAuBuCuDuEuFuGuHuIuJuKLMNLMOLMPLMQLMRLMSLMTLMULMVLMWLMXLMYLMZLM[LM\LM]LM^LM_LM`LMaLMbLMcLMdLMeLMfLMgLhiLjkLlmLnoLpqLprLpsLptLpuLvwLxyLxzLx{Lx|Lx}Lx~LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL//0l1111111111111 1 2 2 2 2223333333444556666 7!7<7=7>7?787:7A7@B"B#B$B%B&B'B(B)B*B+B,B-B./0i123456789:;<=>?@EAEBECEDEEEF G HGIGJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkllmnopqrstuJvJwJxJyJzJ{|}~KKKKKKKKKKKKKKKMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNN      !"#$%&'() * + , -O.O/P0P1P2P3Q4R5S6S7T8T9T:T;<=>?@ABBCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwZY^[xy^z^{^|^}^~___________bddddd]deeeeeeeeeeeeeeeeeeedfffffffgggggggggggghhhhhhh!!!!!!""""""""""""""""""###$$%%%%%%%%%%&&&&jjjjjj j j j j j jjjjkkx !'"'''x'''#'$'%'&'''(')'*'+,-.(/(0(1(2(3(4(5(6(7(8(9(:(;(<(=(>(?(@(A(B(C)D)D)E)F)G)H)I)J)K)L)M)N)O*P*Q*R*S*T*U*V*W*X*Y*Z+[+n+\+]+^+_+`+a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p+q+r+sptpupvpwpxpyz{|}~qqqqq,,-----------o-o-27;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxLLLLLLLLLLLCLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL:L>L;L?LLLLLHHxxKKKKKKKKKKKKKKLLLLLLLOOOOOOOOOOOOOOOPPPPPQQQQRRRRRRRRRRSSSSSTTTTTTTTLLLLLLUVVVVVWW W W W W WWXXXXXXXXXXXXXXXXX X!X"X#X$X%X&X'X(X)X*X+X,X-X.X/X0X1X2X3X4X5X6X7X8X9X:X;X<X=X>X?X@XAXBXCXDXEXFXGXHXIXJXKXLXMXNXOXPXQXRXSXTXUXVXWXXXYXZX[X\X]X^X_X`XaXbXcXdXeXfXgXhXiXjXkXlXmXnXoXpXqXrXsXtXuXvXwXxXyXzX{X|X}X~XXXXXXXXXXXXXXXXXXXXXXZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[[[[[[[[[[[[[[[[\\]]]]]`N````aNaNabbbbbbbbbbccccccccccccccccceegggggggggghhhhhhhhhhhhhhhhhhi i ! xx+ + ++++++++xpprrrrrrrs s!s"s#s$s%s&s's(s)s*s+s,s-s.s/s0s1s2s3s4s5s6s7s8s9s:(foundation-0.0.21-JsgFzoE3wDU8Tr7q47A5wp 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.Format.CSVFoundation.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.Format.CSV.TypesFoundation.Format.CSV.BuilderFoundation.Check.PropertyFoundation.Check.TypesFoundation.Check.PrintFoundation.TupleFoundation.Hashing.HashableElementFoundation.VFSFilePathURIFoundation.IO.FileFoundation.Format.CSV.Parser"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 fromListNtoList<>memptymappendmconcat<*>pure*>BoundedEnumEqMonadFunctorOrdGHC.ShowShowData.Typeable.InternalTypeableIsString Applicative 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 ExceptionpartitionEithersrightsleftseither 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.8-8QjArDsw3GWCcbHE5iqtz3Basement.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$fMonadFixStateT $fMonadStateT$fApplicativeStateT$fFunctorStateTReaderT runReaderT MonadReader ReaderContextask$fMonadReaderReaderT$fMonadBracketReaderT$fMonadCatchReaderT$fMonadThrowReaderT$fMonadFailureReaderT$fMonadIOReaderT$fMonadTransReaderT$fMonadFixReaderT$fMonadReaderT$fApplicativeReaderT$fFunctorReaderTExceptT runExceptT$fMonadIOExceptT$fMonadTransExceptT$fMonadReaderExceptT$fMonadFixExceptT$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$fShowParseError0$fExceptionParseError$fFunctorResult $fShowResult$fAlternativeParser$fMonadPlusParser $fMonadParser$fApplicativeParser$fFunctorParser $fShowAnd $fShowNoMore $fEqNoMore$fEqAnd$fShowCondition $fEqConditiontoString getEntropy MonadRandomgetRandomBytesgetRandomWord64 getRandomF32 getRandomF64MonadRandomStaterunRandomState RandomGen randomNew randomNewFromrandomGeneraterandomGenerateWord64randomGenerateF32randomGenerateF64withRandomGeneratorRNGv1RNGGen Arbitrary arbitrary frequencyoneofbetweenCSVRecordtoRowfromRowRowIsFieldtoField fromFieldEscapingNoEscapeEscape DoubleEscapeField FieldInteger FieldDouble FieldStringintegralfloatcsvStringBuilderrowStringBuilderfieldStringBuildercsvBlockBuilderrowBlockBuilderfieldBlockBuilderrowC IsPropertypropertyPropertyPropunProp PropertyCheckforAll===propertyComparepropertyCompareWith 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 sinkHandlesinkListrecordCrecord_filerecordfield fileMapReadfileMapReadWithURIPath URIFragmentURIQuery URIAuthority URISchema $fPathURI builderLiftSystem.Posix.TypesCModeCOffForeign.C.TypesCCharCSCharCUCharCShortCUShortCIntCUIntCLongCULongCLLongCULLongCBoolCFloatCDoubleCPtrdiffCSizeCWchar CSigAtomicCClockCTime CUSeconds CSUSecondsCIntPtrCUIntPtrCIntMaxCUIntMaxBasement.FinalPtrwithUnsafeFinalPtr touchFinalPtr withFinalPtrwithFinalPtrNoTouch castFinalPtrtoFinalPtrForeign toFinalPtrfinalPtrSameMemoryFinalPtr FinalForeign allocaBytesBasement.Sized.Listscanl1'scanl'foldlmapimapupdateAtindex indexStatic createFromcreateemptytoListN_toListNListNunListN IdentityT runIdentityTControl.Monad.FixMonadFixmfixPipeYieldAwaitDonePipeMLeftoverrunPipe MonadResource liftResourceT unResourceT unConduit runResourceT wordsWhen unsafeIndex vFromListvToListequalvCompare unsafeWrite unsafeReadwritereadconcat partialErrorfromJust fromRightfromLefthashMix8 HashResulthashEnd HashInitParamhashNew hashNewParam hashMix16 hashMix32 hashMix64 hashMixBytesSipHashSipKeymixBa FNV1Hash64 FNV1Hash32 fnv1_32_mixBafnv1a_32_mixBa fnv1_64_mixBafnv1a_64_mixBaBasement.String.Builder runUnsaferunemitCharemitunsafeStringBuildersysHsCoreGetErrno 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 entropyCloseentropyMaximumSize initializenextnextList nextDoublekeySizerunGenGenRng GenParamsgenMaxSizeIntegralgenMaxSizeArraygenMaxSizeStringgenRng genWithRng genWithParamsudfSeed getGenParamsnumTests defaultConfigConfig listTests testNameMatchdisplayOptions helpRequested DisplayOptionDisplayTerminalErrorOnlyDisplayGroupOnlyDisplayTerminalVerboseSeed parseArgs configHelpunCSVunRowPropertyTestArg PropertyEOA PropertyArgPropertyBoolean PropertyNamedPropertyBinaryOp PropertyAnd PropertyFailcheckHasSucceedcheckHasFailedHasTests TestResultPropertyResultrunCheck PlanStateplanRngplanValidations planParams planFailures HasFailures GroupResultPropertySuccessPropertyFailed fqTestNamegroupHasSubGrouppropertyToResult diffBlame CheckMainFileName_InvalidContainsNullByteContainsSeparator EncodingErrorUnknownTrailingBytesFilePath_InvalidContiguousPathSeparatorpathSeparatorPOSIXfileNameToStringfileNameToLStringGHC.IO.Handle.TypesHandlehGetNonBlockinghGetSome FileMappingfileMappingToFinalPtr FileMapReadFfileMappingPtrfileMappingSizefileMappingUnmapMemorySyncFlagMemorySyncAsyncMemorySyncSyncMemorySyncInvalidate MemoryAdviceMemoryAdviceNormalMemoryAdviceRandomMemoryAdviceSequentialMemoryAdviceWillNeedMemoryAdviceDontNeedMemoryProtection MemoryMapFlagMemoryMapSharedMemoryMapPrivate memoryMap memoryUnmap memoryAdvise memoryLock memoryUnlock memoryProtect memorySyncsysconfPageSizeMemoryProtectionNoneMemoryProtectionReadMemoryProtectionWriteMemoryProtectionExecute