!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmno p q r s t u v w x y z { | } ~                 ! " #$%&' ( ) * + , - . / 01234 5 6 7 89:; < = > ? @ A BCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<= > ? @ A!B!C!D!E!F!G!H!I!J!K!L!M!N!O!PQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~""""############     $$$$$$$$$$%%%% !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_ ` a b cdef&g&h&i&j&k&l&mnopqrstuvwxyz{|'}'~''''''''''''''''(((((((((((((&&))))))))))))))))))))))))))))******+++++++++++++++++++++++++,,!!!!!!!c BSD-style foundation experimentalportableNone)0:DR IPath 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 J'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 - type familyK#the associated prefix of the given pathin the case of a ./-, it is a void (i.e. `()`) in the case of a .0!, it is the schema, host, port...L'the associated suffix of the given pathin the case of the .//, it is a void (i.e. `()`) in the case of the .0!, it is a the query, the fragmentM"join a path entity to a given pathN+split the path into the associated elementsO+build the path from the associated elementsP*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/barQ"get the filename of the given path.If there is no filename, you will receive the  of the Jfilename ("foo.hs" :: FilePath)foo.hs'filename ("foo/bar/baz.hs" :: FilePath)baz.hsRget 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 Sget 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) IJKLMNOPQRS IJKLMNOPQRS IJKLMNOPQRSIJKLMNOPQRS BSD-style foundation experimentalportableNone)0DR^ TODO this is not implemented yet TUVWXYZ[\]^_` TUVWXYZ[\]^_ ^_\]Z[XYVWTUTUVWXYZ[\]^_`1 BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DR2None)0DR3Safe)0DR             4(c) Vincent Hanquez 2014-2017 BSD-styleVincent Hanquez provisionalnon-portable (requires POSIX)None)0DR !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~5None)0DR6(c) Vincent Hanquez 2014-2017 BSD-styleVincent Hanquez provisionalnon-portable (requires Linux)None)0DR7None  )0BDR8None)0DR !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ None)0DR BSD-style FoundationNone)0DR abcdefabcdabcd abcdef  BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DR BSD-style foundation experimentalportableNone)0DRg4Enumeration of the known GHC supported architecture.v9get the operating system on which the program is running.Either return the known p or a strict  of the OS name.This function uses the base's  function.w<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.xget the compiler nameKget the compilerName from base package but convert it into a strict Stringy*returns the number of CPUs the machine hasghijklmnopqrstuvwxyDMLKJ3:98ghijklmnopsqrtuvwxypqrstuvghijklmnowy:983xDMLKJghijklmnopqrstuvwxy BSD-style FoundationstableportableSafe)0DR  BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )09;DR0 "!/.-,+*)('4567=<;@?>A2/.-,+*)('A=<;54@?>76 "!!9 BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)05DR0Class of product types that have a third element1Class of product types that have a second element0Class of product types that have a first elementStrict tuple (a,b,c,d)Strict tuple (a,b,c)Strict tuple (a,b)# BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone ),09;<=DRRA generalized version of indexed accessor allowing access to tuples n'th element.Indexing starts at 1, as  is used to get first element.: BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DIRBAn 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   ;None)09DRIEEE754 Floating Point BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )09;DRRound 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(     $#&%($#&%     < BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalGoodNone )0DRTqtry to fill the ptr with the amount of data required. Return the number of bytes, or a negative number otherwise   BSD-style FoundationstablegoodNone)0DRGet some of the system entropy=None)0DR7A monad constraint that allows to generate random bytes>None)0DR[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-styleFoundation maintainersNone)0DIRAn amount of nanosecondsAn amount of nanosecondsNone)0DRA 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 call1Get the number of nano seconds since the call to ?None)0DRBasic Transformer classGLift a computation from an inner monad to the current transformer monad@Safe)0DRUTANone )0DRTMonad 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  BNone)0DRIdentity Transformer  CNone)0DR  $UT210None)0DRReader Transformer           None)0DR None)0DLRState Transformer !"#$%&'(  !"#$%&'(None )/05DR)) n act performs the action n times, gathering the results.)GFEUT210)UT210GFE))None)09DR*/Method to support basic trigonometric functions+the famous pi value,sine-cosine.tan/sine-10cosine-11 tangent-12hyperbolic sine3hyperbolic cosine4hyperbolic tangent5hyperbolic sine-16hyperbolic cosine-17hyperbolic tangent-1*+,-./0123456789*+,-./01234567*+,-./01234567* +,-./0123456789D BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DR%      !"#$%&' BSD-style Foundation experimentalportableNone)0DR:!Print a string to standard output;0Print a string with a newline to standard output<+Get the arguments from the terminal command:;<NOZ[:;<;:Z[<ON:;<ENone)0BDR((( None)0DR=>=>=>=> BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DRB)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgh None)0DR?@?@?@?@FNone )0DORTE<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.i%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.jWProvide new output to be sent downstream. This constructor has three fields: the next Pipe< to be used, a finalization function, and the output value.k^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.lProcessing with this Pipe) is complete, providing the final result.m4Require running of a monadic action to get the next Pipe.nEReturn leftover input, which should be provided to future operations.F Await for a value from upstream.HSend a value downstream.ISame as HW, but additionally takes a finalizer to be run if the downstream component terminates.J\Provide leftover input to be consumed by the next component in the current monadic binding.K%Run a conduit pipeline to completion.L*Run a pure conduit pipeline to completion.MRun a conduit pipeline in a A! context for acquiring resources.oInternal: run a PipeOPSend the output of the first Conduit component to the second Conduit component.BpqrstuvwxyzA{|}BCDE~ijklmnFGHI finalizerJKLMNoOpqA{|BCDE~ijklmnFGHIJKLMNO1pqrstuvwxyzA{|}BCDE~ijklmnFGHIJKLMNoOG BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DRPjCollection of things that can be made mutable, modified and then freezed into an MutableFreezed collectionPQRSTUVWXYZ[\ PQRSUTVWXZ\Y[P QRSTUVWXYZ[\H BSD-style*Nicolas Di Prima <nicolas@primetype.co.uk> experimentalportableNone)0DR ]PFunctors representing data structures that can be traversed from left to right.Mostly like base's  Traversable! but applied to collections only.^Map 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 I._Evaluate each actions of the given collections, from left to right, and collect the results. For a version that ignores the results, see J`Map 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 K.aEvaluate each actions of the given collections, from left to right, and collect the results. For a version that ignores the results, see LbMap 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 McEvaluate each action in the collection from left to right, and ignore the results. For a version that doesn't ignore the results see Nl. 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 O.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 P.dd is `I with its arguments flipped. For a version that ignores the results see Q.ee is cP with its arguments flipped. For a version that doesn't ignore the results see R. ]^_`abcde ]^`_abcde]^_`abcdeS BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DR?Simple helper to split a list repeatly when the predicate matchT BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )09;DRf1Collection of things that can be looked up by KeyfghifghifghiU BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DRjElement type of a collectionjjjV BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DRkIFold1's. Like folds, but they assume to operate on a NonEmpty collection.lLeft associative strict fold.mRight associative lazy fold.n/Give the ability to fold a collection on itselfo%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 o, a strict version of foldl, because the lazy version is seldom useful.MLeft-associative fold of a structure with strict application of the operator.p&Right-associative fold of a structure. @foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...)qSRight-associative fold of a structure, but with strict application of the operator.klmnopqklmnpoq klmnopqW BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )09;DRr.Collection of elements that can indexed by intrstrtsrstXNone)06DRuKA monomorphic functor that maps the inner values to values of the same typeuvuvuvvYNone)0DRwxwxwxZ BSD-style Foundation experimentalportableNone )/0:ADIRT y&A set of methods for ordered colectionzCheck if a collection is empty{,Length of a collection (number of Element c)|1Check if a collection contains a specific elementThis is the inverse of }.};Check if a collection does *not* contain a specific elementThis is the inverse of |.~'Get the maximum element of a collection'Get the minimum element of a collectionADetermine is any elements of the collection satisfy the predicateADetermine is all elements of the collection satisfy the predicate1Smart constructor to create a NonEmpty collectionsIf the collection is empty, then Nothing is returned Otherwise, the collection is wrapped in the NonEmpty propertysame as Z, but assume that the collection is non empty, and return an asynchronous error if it is.:Return True if all the elements in the collection are True=Return True if at least one element in the collection is Trueyz{|}~yz{~|} yz{|}~[ BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)/069:;<DIR%&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 trueZSplit a collection while the predicate return true starting from the end of the collection2Filter all the elements that satisfy the predicateGPartition 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+%'\ BSD-style foundation experimentalportableNone )/09;<=DIR 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.Like , but works with 4 collections.Like , but works with 5 collections.Like , but works with 6 collections.Like , but works with 7 collections.& ] BSD-style foundation experimentalportableNone)0DR-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 BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )09;DRPQRSUTVWXZ\Y[]^`_abcdefghijklmnpoqrtsuvwxyz{~|}ņjuvvnopqklm]^_`abcdeyz{|}~PQRSTUVWXYZ[\rstfghiwx"None)0DR$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*Nicolas Di Prima <nicolas@primetype.co.uk>statbleportableNone)0DR  BSD-styleHaskell Foundation experimentalportableNone )0:DORT 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 ',')@+W+W,$ BSD-styleFoundation maintainersNone)0DRGSimple one-time measurement of time & other metrics spent in a function6In depth timing & other metrics analysis of a function   % BSD-styleFoundation maintainersNone )0DIR  BSD-styleHaskell Foundation experimentalportableNone )09:;DRUExtending the Storable type class to the types that can be sequenced in a structure.&Storable type of self determined size.#like   but at a given offset.$like ! but at a given offset.A !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\9] !"#$%&'( !9"]#$%&'(= !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\^None)0DRRNG 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 )0DRT^GAn 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.]^]^^]]^_ BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableSafe)0DRSQPR None)0DR_Unsafe Shift Left Operator`Unsafe Shift Right Operatora&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 = 16b(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_`aNumber to AlignAlignment (power of 2)bNumber to AlignAlignment (power of 2)~}|{zyxwvutsrqpo_`ab_`~}|{zyxwvutsrqpoab_`ab` BSD-styleNone)0BDR State of Xoroshiro128 plus       BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DR aIBSD-style -- Maintainer : Alfredo Di Napoli <alfredo.dinapoli@gmail.com> experimentalportableNone $)0ABDORTReturns the length of this c8, 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 c. Complexity: O(n) where n0 is the number of chunks, as U.length u is O(1).Fold a c leftwards strictly. Implemented internally using a double fold on the nested Array structure. Other folds implemented analogously.Equality between cX. This function is fiddly to write as is not enough to compare for equality the inner /(s), we need an element-by-element comparison.-c !"#$%&'()*+,-./0123456789:;<=>?@c,c !"#$%&'()*+,-./0123456789:;<=>?@b BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DRA5Return the element at a specific index from a Bitmap.5If the index @n is out of bounds, an error is raised.BMReturn the element at a specific index from an array without bounds checking.NReading from invalid memory can return unpredictable and invalid values. use A if unsure.C&make an array from a list of elements.Dtransform an array to a list.E"Check if two vectors are identicalFCompare 2 vectorsG7Append 2 arrays together by creating a new bigger arrayTODO completely non optimized?dHeIJKLMNOPQRSTUABVWXYCDEFGZ[\]^_`abcdefghijklmnopqrstuvwxyz{|} deRSTUABXGZde=dHeIJKLMNOPQRSTUABVWXYCDEFGZ[\]^_`abcdefghijklmnopqrstuvwxyz{|} BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0BDR cde cedcNone)0DR f9Incremental 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 statef~ f~f ~d BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalgoodNone)0BDR gFNV1a 64 bit statehFNV1a 32 bit stateiFNV1 64 bit statejFNV1 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 memoryghijghijghije BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalgoodNone)0DRk"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)Trueklklkl BSD-style*Nicolas Di Prima <nicolas@primetype.co.uk> experimentalportableNone )09:;DIRmIPv4 data typen "0.0.0.0"o "127.0.0.1"sParse a IPv4 addressmnopqrstuvwxmnopqrsmnopqrsmnopqrstuvwx' BSD-style*Nicolas Di Prima <nicolas@primetype.co.uk> experimentalportableNone )09;DR |IPv6 data type}equivalent to `::`~equivalent to `::1` serialise to human readable IPv6/toString (fromString "0:0:0:0:0:0:0:1" :: IPv6)#create an IPv6 from the given tupledecompose an IPv6 into a tuple#IPv6 Parser as described in RFC4291for more details: 4https://tools.ietf.org/html/rfc4291.html#section-2.2which is exactly:``` ipv6ParserPreferred  | ipv6ParserIPv4Embedded  | ipv6ParserCompressed ```1IPv6 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`'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`1IPv6 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``::`|}~ |}~ |}~|}~(None )0:DR f BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalgoodNone )0BDR5Sip 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).#gNone %&)0ADORTGenerator monad  hNone $)09;DR'How to generate an arbitrary value for a"Call one of the generator weighted/      .      iNone)0DR!optional user specified seed"Parameters 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 details%&'!"#()*+,-./0$123&'!"#()*+,-./0$23%&'!"#()*+,-./0$123jNone )09;DR4'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 pass456789:;<=>?3name of the function used for comparaison, e.g. (<)#function used for value comparaisonvalue left of the operatorvalue right of the operator@ABCD456789:;=>456789:;<=>?@ABCD4k BSD-styleFoundation maintainersNone%&)0ADIORT!different type of tests supportedEnumber of tests and failuresFName of a test FollowedGResult of a property runName of a testHIJKLMNOPEFQRGSTUVWHIJKLMNOPFQRGSTUV HIJKLMNOPEFQRGSTUVWlNone%&)0:ADORTXYGSTXYXY) BSD-styleFoundation maintainersNone %&)0ADORT* BSD-styleFoundation maintainersNone%&)0ADIORTZ9internal check monad for facilitating the tests traversal Run tests Z[\]^_`abcdefghijklmnopqrstuvwZ[\]^_`abcdefghijklmnopqrstuvw& BSD-style FoundationNone)0DR fghijkl klfjihg+ BSD-style foundation experimentalportableNone)0DRx'errors related to FileName manipulationy0this means a null byte was found in the FileNamez5this means a path separator was found in the FileName{encoding 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 manipulation~2this 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)xyz{|}~   xyz{|}~. BSD-style foundation experimentalportableNone)0DRIJKLMNOPQRSIJKLMNOQPRSm BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DRgContains 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.n(c) Vincent Hanquez 2014 BSD-styleVincent Hanquez provisionalnon-portable (requires POSIX)None)0DRMemory synchronization flagsperform 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 mappingoNone)0DRp BSD-style Foundation experimentalportableNone)0DR2list 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. gfedc  BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DRZ[gfedc:;;:Z[gfedc, BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DR*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#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DR:Alias to Prelude String ([Char]) for compatibility purposeH  !"#$%&;>'()*+,-./0<=1ABC2345678:?@ISQPRVYX\^ba`_hijklnm    $#&%BDCFEHG:;npoqyz{~|}XYk:;!  DCFEHGSRQP$ #H$#&%    0<=1ABC&;>'3:?@+,-.56784*/I2)(%\yz{|}~nopqhjiVba`_"^nmlB!None)0DROperator version of O.Send values downstream.ABCDEFGHIJKLMNOEABCDFGHIJKLMON2qrstuvtuwtxytxztx{tx|q}~q}tutututututtttttttututututututxtxq}tutuq}ttttutuqqqqqtttttuqtqqttttttqtutuqttqqqttttttttttttttttttttttttttttttttttttttttttttttttttttt t t t t tttttttttttttxtxtxtxtx tx!t"#t"$t"%t"&t"'t"(t")t"*t+,t+-t+.tu/tu0tu1tu2tu3tu4tu5tu6tu7tu8tu9t:;t<q}=q}>q}?q}@q}Aq}Bq}Cq}Dq}Eq}FGHIGHJGHKGHLGHMGHNGHOGHPGHQGHRGHSGHTGHUGHVGHWGHXGHYGHZGH[GH\GH]GH^GH_GH`GHaGHbGcdGefGghGijGklGmnGmoGmpGmqGmrGmsGtuGtvGwxGwyGz{Gz|Gz}Gz~Gz~GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG00      !"#$%&'()*+,-./0192939495969798999:9;9;9<9<9=9=>?@ABCDEFGHIJKLMNOPQR:S:T:U:V;W;X;Y;Z;[;\]^_`abcdefghijklmnopqrstu=v=w=x=y=z>{>{>|>}>~>>>>>>??AAAAAAh    FFFFFFFFFFFFFFFGGGGGGGGGGGGGHHMHNHOHPHIHKHRHQTTTTU-VVVVVVVWWWX X Y Y Z ZZZZZZZZZZZZZ[[[[[[ [!["[#[$[%[&['[([)[*[+[,[-[.[/[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\P\Q\R\S]T]U]V]W]X]Y"U"T"Y"V#Z#[#\#]#^#_#`#a#b#c#d#effghijklmnopqrstuvwxyz{|}~&$$$$$$$$$$%%%%    abbcddddee '''' '''''' ' ' ' ' ''''(((((((((((((ffg h!h"h#h$hh%j&j'j(j)j*j+j,j-j.j/j0k1k2k(k3k4k5k6)7)8)9**:*;*<*=*>+?+/+@+A+B+C+D+E+F+G+H+I+J+K+L+M+N+O+P+Q+R+S+T+U+VpWpXpYpZp[p\,],^_`a!b!c!d!e!f!g!h971i1i1j2k2l2m2n2o2p2q2r2s2t2u2v2w2x2y2z2{2|2}2~2233333333tttt444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444 4 4 4 4 4445555566666666666 6!6"6#6$6%6&6'6(6)6*6+6,6-6.6/606162636475678W9tt9:9;9<9=9>9?9@9A9B9C9D9E9F9G9H9I9J9K9L9M:N:6:O:S:T:P:Q:R;S;TU<V<W<W<X<Y<Z<[<\<]<^<_=`>a>b>c>deAfAgAhBiBiBjBkBlBmBnBoBpBqBrGsQGsPGsOGsNGsDGsCGsBGsAGsGsGstGsuGsvGswGs GsGsGs8Gs6GsGsGsWGsGs5GsxGsyGsGs8Gs2Gs/Gs:GsKGsOGsGszGs{Gs|E}t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~t~GGGGGGGGGGGFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGGHLHHSSSS!S$S/S0TVVVVVVVVWWWWWXXXXYYYYYZZZZZZ[[[[[[\\\\\\\\\\\ \ \ \ \ \\\]]]]#Z#j$ $!$"%#%#%$%%%%%&%'%(%)%*%+%,^^^-^.^/^0^1^2^3^4^5^6```7`2`8`9`:`;`6aaaa<aa8aWa9a=a>aaaaa?a@aaa aaa"a#a$a(a.a,a0a/a2a1a3a4avaAaBaCaDaEaFaGaHaIaJbvbAb=b>b<bKbWbbbLbMbNbObbbbbPbQbRbSbbTb8b{b9bbbb b"b#b$b*bub2b1b/b0b(b3b4b,b.bbbbbbUbVbWbXbYbZb[b\b]b^b_b`cacbcccdcecfcgchcicjckclcmdndodpdqdrdsdddddndodtdudvdwdxdydzd{d|d}e~eeeeeeeeeeeeeeeeeeee''''''''''(((fffffffffffffffffffffffffffffffffg gggggggggggggggghhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhiiiiiiiiiiiiiiiiii+i,jjjjjjjjjj j j j j jjjkkkk5kkkkkkkkkkkkkkk l!l"*#*#*$*%*%*&*'*(*)***+*,*-*.*/*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+P+QmRmSmTmRmUmVmWnXnYnZn[n\n]n^n_n`nanbncndnenfngnhninjnknlnmnnnonpnqnrnsntnunvnwnxnynzn{n|n}n]t~pppp,(foundation-0.0.16-4FQggEVGP185jA3LgQMqvR FoundationFoundation.Network.IPv4Foundation.Class.StorableFoundation.System.InfoFoundation.MonadFoundation.IO.TerminalFoundation.Parser Foundation.IOFoundation.BitsFoundation.ExceptionFoundation.StringFoundation.String.ReadFoundation.PrimitiveFoundation.Array.InternalFoundation.ForeignFoundation.ArrayFoundation.CollectionFoundation.NumericalFoundation.VFS.PathFoundation.VFS.URIFoundation.String.BuilderFoundation.StrictFoundation.Tuple.NthFoundation.System.EntropyFoundation.RandomFoundation.Time.TypesFoundation.Time.StopWatchFoundation.Monad.ReaderFoundation.Monad.ExceptFoundation.Monad.StateFoundation.Math.TrigonometryFoundation.Time.BindingsFoundation.ConduitFoundation.Conduit.TextualFoundation.List.DListFoundation.TimingFoundation.Timing.MainFoundation.HashingFoundation.Network.IPv6Foundation.UUIDFoundation.CheckFoundation.Check.MainFoundation.VFS.FilePathFoundation.IO.FileMapElementFoundation.VFSFilePathURI Foundation.System.Entropy.CommonFoundation.System.Bindings.Time#Foundation.System.Bindings.PosixDef Foundation.System.Bindings.Posix"Foundation.System.Bindings.Network Foundation.System.Bindings.LinuxFoundation.System.Bindings.HsFoundation.System.BindingsFoundation.TupleFoundation.PartialFoundation.Numerical.FloatingFoundation.System.Entropy.UnixFoundation.Random.ClassFoundation.Random.DRGFoundation.Monad.TransformerFoundation.Monad.MonadIOFoundation.Monad.ExceptionFoundation.Monad.IdentityFoundation.Monad.BaseFoundation.List.ListNFoundation.Foreign.AllocFoundation.Conduit.InternalFoundation.Collection.MutableFoundation.Collection.Mappable traverse_ sequenceA_mapM_ sequence_traverse sequenceAmapMsequenceforM_forMFoundation.Collection.ListFoundation.Collection.KeyedFoundation.Collection.ElementFoundation.Collection.FoldableFoundation.Collection.Indexed"Foundation.Collection.InnerFunctorFoundation.Collection.Copy Foundation.Collection.Collection Foundation.Collection.SequentialFoundation.Collection.ZippableFoundation.Collection.BuildableFoundation.Random.ChaChaDRGFoundation.Class.BifunctorFoundation.Random.XorShift Foundation.Array.Chunked.UnboxedFoundation.Array.BitmapFoundation.Hashing.HasherFoundation.Hashing.FNVFoundation.Hashing.HashableFoundation.Hashing.SipHashFoundation.Check.GenFoundation.Check.ArbitraryFoundation.Check.ConfigFoundation.Check.PropertyFoundation.Check.TypesFoundation.Check.Print"Foundation.Foreign.MemoryMap.Types"Foundation.Foreign.MemoryMap.PosixFoundation.Foreign.MemoryMapFoundation.IO.Fileghc-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 ApplicativeMonoid GHC.TypesBoolCharDoubleFloatIntGHC.IntInt8Int16Int32Int64 integer-gmpGHC.Integer.TypeIntegerMaybeOrderingRationalIOWordGHC.WordWord8Word16Word32Word64GHC.PtrPtr Data.EitherEitherFalseNothingJustTrueLeftRightLTEQGT System.InfocompilerVersionData.Functor.Identity runIdentityIdentityItem GHC.NaturalNatural Data.Version versionTags versionBranchVersion System.Exit exitSuccess exitFailureData.Bifunctorsecondfirstbimap BifunctorControl.Monad.IO.ClassliftIOMonadIO Control.Monad>=>Control.ApplicativeoptionalControl.Category.idGHC.IO.Handle.FDstdinstdout Data.Monoid<>castPtrGHC.IO.Exception IOException GHC.ExceptiondisplayException fromException toException Exception GHC.IO.IOMode ReadWriteMode AppendMode WriteModeReadModeIOModepartitionEithersrightsleftseither Data.Proxy asProxyTypeOfProxy Data.BitspopCountrotateRrotateL unsafeShiftRshiftR unsafeShiftLshiftLisSignedbitSize bitSizeMaybetestBit complementBitclearBitsetBitbitzeroBitsrotateshift complementxor.|..&.Bits Data.Functionon Data.Functor<$>^^maxBoundminBoundfromEnumtoEnumpredsucc Data.MaybemapMaybe catMaybes listToMaybe maybeToList fromMaybe isNothingisJustmaybe Data.TupleswapuncurrycurryasTypeOfuntil$!flipconst=<<<$<*manysome<|>GHC.Err undefined SomeException/=compare<=&&||not<>maxmin%basement-0.0.3-9VABBoFJLfV9rowquvHEzlBasement.StringtoBase64OpenBSD toBase64URLtoBase64lowerupperreadFloatingExact readRational readDouble readNatural readInteger readIntegralwordslinestoBytesfromBytesUnsafefromBytesLenient fromBytesreplaceindices breakLine ISO_8859_1UTF32UTF16UTF8ASCII7Encoding Basement.ShowshowBasement.ErrorerrorBasement.EnvironmentgetArgsBasement.UTF8.BaseStringBasement.Types.AsciiString AsciiStringBasement.UArray toHexadecimalrecastwithPtr copyToPtrfromForeignPtr foreignMemBasement.BoxedArrayArrayMArrayBasement.UArray.MutablewithMutablePtrmutableForeignMemBasement.UArray.Basenew newPinnedMUArrayUArrayBasement.Block.BaseBlock MutableBlockBasement.UTF8.TypesBuildingFailure MissingByteInvalidContinuation InvalidHeaderValidationFailureBasement.PrimType primAddrWrite primAddrRead primAddrIndex primMbaUWrite primMbaURead primBaUIndexprimShiftToBytesprimSizeInBytesPrimTypeBasement.TheseTheseThatThisBasement.NormalFormforcedeepseq toNormalForm NormalFormBasement.MutableBuilder runBuilderBuilder chunkSizecurChunkprevChunksSize prevChunks BuildingStateBasement.NonEmpty getNonEmptyNonEmptyBasement.Exception OutOfBoundBasement.Types.OffsetSizeOffsetCountOfBasement.Numerical.Subtractive- Difference Subtractive!Basement.Numerical.Multiplicativerecip^* midentityMultiplicativedivModmoddiv IDivisible/ DivisibleBasement.Numerical.Additivescale+azeroAdditiveBasement.Types.Word256Word256Basement.Types.Word128Word128Basement.Types.Char7Char7Basement.IntegralConvintegralDownsizeCheckintegralDownsizeIntegralDownsizeintegralUpsizeIntegralUpsize integralCast IntegralCastBasement.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 HasNegationPathPathEnt PathPrefix PathSuffix splitPath buildPathparentfilenameprefixsuffixURIPath URIFragmentURIQuery URIAuthority URISchema $fPathURIemitemitChartoString$fMonoidBuilder$fIsStringBuilderArchI386X86_64PowerPC PowerPC64SparcSparc64ARMARM64OSWindowsOSXLinuxAndroidBSDosarch compilerNamecpus$fShowOS$fEqOS$fOrdOS$fEnumOS $fBoundedOS$fDataOS $fShowArch$fEqArch $fOrdArch $fEnumArch $fBoundedArch $fDataArchstrict1strict2strict3strict4strict5strict6Thdable ProductThirdthdSndable ProductSecondsndFstable ProductFirstfstTuple4Tuple3Tuple2NthableNthTynth$fNthable4Tuple4$fNthable3Tuple4$fNthable2Tuple4$fNthable1Tuple4$fNthable4(,,,)$fNthable3(,,,)$fNthable2(,,,)$fNthable1(,,,)$fNthable3Tuple3$fNthable2Tuple3$fNthable1Tuple3$fNthable3(,,)$fNthable2(,,)$fNthable1(,,)$fNthable2Tuple2$fNthable1Tuple2 $fNthable2(,) $fNthable1(,) PartialErrorPartialpartial fromPartial FloatingPoint floatRadix floatDigits floatRange floatDecode floatEncodeIntegralRoundingroundUp roundDown roundTruncate roundNearestSignedabssignumSign SignNegativeSignZero SignPositive$fIntegralRoundingFloat$fIntegralRoundingDouble$fIntegralRoundingRatio$fSignedDouble $fSignedFloat $fSignedInt64 $fSignedInt32 $fSignedInt16 $fSignedInt8 $fSignedInt$fSignedInteger$fEqSign getEntropy MonadRandomgetRandomBytesgetRandomWord64 getRandomF32 getRandomF64MonadRandomStaterunRandomState RandomGen randomNew randomNewFromrandomGeneraterandomGenerateWord64randomGenerateF32randomGenerateF64withRandomGeneratorSeconds NanoSeconds$fPrimTypeSeconds$fPrimTypeNanoSeconds$fShowNanoSeconds$fEqNanoSeconds$fOrdNanoSeconds$fAdditiveNanoSeconds$fEnumNanoSeconds$fBoundedNanoSeconds $fShowSeconds $fEqSeconds $fOrdSeconds$fAdditiveSeconds $fEnumSeconds$fBoundedSecondsStopWatchPrecise startPrecise stopPrecise MonadTranslift MonadBracketgeneralBracket MonadCatchcatch MonadThrowthrowReaderT runReaderT MonadReader ReaderContextask$fMonadReaderReaderT$fMonadBracketReaderT$fMonadCatchReaderT$fMonadThrowReaderT$fMonadFailureReaderT$fMonadIOReaderT$fMonadTransReaderT$fMonadReaderT$fApplicativeReaderT$fFunctorReaderTExceptT runExceptT$fMonadIOExceptT$fMonadTransExceptT$fMonadReaderExceptT$fMonadExceptT$fMonadFailureExceptT$fApplicativeExceptT$fFunctorExceptTStateT runStateT MonadStateState withStategetput$fMonadStateStateT$fMonadCatchStateT$fMonadThrowStateT$fMonadFailureStateT$fMonadIOStateT$fMonadTransStateT $fMonadStateT$fApplicativeStateT$fFunctorStateT replicateM Trigonometrypisincostanasinacosatansinhcoshtanhasinhacoshatanh$fTrigonometryDouble$fTrigonometryFloatputStrputStrLnmeasuringNanoSecondsgetMonotonicTimefinallytry ResourceTZipSink getZipSinkConduitawait awaitForeveryieldyieldOrleftover runConduitrunConduitPure runConduitResbracketConduitfuseMutableCollectionMutableFreezed MutableKey MutableValue unsafeThaw unsafeFreezethawfreezemutNewmutUnsafeWritemutWrite mutUnsafeReadmutReadMappableKeyedCollectionKeyValuelookup Fold1ablefoldl1'foldr1Foldablefoldl'foldrfoldr'IndexedCollection! findIndex InnerFunctorimapCopycopy CollectionnulllengthelemnotElemmaximumminimumanyallnonEmpty nonEmpty_ nonEmptyFmapandor SequentialtakerevTakedroprevDropsplitAt revSplitAtsplitOnbreakbreakEnd breakElem takeWhile dropWhile intersperse intercalatespanspanEndfilter partitionreverseunconsunsnocsnocconsfindsortBy singletonheadlasttailinit replicate isPrefixOf isSuffixOf isInfixOf stripPrefix stripSuffix BoxedZippablezipzip3zip4zip5zip6zip7unzipunzip3unzip4unzip5unzip6unzip7ZippablezipWithzipWith3zipWith4zipWith5zipWith6zipWith7 BuildableMutableStepappendbuildbuild_DList$fSequentialDList$fCollectionDList$fFoldableDList $fMonadDList$fApplicativeDList$fFunctorDList $fMonoidDList $fIsListDList $fShowDList $fOrdDList $fEqDListAnd ConditionBetweenExactlyParser ParserSourceChunk nullChunk appendChunksubChunk spanChunkResult ParseFailedParseOk ParseMore ParseError NotEnoughNotEnoughParseOnlyExpectedElementExpectedSatisfy parseFeedparse parseOnly reportError anyElementelementelementssatisfysatisfy_takeAllskip skipWhileskipAllstringrepeat $fShowAnd$fParserSource[]$fParserSourceString$fAlternativeParser$fMonadPlusParser $fMonadParser$fApplicativeParser$fFunctorParser$fFunctorResult $fShowResult$fShowParseError$fExceptionParseError $fShowNoMore $fEqNoMore$fEqAnd$fShowCondition $fEqConditionMeasure measurementsitersTimingtimeDifftimeBytesAllocated stopWatchmeasure defaultMain$fFunctorTimingPlan$fApplicativeTimingPlan$fMonadTimingPlan StorableFixedsize alignmentStorablepeekpokeplusPtrpeekOffpokeOff peekArraypeekArrayEndedBy pokeArraypokeArrayEndedBy$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 $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$fStorableCCharRNGv1RNG.<<..>>. alignRoundUpalignRoundDown ChunkedUArray MutableBitmapBitmapHasherFNV1a_64FNV1a_32FNV1_64FNV1_32HashablehashMixIPv4loopback fromTupletoTuple ipv4Parser$fStorableFixedIPv4$fStorableIPv4$fIsStringIPv4$fNormalFormIPv4 $fShowIPv4$fEqIPv4 $fOrdIPv4$fHashableIPv4IPv6 ipv6Parseripv6ParserPreferredipv6ParserIpv4Embeddedipv6ParserCompressed$fStorableFixedIPv6$fStorableIPv6$fIsStringIPv6 $fShowIPv6$fHashableIPv6$fNormalFormIPv6$fEqIPv6 $fOrdIPv6UUIDnilnewUUID fromBinary uuidParser$fStorableFixedUUID$fStorableUUID$fHashableUUID$fNormalFormUUID $fShowUUID$fEqUUID $fOrdUUIDSip1_3Sip2_4Gen Arbitrary arbitrary frequencyoneofbetween IsPropertypropertyPropertyPropunProp PropertyCheckforAll===propertyCompare propertyAnd propertyFailTestUnitGroup CheckPlanChecktestNamevalidatepickiterateProperty$fMonadStateCheckMain$fFunctorCheckMain$fApplicativeCheckMain$fMonadCheckMain$fMonadIOCheckMainFileName RelativityAbsoluteRelativefilePathToStringfilePathToLStringunsafeFilePathunsafeFileName extension$fPathFilePath$fMonoidFileName$fIsStringFileName$fShowFileName$fExceptionFileName_Invalid$fIsStringFilePath$fExceptionFilePath_Invalid $fOrdFilePath $fEqFilePath$fShowFilePath$fEqRelativity$fShowRelativity$fShowFilePath_Invalid $fEqFileName$fShowFileName_InvalidopenFile closeFilehGethPutwithFilereadFile fileMapReadfileMapReadWithLString fromCounttoCount.| sourceFile sourceHandleyieldssinkFile sinkHandlesinkListEntropySystemMissing$fExceptionEntropySystemMissing 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_ALARM COpenFlags CSysconfName CMemSyncFlags CMemAdviceCMemMappingFlags CMemProtFlagsCFdCErrnoSystem.Posix.TypesCModeCOffCDirentCDir 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_PAGESIZE getHErrnoherr_HostNotFound herr_NoDataherr_NoRecovery herr_TryAgainCWatchDescriptor 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_UNMOUNTcinotifyEventSizesysHsCoreGetErrnoETemptyconcat$fThdableTuple4$fThdableTuple3$fThdable(,,,) $fThdable(,,)$fSndableTuple4$fSndableTuple3$fSndableTuple2$fSndable(,,,) $fSndable(,,) $fSndable(,)$fFstableTuple4$fFstableTuple3$fFstableTuple2$fFstable(,,,) $fFstable(,,) $fFstable(,)$fNormalFormTuple4$fNormalFormTuple3$fBifunctorTuple2$fNormalFormTuple2 partialErrorfromJust fromRightfromLeft$fExceptionPartialError$fFloatingPointDouble$fFloatingPointFloatorderingToSign entropyGather EntropyCtxEntropySyscallc_sysrandom_linux entropyOpen entropyCloseentropyMaximumSizeopenDevgatherDevEntropysupportSyscall$fMonadRandomIO$fMonadRandomMonadRandomState$fMonadMonadRandomState$fApplicativeMonadRandomState$fFunctorMonadRandomState secondInNano$fMonadBracketIO$fMonadCatchIO$fMonadThrowIO IdentityT runIdentityT$fMonadCatchIdentityT$fMonadThrowIdentityT$fMonadFailureIdentityT$fMonadIOIdentityT$fMonadTransIdentityT$fMonadIdentityT$fApplicativeIdentityT$fFunctorIdentityTBasement.Sized.Listfoldlmapindex indexStatic createFromcreatetoListNListNunListN allocaBytesForeign.C.TypesCCharCSCharCUCharCShortCUShortCIntCUIntCLongCULongCLLongCULLongCFloatCDoubleCPtrdiffCSizeCWchar CSigAtomicCClockCTime CUSeconds CSUSecondsCFileCFposCJmpBufCIntPtrCUIntPtrCIntMaxCUIntMaxBasement.FinalPtrwithUnsafeFinalPtr touchFinalPtr withFinalPtrwithFinalPtrNoTouch castFinalPtrtoFinalPtrForeign toFinalPtrfinalPtrSameMemoryFinalPtr FinalForeignPipeYieldAwaitDonePipeMLeftoverrunPipe MonadResource liftResourceTNextKeyRefCount ReleaseType ReleaseEarly ReleaseNormalReleaseException ReleaseMapReleaseMapClosed unResourceTVoid unConduitawait'absurdinjectLeftovers runResourceTallocate$fMonadResourceConduit$fMonadResourceResourceT$fMonadBracketResourceT$fMonadCatchResourceT$fMonadThrowResourceT$fMonadIOResourceT$fMonadTransResourceT$fMonadResourceT$fApplicativeResourceT$fFunctorResourceT$fApplicativeZipSink$fFunctorZipSink$fMonadCatchConduit$fMonadThrowConduit$fMonadFailureConduit$fMonadIOConduit$fMonadTransConduit$fMonadConduit$fApplicativeConduit$fFunctorConduit $fMonadPipe$fApplicativePipe $fFunctorPipe$fMutableCollectionMArray$fMutableCollectionMutableBlock$fMutableCollectionMUArray$fMappableArray $fMappable[] wordsWhen$fKeyedCollection[]$fFold1ableBlock$fFold1ableArray$fFold1ableUArray $fFold1able[]$fFoldableBlock$fFoldableArray$fFoldableUArray $fFoldable[]$fIndexedCollectionString$fIndexedCollectionArray$fIndexedCollectionUArray$fIndexedCollectionBlock$fIndexedCollection[]$fInnerFunctorString$fInnerFunctorArray$fInnerFunctorUArray$fInnerFunctor[] $fCopyString $fCopyArray $fCopyUArray $fCopyBlock$fCopy[]$fCollectionNonEmpty$fCollectionString$fCollectionArray$fCollectionUArray$fCollectionBlock$fCollection[]mconcatCollection$fSequentialString$fSequentialArray$fSequentialUArray$fSequentialBlock$fSequential[]uncons2uncons3uncons4uncons5uncons6uncons7uncurry2uncurry3uncurry4uncurry5uncurry6uncurry7$fBoxedZippableArray$fBoxedZippable[]$fZippableString$fZippableArray$fZippableUArray $fZippable[] builderLift$fBuildableString$fBuildableArray$fBuildableUArrayunDList runParserSuccessNoMoreMoreendOfParserSource runParser_failuresuccessrepeatErepeatAGCStats getGCStatsdiffGC TimingPlan runTimingPlan MainConfigmainHelpmainListBenchs mainVerbose mainOtherdefaultMainConfig parseArgs configHelpc_rngv1_generate_f64c_rngv1_generate_f32c_rngv1_generate_word64c_rngv1_generatekeySizegenerategenerateWord64 generateF32 generateF64$fRandomGenState initializenextnextList nextFloat nextDoubleequal vFromListvToListfindPos splitChunk unsafeIndexremoveArraySize $fIndexedCollectionChunkedUArray$fSequentialChunkedUArray$fCollectionChunkedUArray$fFoldableChunkedUArray$fIsListChunkedUArray$fMonoidChunkedUArray$fNormalFormChunkedUArray$fEqChunkedUArrayvCompare bitsPerTy shiftPerTy maskPerTy bitmapIndex unsafeWrite unsafeReadwriteread mutableLength unoptimised $fMutableCollectionMutableBitmap$fIndexedCollectionBitmap$fSequentialBitmap$fCollectionBitmap$fFoldableBitmap$fInnerFunctorBitmap$fIsListBitmap$fMonoidBitmap $fOrdBitmap $fEqBitmap $fShowBitmaphashMix8 HashResulthashEnd HashInitParamhashNew hashNewParam hashMix16 hashMix32 hashMix64 hashMixBytesunWord16unWord32 unWord64_32 FNV1Hash64 FNV1Hash32 fnv1_32_mixBafnv1a_32_mixBa fnv1_64_mixBafnv1a_64_mixBaxor32xor64 fnv1_32_Mix8 fnv1a_32_Mix8 fnv1_64_Mix8 fnv1a_64_Mix8$fHasherFNV1a_64$fHasherFNV1_64$fHasherFNV1a_32$fHasherFNV1_32$fHashableTuple4$fHashableTuple3$fHashableTuple2$fHashable(,,,,,)$fHashable(,,,,)$fHashable(,,,)$fHashable(,,) $fHashable(,) $fHashable[]$fHashableUArray$fHashableString$fHashableInteger$fHashableInt64$fHashableInt32$fHashableInt16$fHashableInt8$fHashableNatural$fHashableWord64$fHashableWord32$fHashableWord16$fHashableWord8 fromLString toLStringshowHex4showHexformat skipColonskipDot takeAWord8 takeAWord16 withComponentparseHexSipHashSipKeymixBaSipIncrementalSipIncremental0SipIncremental1SipIncremental2SipIncremental3SipIncremental4SipIncremental5SipIncremental6SipIncremental7 InternalStateSip newSipStatemix8Primmix8mix32mix64finishdoRoundprocessfinalize loopRounds andMask64$fHasherSip1_3$fHasherSip2_4runGenGenSeedGenRng GenParamsgenMaxSizeIntegralgenMaxSizeArraygenMaxSizeStringgenRng genGenerator genWithRng genWithParams $fMonadGen$fApplicativeGen $fFunctorGenarbitraryIntegerarbitraryNatural arbitraryChararbitraryWord64arbitraryInt64 arbitraryF64 arbitraryF32arbitraryUArrayOfgenMax $fArbitrary[]$fArbitrary(,,,,,)$fArbitrary(,,,,)$fArbitrary(,,,)$fArbitrary(,,)$fArbitrary(,)$fArbitraryEither$fArbitraryMaybe$fArbitraryDouble$fArbitraryFloat$fArbitraryAsciiString$fArbitraryString$fArbitraryBool$fArbitraryCountOf$fArbitraryChar7$fArbitraryChar$fArbitraryInt8$fArbitraryInt16$fArbitraryInt32$fArbitraryInt64$fArbitraryWord8$fArbitraryWord16$fArbitraryWord32$fArbitraryWord64$fArbitraryWord128$fArbitraryWord256$fArbitraryWord$fArbitraryInt $fArbitraryZn$fArbitraryZn64$fArbitraryNatural$fArbitraryIntegerudfSeed getGenParamsnumTests defaultConfig ParamErrorConfig listTests testNameMatchdisplayOptions helpRequested DisplayOptionDisplayTerminalErrorOnlyDisplayGroupOnlyDisplayTerminalVerboseSeed getIntegerPropertyTestArg PropertyEOA PropertyArgPropertyBoolean PropertyNamedPropertyBinaryOp PropertyAnd PropertyFailPropertyTestResultcheckHasSucceedcheckHasFailedpretty$fIsProperty(->)$fIsPropertyProperty$fIsPropertyPropertyCheck$fIsProperty(,)$fIsPropertyBoolHasTests TestResultPropertyResultrunCheck PlanStateplanRngplanValidations planParams planFailures HasFailures GroupResultPropertySuccessPropertyFailed fqTestNamegroupHasSubGroup$fMonadStateCheckpropertyToResult diffBlame CheckMain runCheckMain TestStateconfiggetSeedindent testPassed testFailedtestPathnbFailnbTestsnewStatefilterTestMatchingonDisplayOption whenErrorOnly whenGroupOnly whenVerbosepassedfailedtestdisplayCurrentdisplayPropertySucceed successString failureStringdisplayPropertyFailed pushGroup testCheckPlan testPropertyFileName_InvalidContainsNullByteContainsSeparator EncodingErrorUnknownTrailingBytesFilePath_InvalidContiguousPathSeparatorpathSeparatorPOSIXfileNameToStringfileNameToLStringpathSeparatorPOSIXCpathSeparatorC pathSeparator hasNullByte hasSeparator isSeparatorhasContigueSeparatorsjoinfilenameIntercalate FileMappingfileMappingToFinalPtr FileMapReadFfileMappingPtrfileMappingSizefileMappingUnmapMemorySyncFlagMemorySyncAsyncMemorySyncSyncMemorySyncInvalidate MemoryAdviceMemoryAdviceNormalMemoryAdviceRandomMemoryAdviceSequentialMemoryAdviceWillNeedMemoryAdviceDontNeedMemoryProtection MemoryMapFlagMemoryMapSharedMemoryMapPrivate memoryMap memoryUnmap memoryAdvise memoryLock memoryUnlock memoryProtect memorySyncsysconfPageSizeMemoryProtectionNoneMemoryProtectionReadMemoryProtectionWriteMemoryProtectionExecute c_sysconf c_munlockc_mlock c_mprotectc_msync c_madvisec_munmapc_mmapcvalueOfMemoryProtscvalueOfMemorySyncfileSizeToCSizefileSizeFromIntegerGHC.IO.Handle.TypesHandlehGetNonBlockinghGetSomeinvalidBufferSize blockSizegetSize