h&q{      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmn o p q r s t u v w x y z { | } ~                                                                                                                       !!!!!!""""""""""""""""""###$$%%%%%%%%%%&&&&'''''''''''''''((((((((((((((((((((()))))))))))))***********++++++++++++++++++++++++++     ,,------------- BSD-style#Vincent Hanquez  experimentalportable Safe-Inferred.6A  . BSD-style#Vincent Hanquez  experimentalportable Safe-Inferred.6JGIH/ Safe-Inferred .60 BSD-style#Vincent Hanquez  experimentalportable Safe-Inferred.6 foundationElement type of a collection1 BSD-style Foundation experimentalportable Safe-Inferred .56  foundation&A set of methods for ordered colection foundationCheck if a collection is empty foundation,Length of a collection (number of Element c) foundation1Check if a collection contains a specific elementThis is the inverse of . foundation;Check if a collection does *not* contain a specific elementThis is the inverse of . foundation'Get the maximum element of a collection foundation'Get the minimum element of a collection foundationDetermine is any elements of the collection satisfy the predicate foundationDetermine is all elements of the collection satisfy the predicate foundation1Smart constructor to create a NonEmpty collectionIf the collection is empty, then Nothing is returned Otherwise, the collection is wrapped in the NonEmpty property foundationsame as , but assume that the collection is non empty, and return an asynchronous error if it is. foundation:Return True if all the elements in the collection are True foundation=Return True if at least one element in the collection is True2 BSD-style foundation experimentalportable Safe-Inferred.6c foundation-Collections that can be built chunk by chunk.Use the  instance of  to chain  operations and feed it into :runST $ 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.A 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 chunk3 BSD-style#Vincent Hanquez  experimentalportable Safe-Inferred .16" foundationFold1's. Like folds, but they assume to operate on a NonEmpty collection. foundationLeft associative strict fold. foundationRight associative lazy fold. foundation/Give the ability to fold a collection on itself 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: foldl 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 foldl`, a strict version of foldl, because the lazy version is seldom useful.Left-associative fold of a structure with strict application of the operator. foundation&Right-associative fold of a structure. foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...) foundationRight-associative fold of a structure, but with strict application of the operator.4 BSD-style#Vincent Hanquez  experimentalportable Safe-Inferred .6#r foundation.Collection of elements that can indexed by int5 Safe-Inferred .6<$  foundationA monomorphic functor that maps the inner values to values of the same type6 BSD-style#Vincent Hanquez  experimentalportable Safe-Inferred .6$ foundation1Collection of things that can be looked up by Key7 BSD-style*Nicolas Di Prima  experimentalportable Safe-Inferred.6,  foundationFunctors representing data structures that can be traversed from left to right.Mostly like base's  Traversable! but applied to collections only. 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. foundationEvaluate each actions of the given collections, from left to right, and collect the results. For a version that ignores the results, see 9 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 :. foundationEvaluate each actions of the given collections, from left to right, and collect the results. For a version that ignores the results, see ; 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 < foundationEvaluate each action in the collection from left to right, and ignore the results. For a version that doesn't ignore the results see =. 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 ?. foundation is  with its arguments flipped. For a version that ignores the results see @. foundation is  with its arguments flipped. For a version that doesn't ignore the results see A. B BSD-style#Vincent Hanquez  experimentalportable Safe-Inferred.6- foundationCollection of things that can be made mutable, modified and then freezed into an MutableFreezed collection  BSD-style#Vincent Hanquez  experimentalportable Safe-Inferred.6.{C Safe-Inferred.6/9 BSD-style Foundation experimentalportable Safe-Inferred.60H foundation!Print a string to standard output foundation0Print a string with a newline to standard output foundation+Get the arguments from the terminal commandMNXYXYNMD BSD-style#Vincent Hanquez  experimentalportable Safe-Inferred.603  Safe-Inferred.632 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-1E Safe-Inferred ./66 foundationMonad that can ensure cleanup actions are performed even in the case of exceptions, both synchronous and asynchronous. This usually excludes continuation-based monads. foundationA 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  Safe-Inferred.66F Safe-Inferred.67LKG Safe-Inferred./67 foundationBasic Transformer class foundationLift a computation from an inner monad to the current transformer monadH Safe-Inferred.68  foundationIdentity Transformer I Safe-Inferred.68G   $LK  Safe-Inferred.68 foundationState Transformer Safe-Inferred./696 foundationReader Transformer Safe-Inferred "./69|J Safe-Inferred.69 foundationIEEE754 Floating Point BSD-style#Vincent Hanquez  experimentalportable Safe-Inferred .6<~ foundationRound up, to the next integral.Also known as ceiling foundation$Round down, to the previous integralAlso known as floor foundationTruncate to the closest integral to the fractional number closer to 0.This 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(( Safe-Inferred .56;= foundation n act performs the action n times, gathering the results.LKWVULKWVUK Safe-Inferred ".6E foundation experimentalportable Safe-Inferred.6F  foundation?Simple helper to split a list repeatly when the predicate match M BSD-style#Vincent Hanquez  experimentalportable Safe-Inferred.56<Sp% 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 foundationSplit a collection when the predicate return true starting from the end of the collection foundation'Split a collection at the given element foundationReturn the longest prefix in the collection that satisfy the predicate foundationReturn the longest prefix in the collection that satisfy the predicate foundationThe  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 foundationSplit a collection while the predicate return true starting from the end of the collection foundation2Filter all the elements that satisfy the predicate foundationPartition the elements that satisfy the predicate and those that don't foundationReverse a collection foundationDecompose 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 foundationExtract the elements after the first element of a non-empty collection. foundationExtract the elements before the last element of a non-empty collection. foundationCreate a collection where the element in parameter is repeated N time foundationTakes two collections and returns True iff the first collection is a prefix of the second. foundationTakes two collections and returns True iff the first collection is a suffix of the second. foundationTakes 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 experimentalportable Safe-Inferred.56Z_ 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 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. foundation generalises  by zipping with the function given as the first argument, instead of a tupling function. For example,  (+) is applied to two collections to produce the collection of corresponding sums. 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. BSD-style#Vincent Hanquez  experimentalportable Safe-Inferred .6Z BSD-style*Nicolas Di Prima statbleportable Safe-Inferred.6]z Safe-Inferred".6^ foundation$Split conduit of string to its linesThis is very similar to Prelude lines except it work directly on ConduitNote 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-styleHaskell Foundation experimentalportable Safe-Inferred .6`^ foundationExtending the Storable type class to the types that can be sequenced in a structure. foundation&Storable type of self determined size. foundationlike  but at a given offset. foundationlike  but at a given offset.;m;m  Safe-Inferred.6c" 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)~}|{zyxwvutsrqpon~}|{zyxwvutsrqponO BSD-style#Vincent Hanquez  experimentalportable Safe-Inferred.6fK  foundation5Return the element at a specific index from a Bitmap.5If the index @n is out of bounds, an error is raised.  foundationReturn the element at a specific index from an array without bounds checking.Reading 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  experimentalportable Safe-Inferred.6h foundationAn 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 foundationCreate 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  experimentalportable Safe-Inferred .6ip//QBSD-style -- Maintainer : Alfredo Di Napoli  experimentalportable Safe-Inferred (.6mq  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 @* 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 . 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  experimentalportable Safe-Inferred.6m  R Safe-Inferred.6q  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  experimentalgood Safe-Inferred.6s 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  experimentalgood Safe-Inferred.6vd  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 Foundationstableportable Safe-Inferred.6v  BSD-style#Vincent Hanquez  experimentalportable Safe-Inferred.6wT BSD-styleHaskell Foundation experimentalportable Safe-Inferred .6 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 inputThe 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 parsersThis way we can provide more detailed error when building custom parsers and still avoid to use the naughty _fail_. myParser :: Parser input Int myParser = reportError $ Satisfy (Just "this function is not implemented...")  foundation,Get the next `Element input` from the parser foundationpeek 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 foundationTake 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 repeat (Between $ 1 `And` 10) (takeWhile ((/=) ',') <* element ','),T,T BSD-style Foundation Safe-Inferred.6c foundationrun the builder and return a  alias to  "This function is not safe, prefer  .   Safe-Inferred.6U Safe-Inferred  .6 V BSD-style*Nicolas Di Prima  provisionalportable Safe-Inferred.6i W Safe-Inferred.6  X(c) Vincent Hanquez 2014-2017 BSD-styleVincent Hanquez provisionalnon-portable (requires POSIX)None .6F Y Safe-Inferred.6 Z(c) Vincent Hanquez 2014-2017 BSD-styleVincent Hanquez provisionalnon-portable (requires Linux) Safe-Inferred.6 [Haskell foundation Safe-Inferred.6 \ BSD-style#Vincent Hanquez  experimentalportable Safe-Inferred.6B ] BSD-style#Vincent Hanquez  experimentalGood Safe-Inferred .6=  foundationtry to fill the ptr with the amount of data required. Return the number of bytes, or a negative number otherwise  BSD-style Foundationstablegood Safe-Inferred.6 foundationGet some of the system entropy^ Safe-Inferred.6E foundation7A monad constraint that allows to generate random bytes_ Safe-Inferred.6 foundationA 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 > 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-style Safe-Inferred.6;  foundationState of Xoroshiro128 plus a Safe-Inferred.6/  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 experimentalGood Safe-Inferred .6 foundationAn 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.b Safe-Inferred ")*.6a foundationGenerator monad  c Safe-Inferred".6  foundationoptional user specified seed  foundationParameters for the generatordefault: * 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 details d Safe-Inferred "(.6 foundation'How to generate an arbitrary value for a foundation"Call one of the generator weightede BSD-style Foundation experimentalportable Safe-Inferred ".6 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 function  f BSD-style Foundation experimentalportable Safe-Inferred ".6 foundation-serialise the CSV document into a UTF8 string foundation experimentalportable Safe-Inferred.6; foundation0Class of product types that have a third element foundation1Class of product types that have a second element foundation0Class of product types that have a first element foundationStrict tuple (a,b,c,d) foundationStrict tuple (a,b,c) foundationStrict tuple (a,b)k BSD-style#Vincent Hanquez  experimentalgood Safe-Inferred.6 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  experimentalportable Safe-Inferred .6  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 xs 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 addresswhen dealing with a mixed environment of IPv4 and IPv6 nodes is x:x:x:x:x:x:d.d.d.d, where the xs are the hexadecimal values of the six high-order 16-bit pieces of the address, and the ds 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  experimentalportable Safe-Inferred".6 foundationIPv4 data type foundation "0.0.0.0" foundation "127.0.0.1" foundationParse a IPv4 address   BSD-style Foundation Safe-Inferred.6*   BSD-style#Vincent Hanquez  experimentalportable Safe-Inferred.6  foundation:Alias to Prelude String ([Char]) for compatibility purposeF   !"# $%&'=@()*+,-./012?>3CDE456789:3CDE'=@(5 experimentalportable Safe-Inferred .16 foundationA generalized version of indexed accessor allowing access to tuples n'th element.Indexing starts at 1, as  is used to get first element.) Safe-Inferred ".6* BSD-style foundation experimentalportable Safe-Inferred.6  foundationPath type classdefines 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.if 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 experimentalportable Safe-Inferred.6Ȓ  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 experimentalportable Safe-Inferred.6p BSD-style Foundation experimentalportable Safe-Inferred".6i foundation2list the file name in the given FilePath directoryTODO: 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.   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 act. the by-product handle will be closed when act finish, either normally or through an exception.(The value returned is the result of act@ foundationRead a binary file and return the whole content in one contiguous buffer.lkjih  BSD-style#Vincent Hanquez  experimentalportable Safe-Inferred.6XYlkjihXYlkjih Safe-Inferred.6Ы foundationOperator version of . foundationSend values downstream.2q Safe-Inferred ".6A  BSD-style Foundation experimentalportable Safe-Inferred ".6ѯr BSD-style#Vincent Hanquez  experimentalportable Safe-Inferred.6Ӗ  foundationContains all the information related to a file mapping, including the size and the finalizer function.  foundationFrom 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.6   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.  foundationExpect page references in random order. No readahead should occur.  foundationExpect page references in sequential order. Page should be readahead aggressively.  foundationExpect 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.If 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.On 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 t Safe-Inferred.6p , BSD-style#Vincent Hanquez  experimentalportable Safe-Inferred".6ܳ foundation*Map in memory the whole content of a file.Once the array goes out of scope, the memory get (eventually) unmap foundation*Map in memory the whole content of a file,- BSD-style foundation experimentalportable Safe-Inferred.6G foundation TODO this is not implemented yet   uvwxyzxy{x|}x|~x|x|uuxyxyxyxyxxxxxxxxyxyxyxyxyxyxyx|x|uxyxyuxxxxyxyxyuuuuuxxxxxuxuuxxxxxxuxxuxxuuuxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx|x|x|x|x|x|xxxxxxxxxxxxxxxyxyxyxyxyxyxyxyxyxyxyxyxxuuuuuuuuuu//0l11111111111111222222333333344455666677<7=7>7?787:7A7@BBBBBBBBBBBBBEEEEEE  GGJJJJJJKKKKKKKKKKKKKKKMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNN    OOPPPPQRSSTTTT^^^^^___________bddddddeeeeeeeeeeeeeeeeeeefffffffgggggggggggghhhhhhh!!!!!!""""""""""""""""""###$$%%%%%%%%%%&&&&jjjjjjjjjjjjjjjkk'''''''''''''''((((((((((((((((((((()))))))))))))***********++n++++++++++++++++++++++++pppppp  q q q q q , , - - - - - - - - - - -o-o- 2 7;x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x                C                                            : > ; ?      H H x  x K K K K K K K K K KK KK K L LLLLLLO O O O O O OO O O O O O OOP PP P P QQQQ R R R R R R R R R R S S S S S T T T T T T T T       U V V V V V W W W W W W W W X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ [ \ \ ] ] ] ] ] `` ` ` ` aaa b b b b b b b b b b c c c c c c c c c c c c c c c c c e e g g g g g g g g g g h h h hh h h h h h h h h h h h h h i i ! xx+ + + + + + + + + + x  p p r r r r r r r s s s s s s s s s s s s s s s s s s s s s s s s s s s (foundation-0.0.30-9BPNbqL9YFL1YXPlNJAt6G 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.Conduit.TextualFoundation.HashingFoundation.StrictFoundation.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==>=>>=>>fmapreturn Data.String fromStringGHC.Real fromIntegral realToFracGHC.ExtsIsListfromList fromListNtoList<>memptymappendmconcat<*>pure*>BoundedEnumEqMonadFunctorOrdGHC.ShowShowData.Typeable.InternalTypeableIsString Applicative SemigroupMonoid GHC.TypesBoolCharDoubleFloatIntGHC.IntInt8Int16Int32Int64 ghc-bignumGHC.Num.IntegerIntegerGHC.Num.NaturalNatural GHC.MaybeMaybeOrderingRationalIOWordGHC.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.StdHandlesstdinstdoutGHC.IO.Exception IOExceptionGHC.Exception.Type toException fromExceptiondisplayException ExceptionrightspartitionEithersleftseither Data.ProxyProxy asProxyTypeOfControl.Categoryid. GHC.IO.IOMode WriteMode ReadWriteModeReadMode AppendModeIOModecastPtrGHC.BitszeroBitsxor unsafeShiftR unsafeShiftLtestBitshiftRshiftLshiftsetBitrotateRrotateLrotatepopCountisSigned complementBit complementclearBit bitSizeMaybebitSizebit.|..&.Bits^^toEnumsuccpredfromEnumminBoundmaxBound Data.Maybe maybeToListmaybemapMaybe listToMaybe isNothingisJust fromMaybe catMaybes Data.Functionon Data.Functor<$> Data.Tupleuncurryswapcurry<$liftA2<*somemany<|>untilflipconstasTypeOf=<<$!GHC.Err undefined SomeException&&not||/=<<=>comparemaxmin&basement-0.0.16-3uwtrFwJBNe9fYsJNLpD8fBasement.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$fMonadFailExceptT$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$fShowCondition $fEqCondition$fEqAnd $fShowNoMore $fEqNoMoretoString 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 $fShowArch$fEqArch $fOrdArch $fEnumArch $fBoundedArch $fDataArch$fShowOS$fEqOS$fOrdOS$fEnumOS $fBoundedOS$fDataOSSeconds NanoSeconds$fPrimTypeNanoSeconds$fPrimTypeSeconds $fShowSeconds $fEqSeconds $fOrdSeconds$fAdditiveSeconds $fEnumSeconds$fBoundedSeconds$fShowNanoSeconds$fEqNanoSeconds$fOrdNanoSeconds$fAdditiveNanoSeconds$fEnumNanoSeconds$fBoundedNanoSecondsStopWatchPrecise 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$fShowFileName_Invalid $fEqFileName$fShowFilePath_Invalid$fEqRelativity$fShowRelativityopenFile closeFilehGethPutwithFilereadFile.| sourceFile sourceHandleyieldssinkFile sinkHandlesinkListrecordCrecord_filerecordfield fileMapReadfileMapReadWithURIPath URIFragmentURIQuery URIAuthority URISchema $fPathURI builderLiftSystem.Posix.TypesCOffCModeForeign.C.TypesCWcharCUShort CUSecondsCULongCULLongCUIntPtrCUIntMaxCUIntCUCharCTimeCSize CSigAtomicCShort CSUSecondsCSCharCPtrdiffCLongCLLongCIntPtrCIntMaxCIntCFloatCDoubleCClockCCharCBoolBasement.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_ALARMsysTime_CLOCK_TAIEntropySystemMissing 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