Emi      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_ `abcdefghijklm n o p q rstuvwxy z { | } ~                        ! " # $%&'()*+,-./0123456789:;<=>? @ A B C D E F G HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                    !"#$%&'()*+,-./0123456789:;<=>?@A B C D EFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       !"#$%&'()*+,-./012345678!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 Z [ \ ] ^ _ ` 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 z { |"}"~""""""""""""""""###############$$$$%%%%%%%%%%%%%%%%%%&&'''(((((((((())))*******++++++++++++++++++**,,,,,,,,,,,,,,,,,,,, , , , , ------------------- -!-"-#-$-%-&-'-(-).*.+.,.-...//0/1/2/3/4/5/6/7/8/9/:/;/<0=0>0?0@0A0B0C0D0E0F0G0H0I0J0K0L0M0N0O0P0Q0R0S0T0U V W X Y Z [ \1]1^_`ab#c#d#e#f#g#h#2Safe)0DRijklmnop qrstijklmnopijklmnop3 BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableSafe)0DR  BSD-style FoundationstableportableSafe)0DR4None )0BDRuConvert a byte value in Word to two Word9s containing the hexadecimal representation of the Word#GThe output words# are guaranteed to be included in the 0 to 2^7-1 rangejNote that calling convertByte with a value greater than 256 will cause segfault or other horrible effect.v hex word16w hex word32xyuvwz{uvwxyuvwz{5None )0<=BDR|*Various conversion between integral number}lossless integral convertion~ Convert an + into a 5|}~}~|}~6Safe)0DR]\7 BSD-style*Nicolas Di Prima <nicolas@primetype.co.uk>statbleportableSafe)0DR"8 BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableSafe)0DRvxw9 BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0BDRPinning statusLowlevel BooleanCountOf in bytes type aliasEfor code documentation purpose only, just a simple type alias on Int#)Offset in a bytearray, string, type aliasEfor code documentation purpose only, just a simple type alias on Int#File size in bytes: BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone  )0BDR:Flag record whether a specific byte array is pinned or notturn an Int# into a Bool<Since GHC 7.8, boolean primitive don't return Bool but Int#.A version friendly of andI#!A version friendly of quotRemInt#*A version friendly fo copyAddrToByteArray#only available from GHC 7.8*A version friendly fo copyByteArrayToAddr#only available from GHC 7.8*A mkWeak# version that keep working on 8.0,signature change in ghc-prim: * 0.4: mkWeakD :: o -> b -> c -> State RealWorld -> (State RealWorld, Weak b) * 0.5 :mkWeak :: o -> b -> (State RealWorld -> (State RealWorld, c )) -> State RealWorld -> (State RealWorld, Weak b)5 ;None )0DIRQ< BSD-style FoundationNone )09;DRNegation support e.g. -(f x)Fractional Literal support'e.g. 1.2 :: Double 0.03 :: FloatIntegral Literal support&e.g. 123 :: Integer 123 :: Word8/,= BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DRP> BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableSafe)0DRONM? BSD-style foundationSafe)0DR@Safe )*0DRA BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DR/Only to use internally for internal error cases!for support of if .. then .. elseP  !"#$&'CF()*+,-./01DE2IJK456789:;GHa`djuB BSD-style Foundation experimentalportableNone)0DR(Class of types that can be byte-swapped.e.g. Word16, Word32, Word64C BSD-stylePsychohistorians experimentalportableNone)0DRSimple Reader monadSimple State monad None)09DR/Method to support basic trigonometric functionsthe famous pi valuesinecosinetansine-1cosine-1 tangent-1hyperbolic sinehyperbolic cosinehyperbolic tangenthyperbolic sine-1hyperbolic cosine-1hyperbolic tangent-1 DNone )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  Monad that can represent failureHSimilar to MonadFail but with a parametrized Failure linked to the MonadbThe associated type with the MonadFailure, representing what failure can be encoded in this monad Raise a Failure through a monad.  ENone)0DRBasic Transformer classGLift a computation from an inner monad to the current transformer monadNone )/05DRONM]\]\ONMFNone)0DRIdentity Transformer  GNone)0DR  $]\None)0DRReader Transformer HNone)09DRIEEE754 Floating Point    INone)0DRJNon Negative Number literals, convertible through the generic Natural type>Number literals, convertible through the generic Integer type.Fall number are Enum'erable, meaning that you can move to next element      JNone )0BDReRepresent class of things that can be added together, contains a neutral element and is commutative. )x + azero = x azero + x = x x + y = y + x !"#$%&'()*+,-. !"#$%&'()*+,-.6KNone )09;DR'Support for division between same typesCThis is likely to change to represent specific mathematic divisions3Represent types that supports an euclidian division "(x div  y) * y + (x mod  y) == x9Represent class of things that can be multiplied together #x * midentity = x midentity * x = x$Identity element over multiplication;Multiplication of 2 elements that result in another element Raise to power, repeated multiplication e.g. > a ^ 2 = a * a > a ^ 10 = (a ^ 5) * (a ^ 5) .. (^) :: (IsNatural n) => a -> n -> a+  /0123456789:;<=>?@ABCDEFGHIJKLMN   $  /0123456789:;<=>?@ABCDEFGHIJKLMN77 8L BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DIR BAn error related to the evaluation of a Partial value that failed.?it contains the name of the function and the reason for failure Partialiality wrapper.O"Throw an asynchronous PartialError CCreate a value that is partial. this can only be unwrap using the  functionDewrap a possible partial valueP*Partial function to get the head of a listQ1Partial function to grab the value inside a Maybe  R SO PQTUV   O PQTU  R SO PQTUVM BSD-styleHaskell Foundation experimentalportableNone )0DIRBig Endian valueLittle Endian value.Convert a value in cpu endianess to big endian5Convert from a big endian value to the cpu endianness1Convert a value in cpu endianess to little endian8Convert from a little endian value to the cpu endianness&endianness of the current architectureWX WXNNone)0DRYZ[\]YZ[\]YZ[\]ONone)06<=BDRTOCast an integral value to another value that have the same representional sizeUpsize an integral valueThe destination type b9 size need to be greater or equal than the size type of a!Downsize an integral valueZ !"#^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#_`abdefgV !""#^_`abcdefghijklmnopqrstuvwxyz{|}~PNone)0DR$1Represent class of things that can be subtracted.dNote that the result is not necessary of the same type as the operand depending on the actual type. For example: (-) :: Int -> Int -> Int (-) :: DateTime -> DateTime -> Seconds (-) :: Ptr a -> Ptr a -> PtrDiff (-) :: Natural -> Natural -> Maybe Natural$%&$%&$%&&6 BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )09;DR(Round up, to the next integral.Also known as ceiling)$Round down, to the previous integralAlso known as floor*GTruncate to the closest integral to the fractional number closer to 0.TThis is equivalent to roundUp for negative Number and roundDown for positive Number+Round to the nearest integral roundNearest 3.64 > roundNearest 3.4 3,-types that have sign and can be made absolute/Sign of a signed number'()*+,-./0123456789:;<=(  $%&'()*+,-./012(,-.$%& /012 '()*+'()*+,-./0123456789:;<=Q BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )0ABDRT?)Primitive monad that can handle mutation.For example: IO and ST.@3type of state token associated with the PrimMonad mA0type of variable associated with the PrimMonad mBmUnwrap the State# token to pass to a function a primitive function that returns an unboxed state and a value.C&Throw Exception in the primitive monadD(Run a Prim monad from a dedicated state#E&Build a new variable in the Prim MonadF#Read the variable in the Prim MonadG$Write the variable in the Prim Monad just like unwrapPrimMonad9 but throw away the result and return just the new State#+Convert a prim monad to another prim monad.The net effect is that it coerce the state repr to another, so the runtime representation should be the same, otherwise hilary ensues.%Convert any prim monad to an ST monad%Convert any prim monad to an IO monad$Convert any IO monad to a prim monad(Touch primitive lifted to any prim monad?@ABCDEFG?@ABCDEFG ?@ABCDEFGR BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )0BDRH-Create a pointer with an associated finalizerK3Check if 2 final ptr points on the same memory bitsit stand to reason that provided a final ptr that is still being referenced and thus have the memory still valid, if 2 final ptrs have the same address, they should be the same final ptrL$create a new FinalPtr from a PointerM'Create a new FinalPtr from a ForeignPtrN.Cast a finalized pointer from type a to type bP}Looks at the raw pointer inside a FinalPtr, making sure the data pointed by the pointer is not finalized during the call to fRUnsafe version of PHIJKLMNOPQR HIJKLMNOPQRHIJKLMNOPQRNone%&),0ADQRTSGConstraint to check if a natural is within a specific bounds of a type.i.e. given a Nat n", is it possible to convert it to ty without losing informationT?Check if a Nat is in bounds of another integral / natural typesUGGet Maximum bounds of different Integral / Natural types related to Nat STUVWXYZ[\]^_%<=>?@ABklSTUVWXYZ[\]^_<%kl@=>?ABVZYXW[_^]\UTS STUVWXYZ[\]^_ BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone%&),0ADQRT`abcdefghijklmnopqrstuvwxyz{|`abcdefghijklmnopqrstuvwxyz{|`abaghifjdesktlnmopqruvwxyz{|c`abcdefghijklmnopqrstuvwxyz{|S BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )0<=BDIR}CountOf of a data structure.@More specifically, it represents the number of elements of type ty# that fit into the data structure.6length (fromList ['a', 'b', 'c', '']) :: CountOf Char CountOf 4Same caveats as  apply here.%CountOf of a data structure in bytes.:Offset in a data structure consisting of elements of type ty.Int is a terrible backing type which is hard to get away from, considering that GHC/Haskell are mostly using this for offset. Trying to bring some sanity by a lightweight wrapping.IOffset in bytes used for memory addressing (e.g. in a vector, string, ..)File size in bytes+subtract 2 CountOf values of the same type.gm need to be greater than n, otherwise negative count error ensue use the safer (-) version if unsure.+subtract 2 CountOf values of the same type.gm need to be greater than n, otherwise negative count error ensue use the safer (-) version if unsure.)}~}~&}~T BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DR?Exception during an operation accessing the vector out of boundXRepresent the type of operation, the index accessed, and the total length of the vector.<The type of operation that triggers an OutOfBound exception.&OOB_Index: reading an immutable vector"OOB_Read: reading a mutable vector!OOB_Write: write a mutable vector UNone)0DR/Data that can be fully evaluated in Normal Form1      !"#$%&'()*+,-./01230      !"#$%&'()*+,-./0123V BSD-style foundationNone)0DR45Defines the maximum size in bytes of unpinned arrays.?You can change this value by setting the environment variable !HS_FOUNDATION_UARRAY_UNPINNED_MAX to an unsigned integer number. Note: We use 5 here. If the environment variable changes during runtime and the runtime system decides to recompute this value, referential transparency is violated (like the First Order violated the Galactic Concordance!).CTODO The default value of 1024 bytes is arbitrarily chosen for now.444WNone)09;BDRT 6[A constraint class for serializable type that have an unique memory compare representatione.g. Float and Double have -0.0 and 0.0 which are Eq individual, yet have a different memory representation which doesn't allow for memcmp operationNRepresent the accessor for types that can be stored in the UArray and MUArray.=Types need to be a instance of storable and have fixed sized.%get the size in bytes of a ty elementget the shift size-return the element stored at a specific index.Read an element at an index in a mutable array7Write an element to a specific cell in a mutable array.Read from Address, without a state. the value read should be considered a constant for all pratical purpose, otherwise bad thing will happens.4Read a value from Addr in a specific primitive monad3Write a value to Addr in a specific primitive monad7UCast a CountOf linked to type A (CountOf A) to a CountOf linked to type B (CountOf B)@689:;<=>?@A7BCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkl689:;<=7CDEFGIJKL8689:;<=>?@A7BCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklXNone  )0BDRmnopqrsmnopqrsmnopqrsYNone )0BDRTPA Mutable block of memory containing unpacked bytes representing values of type tyHA block of memory containing unpacked bytes representing values of type tytCreate an empty block of memoryMReturn the element at a specific index from an array without bounds checking.NReading from invalid memory can return unpredictable and invalid values. use index if unsure.u%make a block from a list of elements.vtransform a block to a list.w!Check if two blocks are identicalxCompare 2 blocksy7Append 2 blocks together by creating a new bigger block$Freeze a mutable block into a block.|If the mutable block is still use after freeze, then the modification will be reflected in an unexpected way in the Block.Thaw an immutable block.If the immutable block is modified, then the original immutable block will be modified too, but lead to unexpected results when queryingz7Create a new mutable block of a specific size in bytes.qNote that no checks are made to see if the size in bytes is compatible with the size of the underlaying element ty in the block.use { if unsure{3Create a new mutable block of a specific N size of ty elements|ECopy a number of elements from an array to another array with offsets}]Copy a number of bytes from a MutableBlock to another MutableBlock with specific byte offsets~PCopy a number of bytes from a Block to a MutableBlock with specific byte offsets<read from a cell in a mutable block without bounds checking.NReading from invalid memory can return unpredictable and invalid values. use read if unsure.;write to a cell in a mutable block without bounds checking.^Writing with invalid bounds will corrupt memory and your program will become unreliable. use write if unsure.'tuvwxyz{|destination mutable blockoffset at destinationsource mutable blockoffset at sourcenumber of elements to copydestination mutable blockoffset at destination source blockoffset at sourcenumber of elements to copy}destination mutable blockoffset at destinationsource mutable blockoffset at sourcenumber of elements to copy~destination mutable blockoffset at destination source blockoffset at sourcenumber of elements to copyz{|}~%tuvwxyz{|}~Z BSD-styleHaskell FoundationNone )0BDRT$Return the length of a Mutable BlockEnote: we don't allow resizing yet, so this can remain a pure function4Get the address of the context of the mutable block.;if the block is not pinned, this is a _dangerous_ operation(Set all mutable block element to a valueread a cell in a mutable array.2If the index is out of bounds, an error is raised.#Write to a cell in a mutable array.2If the index is out of bounds, an error is raised.z{|}~[None)0BDR :e\None )0:ABDRT   ]None )0:BDR   ^ BSD-style FoundationNone )0:BDRADifferent way to encode a Character in UTF8 represented as an ADTTransform a Unicode code point ( intovnote that we expect here a valid unicode code point in the *allowed* range. bits will be lost if going above 0x10ffff_ BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0BDR(Check if the byte is a continuation byteJGet the number of following bytes given the first byte of a UTF8 sequence.(Check if the byte is a continuation byteJGet the number of following bytes given the first byte of a UTF8 sequence. `None)0DR?Possible failure related to validating bytes of UTF8 sequences.$Step when processing ASCII characterEStep when processing digits. the value is between 0 and 9 to be validASimilar to Step but used when processing the string from the end.fThe stepper is thus the previous character, and the offset of the beginning of the previous characterStep when walking a Stringthis is a return value composed of : * the unicode code point read (Char) which need to be between 0 and 0x10ffff (inclusive) * The next offset to start reading the next unicode code point (or end)aNone )0:BDRAnextAsciiBa specialized to get a digit between 0 and 9 (included)bNone )0:BDRAnextAsciiBa specialized to get a digit between 0 and 9 (included)c BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )0BDRCopy all bytes from a byteArray to a mutableByteArray$Copy @nbBytes bytes from a byteArray to a mutableByteArray starting at an offsetsame as  except copy using 32 bits wordsame as  except copy using 64 bits worddNone )0:BDR   eNone )0:BDR      f(c) Vincent Hanquez 2014-2017 BSD-styleVincent Hanquez provisionalnon-portable (requires Linux)None)0DR   !"#$%&'()*   !"#$%&'()*   !"#$%&'()*gNone)0DR+,-./+,-./+,-./h(c) Vincent Hanquez 2014-2017 BSD-styleVincent Hanquez provisionalnon-portable (requires POSIX)None)0DR0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~iNone)0DR0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~jNone)0DRk BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DRl 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 foundation experimentalportableNone)0:DR Path type classddefines the Path associated types and basic functions to implement related to the path manipulation # TODO, add missing enhancement: ~splitExtension :: PathEnt path -> (PathEnt path, PathEnt path) addExtension :: PathEnt path -> PathEnt path -> PathEnt path ( .$) :: path -> PathEnt path -> path (- .") :: path -> PathEnt path -> path 'the associated PathEntity of the given path this type is the minimal element contained in the Path a Path is not a collection but it is possible to see this associated type equivalent to the m type family#the associated prefix of the given pathin the case of a no-, it is a void (i.e. `()`) in the case of a np!, it is the schema, host, port...'the associated suffix of the given pathin the case of the no/, it is a void (i.e. `()`) in the case of the np!, it is a the query, the fragment"join a path entity to a given path+split the path into the associated elements+build the path from the associated elements*parent is only going to drop the filename.Gif you actually want to reference to the parent directory, simply uses:  parent "." = "." <> ".." parent ("foo.hs" :: FilePath).%parent ("foo/bar/baz.hs" :: FilePath)foo/bar"get the filename of the given path.If there is no filename, you will receive the  of the filename ("foo.hs" :: FilePath)foo.hs'filename ("foo/bar/baz.hs" :: FilePath)baz.hsget the path prefix information prefix ("/home/tab" :: FilePath)Absoluteprefix ("home/tab" :: FilePath)Relative#or for URI (TODO, not yet accurate) prefix " .http://github.com/vincenthz/hs-foundation?w=1"; == URISchema http Nothing Nothing "github.com" Nothing get the path suffix information suffix ("/home/tab" :: FilePath)()#or for URI (TODO, not yet accurate) suffix " .http://github.com/vincenthz/hs-foundation?w=1"' == URISuffix (["w", "1"], Nothing)    BSD-style foundation experimentalportableNone)0DR TODO this is not implemented yet    BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )09;<=DR1Class of things that can be converted from a to bq BSD-style Foundation experimentalportableNone)0DR$NonEmpty property for any Collection BSD-styleHaskell FoundationNone )0BDRTLCopy all the block content to the memory starting at the destination addressCreate a new array of size /n by settings each cells through the function f. Thaw a Block into a MutableBlockqthe Block is not modified, instead a new Mutable Block is created and its content is copied to the mutable block4Copy every cells of an existing Block to a new Block5Return the element at a specific index from an array.5If the index @n is out of bounds, an error is raised.Map all element a from a block to a new block of b!the source block to copy8The destination address where the copy is going to start(the size of the block (in element of ty),the function that set the value at the indexthe array created))! BSD-styleHaskell FoundationNone),0DIQRTfr BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DR?Simple helper to split a list repeatly when the predicate matchs BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )09;DR1Collection of things that can be looked up by Key BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableSafe)0DR[YXZ[ZYXNone)0DLRState Transformer     t BSD-style*Nicolas Di Prima <nicolas@primetype.co.uk>stableportableNone)0DR Either a or b or both.           BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )09;DR. !"#?@ABCDEFG   0?@ABCDEFG !""#   u 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. !"#$%&'()*+,-./012   !"#$%&'()*+,-./012vNone)0DRCompute the size of the listSum the element in a listwNone $)0BDRT3/An array of type built on top of GHC primitive.The elements need to have fixed sized and the representation is a packed contiguous array in memory that can easily be passed to foreign interface57A Mutable array of types built on top of GHC primitive./Element in this array can be modified in place.'Return if the array is pinned in memory-note that Foreign array are considered pinned-Return if a mutable array is pinned in memory6-Create a new pinned mutable array of size @n.Ball the cells are uninitialized and could contains invalid values.?All mutable arrays are allocated on a 64 bits aligned addresses7&Create a new mutable array of size @n.When memory for a new array is allocated, we decide if that memory region should be pinned (will not be copied around by GC) or unpinned (can be moved around by GC) depending on its size.MYou can change the threshold value used by setting the environment variable !HS_FOUNDATION_UARRAY_UNPINNED_MAX.<read from a cell in a mutable array without bounds checking.NReading from invalid memory can return unpredictable and invalid values. use read if unsure.;write to a cell in a mutable array without bounds checking.^Writing with invalid bounds will corrupt memory and your program will become unreliable. use write if unsure.MReturn the element at a specific index from an array without bounds checking.NReading from invalid memory can return unpredictable and invalid values. use index if unsure. %Freeze a mutable array into an array./the MUArray must not be changed after freezing. Thaw an immutable array.*The UArray must not be used after thawing. &make an array from a list of elements. transform an array to a list. "Check if two vectors are identicalCompare 2 vectorsECopy a number of elements from an array to another array with offsetsCopy nu sequential elements from the specified offset in a source array to the specified position in a destination array.mThis function does not check bounds. Accessing invalid memory can return unpredictable and invalid values.7Append 2 arrays together by creating a new bigger array:3456 move to a MutableBlock7! " #$%&'(   )*+,-destination arrayoffset at destination source arrayoffset at sourcenumber of elements to copydestination arrayoffset at destination source arrayoffset at sourcenumber of elements to copy./012345678)3456 7! " #$%&'( */133456 7! " #$%&'(   )*+,-./012345678xNone)0DIR8.The in-progress state of a building operation.The previous buffers are in reverse order, and this contains the current buffer and the state of progress packing the elements inside. 89:;<=>?@9 89:;<=>?@89:;<=>?@9 None)0DRAUnsafe Shift Left OperatorBUnsafe Shift Right OperatorC&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 = 16D(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 = 8ABCNumber to AlignAlignment (power of 2)DNumber to AlignAlignment (power of 2)~}|{zyABCDAB~}|{zyCDABCDy#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )0BDRT:read a cell in a mutable array.2If the index is out of bounds, an error is raised.;#Write to a cell in a mutable array.2If the index is out of bounds, an error is raised.<1return the numbers of elements in a mutable arrayFLCreate a pointer on the beginning of the mutable array and call a function f.)The mutable buffer can be mutated by the f@ function and the change will be reflected in the mutable arraycIf the mutable array is unpinned, a trampoline buffer is created and the data is only copied when f return.=Copy from a pointer, count! elements, into the mutable array>LCopy all the block content to the memory starting at the destination address ?:;@AE"the start pointer with a finalizer/the number of elements (in elements, not bytes)B<CF=> the source mutable array to copy8The destination address where the copy is going to startD56 7%?:;AEB<F=>D ?:;@AEB<CF=>DzNone)0DREMutable Byte Array aliasEFEFEF{ BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )0BDORTG4Copy every cells of an existing array to a new arrayH!Thaw an array to a mutable array.the array is not modified, instead a new mutable array is created and every values is copied, before returning the mutable array.I5Return the element at a specific index from an array.5If the index @n is out of bounds, an error is raised.JaAllocate a new array with a fill function that has access to the elements of the source array.KCreate a new array of size /n by settings each cells through the function f.L*Create a pinned array that is filled by a filler- function (typically an IO call like hGetBuf)MKFreeze a chunk of memory pointed, of specific size into a new unboxed arrayN9update an array by creating a new array with the updates.Jthe operation copy the previous array, modify it in place, then freeze it.ILCopy all the block content to the memory starting at the destination addressK*Recast an array of type a to an array of bKa and b need to have the same size otherwise this raise an async exceptionOTTake a count of elements from the array and create an array with just those elementsP]Drop a count of elements from the array and return the new array minus those dropped elementsQmSplit an array into two, with a count of at most N elements in the first one and the remaining in the other.R5Similar to breakElem specialized to split on linefeedit either returns: * Left. no line has been found, and whether the last character is a CR * Right, a line has been found with an optional CR, and it returns the array of bytes on the left of the CR/LF, and the the array of bytes on the right of the LF.S-Take the N elements from the end of the arrayT-Drop the N elements from the end of the arrayUSplit an array at the N element from the end, and return the last N elements in the first part of the tuple, and whatever first elements remaining in the secondV Replace all the occurrencies of needle with  replacement in the haystack string.CGHIG"the start pointer with a finalizer/the number of elements (in elements, not bytes)HJ Source arrayLength of the destination array4Function called for each element in the source arrayReturns the filled new arrayWXYKthe size of the array,the function that set the value at the indexthe array createdLthe size of the arrayfilling function thatMZ[N\Ithe source array to copy8The destination address where the copy is going to startJK]^O_P`QabRcSTUdefghijklmnopqrstuVvwxyz{|}~LV347! " &*FGHIGHWXYKLMZ[N\IJK]^O_P`QaRSTUdefghijklmnopqrstuVvwxyz{|}~LCGHIGHJWXYKLMZ[N\IJK]^O_P`QabRcSTUdefghijklmnopqrstuVvwxyz{|}~L BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DRBHIJKLMNOPQREG HIJKNLMQPROGE| BSD-style Foundation experimentalportableNone)0:DRZthe unit element use for the encoding. i.e. Word8 for ASCII7 or UTF8, Word16 for UTF16...Idefine the type of error handling you want to use for the next function. %type Error UTF8 = Either UTF8_Invalidnconsume an `Unit encoding` and return the Unicode point and the position of the next possible `Unit encoding`Yhelper to convert a given Array in a given encoding into an array with another encoding.tThis is a helper to convert from one String encoding to another. This function is (quite) slow and needs some work.z``` let s16 = ... -- string in UTF16 -- create s8, a UTF8 String let s8 = runST $ convertWith UTF16 UTF8 (toBytes s16) print s8 ```Input's encoding typeOutput's encoding typethe input raw array} BSD-style Foundation experimentalportableNone)0BDR>validate a given byte is within ASCII characters encoring size+This function check the 8th bit is set to 0fconsume an Ascii7 char and return the Unicode point and the position of the next possible Ascii7 char method to access a given byteindex of the byte_either successfully validated the ASCII char and returned the next index or fail with an error\expecting it to be a valid Ascii character. otherwise this function will throw an exception~ BSD-style Foundation experimentalportableNone)0BDR  BSD-style Foundation experimentalportableNone)0BDR  BSD-style Foundation experimentalportableNone)0BDR BSD-style foundation experimentalportableNone )0:BDRHassuming the given ByteArray is a valid modified UTF-8 sequence of bytesJWe only modify the given Unicode Null-character (0xC080) into a null bytesFIXME: need to evaluate the kind of modified UTF8 GHC is actually expecting it is plausible they only handle the Null Bytes, which this function actually does. BSD-style FoundationNone )0:BDIRMutable String Buffer.Use as an *append* buffer, as UTF8 variable encoding doesn't really allow to change previously written character without potentially shifting bytes.M6Opaque packed array of characters in the UTF8 encodingsize in bytes.this size is available in o(1)(Convert a String to a list of characters/The list is lazily created as evaluation needed-Create a new String from a list of characterszThe list is strictly and fully evaluated before creating the new String, as the size need to be computed before filling.5Allocate a MutableString of a specific size in bytes.M$in number of bytes, not of elements.$in number of bytes, not of elements.MMNone )+0ABDRTN,stop execution and displays an error messageNNNNone)0DRO&Use the Show class to create a String.yNote that this is not efficient, since an intermediate [Char] is going to be created before turning into a real String.OOO BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )0:BDRBPDVarious String Encoding that can be use to convert to and from bytes UTF8 Encoder"Validate a bytearray for UTF8'nessUOn success Nothing is returned On Failure the position along with the failure reason Similar to  but works on a ECheck if a String is null GCreate a string composed of a number @n of Chars (Unicode code points).Zif the input @s contains less characters than required, then the input string is returned. SCreate a string with the remaining Chars after dropping @n Chars from the beginning iSplit a string at the Offset specified (in Char) returning both the leading part and the remaining part. CReturn the offset (in bytes) of the N'th sequence in an UTF8 String  Similar to   but from the end  Similar to   but from the end  Similar to   but from the end :Split on the input string using the predicate as separatore.g. splitOn (== ',') "," == ["",""] splitOn (== ',') ",abc," == ["","abc",""] splitOn (== ':') "abc" == ["abc"] splitOn (== ':') "abc::def" == ["abc","","def"] splitOn (== ':') "::abc::def" == ["","","abc","","def"] 8Internal call to make a substring given offset in bytes.tThis is unsafe considering that one can create a substring starting and/or ending on the middle of a UTF8 sequence. ;Internal call to split at a given index in offset of bytes.bThis is unsafe considering that one can split in the middle of a UTF8 sequence, so use with care. MBreak a string into 2 strings at the location where the predicate return True EBreak a string into 2 strings at the first occurence of the characterVFSame as break but cut on a line feed with an optional carriage return.eThis is the same operation as 'breakElem LF' dropping the last character of the string if it's a CR.\Also for efficiency reason (streaming), it returns if the last character was a CR character. Apply a  predicateY to the string to return the longest prefix that satisfy the predicate and the remaining =Drop character from the beginning while the predicate is true >Return whereas the string contains a specific character or not Intersperse the character sep% between each character in the string "intersperse ' ' "Hello Foundation"!"H e l l o F o u n d a t i o n" Allocate a new StringI with a fill function that has access to the characters of the source String.  Length of a String using CountOfthis size is available in o(n) Replicate a character c n$ times to create a string of length n Copy the StringkThe slice of memory is copied to a new slice, making the new string independent from the original string.. Create a single element String "Unsafely create a string of up to sz bytes. The callback f needs to return the number of bytes filled in the underlaying bytes buffer. No check is made on the callback return values, and if it's not contained without the bounds, bad things will happen. LMonomorphically map the character in a string and return the transformed one AAppend a Char to the end of the String and return this new String HPrepend a Char to the beginning of the String and return this new String UExtract the String stripped of the last character and the last character if not emptyIf empty, Nothing is returned XExtract the First character of a string, and the String stripped of the first character.If empty, Nothing is returned LLook for a predicate in the String and return the matched character, if any. =Sort the character in a String using a specific sort function'TODO: optimise not going through a list 1Filter characters of a string using the predicate Reverse a stringX Replace all the occurrencies of needle with  replacement in the haystack string. $Return the nth character in a StringlCompared to an array, the string need to be scanned from the beginning since the UTF8 encoding is variable. WReturn the index in unit of Char of the first occurence of the predicate returning True!If not found, Nothing is returnedY=Convert a ByteArray to a string assuming a specific encoding.It returns a 3-tuple of:@The string that has been succesfully converted without any errorAn optional validation errorThe remaining buffer that hasn't been processed (either as a result of an error, or because the encoded sequence is not fully available)Considering a stream of data that is fetched chunk by chunk, it's valid to assume that some sequence might fall in a chunk boundary. When converting chunks, if the error is Nothing and the remaining buffer is not empty, then this buffer need to be prepended to the next chunkZ*Convert a UTF8 array of bytes to a String.qIf there's any error in the stream, it will automatically insert replacement bytes to replace invalid sequences.In the case of sequence that fall in the middle of 2 chunks, the remaining buffer is supposed to be preprended to the next chunk, and resume the parsing. !SDecode a stream of binary chunks containing UTF8 encoding in a list of valid String`Chunk not necessarily contains a valid string, as a UTF8 sequence could be split over 2 chunks.[cConvert a Byte Array representing UTF8 data directly to a string without checking for UTF8 validitycIf the input contains invalid sequences, it will trigger runtime async errors when processing data.In doubt, use Y\6Convert a String to a bytearray in a specific encodingeif the encoding is UTF8, the underlying buffer is returned without extra allocation or any processingJIn any other encoding, some allocation and processing are done to convert.]4Split lines in a string using newline as separation.xNote that carriage return preceding a newline are also strip for maximum compatibility between Windows and Unix system.^2Split words in a string using spaces as separation words "Hello Foundation"  Hello,  Foundation "&Append a character to a String builder #,Create a new String builder using chunks of  sizeChunksI_Read an Integer from a StringCConsume an optional minus sign and many digits until end of string.aRead a Natural from a String(Consume many digits until end of string.bTry to read a Doublec+Try to read a floating number as a Rational Note that for safety reason, only exponent between -10000 and 10000 is allowed as otherwise DoS/OOM is very likely. if you don't want this behavior, switching to a scientific type (not provided yet) that represent the exponent separately is the advised solution.d)Read an Floating like number of the form:  &  numbers [ `  numbers ] [ ( e | E ) [ & ]  number ]Call a function with:0A boolean representing if the number is negativeYThe digits part represented as a single natural number (123.456 is represented as 123456)?The number of digits in the fractional part (e.g. 123.456 => 3)The exponent if any6The code is structured as a simple state machine that:Optionally Consume a & sign$Consume number for the integral part OptionallyConsume `5Consume remaining digits if not already end of stringOptionally Consume a e or E follow by an optional & and a number $)Take decimal digits and accumulate it in acc?The loop starts at the offset specified and finish either when:It reach the end of the stringIt reach a non-ASCII character8It reach an ASCII character that is not a digit (0 to 9)Otherwise each iterations:(Transform the ASCII digits into a numberscale the accumulator by 103Add the number (between 0 and 9) to the accumulatorIt then returns:The new accumulated value'Whether it stop by end of string or not$The end offset when the loop stoppedQIf end offset == start offset then no digits have been consumed by this function %-same as decimalDigitsBA specialized for ptr #e Convert a M_ to the upper-case equivalent. Does not properly support multicharacter Unicode conversions.f Convert a M_ to the upper-case equivalent. Does not properly support multicharacter Unicode conversions. &@Check whether the first string is a prefix of the second string. '@Check whether the first string is a suffix of the second string. (DCheck whether the first string is contains within the second string.STODO: implemented the naive way and thus terribly inefficient, reimplement properly )1Try to strip a prefix from the start of a String.mIf the prefix is not starting the string, then Nothing is returned, otherwise the striped string is returned */Try to strip a suffix from the end of a String.kIf the suffix is not ending the string, then Nothing is returned, otherwise the striped string is returnedgTransform string src! to base64 binary representation.hTransform string srct to URL-safe base64 binary representation. The result will be either padded or unpadded, depending on the boolean padded argument.iTransform string src) to OpenBSD base64 binary representation.X +PQRSTU , - . / 0 1    2      V    Source string)Length of the destination string in bytes7Function called for each character in the source StringReturns the filled new string              WX  3YZ ![ 4\]^ " # 5 6_`abcd $ %ef & ' ( ) * 7 8ghi 9NMPRQSTU        V                WX  YZ ![\]^ " # 5_`abcdef & ' ( ) * 7 8ghiR +PQRSTU , - . / 0 1    2      V                 WX  3YZ ![ 4\]^ " # 5 6_`abcd $ %ef & ' ( ) * 7 8ghi 9 BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DRMPRQSTUVWXYZ[\]^efghiMPQRSTUYZ[\]^efXWghiV BSD-style foundation experimentalportableNone)0DRj4Enumeration of the known GHC supported architecture.y9get the operating system on which the program is running.Either return the known s or a strict M of the OS name.This function uses the base's  : function.z<get the machine architecture on which the program is running1Either return the known architecture or a Strict M of the architecture name.This function uses the base's  ; function.{get the compiler nameKget the compilerName from base package but convert it into a strict String|*returns the number of CPUs the machine hasjklmnopqrstuvwxyz{|LUTSRjklmnopqrsvtuwxyz{|stuvwxyjklmnopqrz|{LUTSRjklmnopqrstuvwxyz{| BSD-style FoundationNone)0DR  < = > ? @  < = > ? @None)0DR_`abcd`_abcd  BSD-style FoundationstablegoodNone)0DRGet some of the system entropy BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DR 3467FHIJKL 34HJIKL76F BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )0BDRTMutable Array of a Array of a A1return the numbers of elements in a mutable array B1return the numbers of elements in a mutable array C5Return the element at a specific index from an array.5If the index @n is out of bounds, an error is raised. DMReturn the element at a specific index from an array without bounds checking.NReading from invalid memory can return unpredictable and invalid values. use  C if unsure. Eread a cell in a mutable array.2If the index is out of bounds, an error is raised. F<read from a cell in a mutable array without bounds checking.NReading from invalid memory can return unpredictable and invalid values. use  E if unsure. G#Write to a cell in a mutable array.2If the index is out of bounds, an error is raised. H;write to a cell in a mutable array without bounds checking.^Writing with invalid bounds will corrupt memory and your program will become unreliable. use  G if unsure. I%Freeze a mutable array into an array..the MArray must not be changed after freezing. JThaw an immutable array.)The Array must not be used after thawing. K!Thaw an array to a mutable array.the array is not modified, instead a new mutable array is created and every values is copied, before returning the mutable array. L'Copy the element to a new element array MECopy a number of elements from an array to another array with offsets NCopy nu sequential elements from the specified offset in a source array to the specified position in a destination array.mThis function does not check bounds. Accessing invalid memory can return unpredictable and invalid values. OaAllocate a new array with a fill function that has access to the elements of the source array. P&Create a new mutable array of size @n.Ball the cells are uninitialized and could contains invalid values.|All mutable arrays are allocated on a 64 bits aligned addresses and always contains a number of bytes multiples of 64 bits. QCreate a new array of size /n by settings each cells through the function f. R7Append 2 arrays together by creating a new bigger arrayN S T U A B C D E F G H I J K V L Mdestination arrayoffset at destination source arrayoffset at sourcenumber of elements to copy Ndestination arrayoffset at destination source arrayoffset at sourcenumber of elements to copy O Source arrayLength of the destination array4Function called for each element in the source arrayReturns the filled new array P Qthe size of the array,the function that set the value at the indexthe array created W X Y Z [ \ R ] ^ _ ` 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 z { | } ~  4 A C D E F G H I J K V L N P Y Z _ ` a b d e f g h i j k m n o p q r s t u v y z { | } ~  L S T U A B C D E F G H I J K V L M N O P Q W X Y Z [ \ R ] ^ _ ` 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 z { | } ~  None)0DR   BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DRElement type of a collection 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 89:;<=>?@    BSD-style Foundation experimentalportableNone )0:ADRT &A set of methods for ordered colectionCheck 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 True    BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DRIFold1's. Like folds, but they assume to operate on a NonEmpty collection.Left associative strict fold.Right associative lazy fold./Give the ability to fold a collection on itself%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 , a strict version of foldl, because the lazy version is seldom useful.MLeft-associative fold of a structure with strict application of the operator.&Right-associative fold of a structure. @foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...)SRight-associative fold of a structure, but with strict application of the operator.    BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )09;DR.Collection of elements that can indexed by int  None)06DRKA monomorphic functor that maps the inner values to values of the same type   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 .Evaluate each actions of the given collections, from left to right, and collect the results. For a version that ignores the results, see 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 .Evaluate each actions of the given collections, from left to right, and collect the results. For a version that ignores the results, see Map 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 Evaluate each action in the collection from left to right, and ignore the results. For a version that doesn't ignore the results see l. sequenceA_ :: (Mappable col, Applicative f) => col (f a) -> f () sequenceA_ col = sequenceA col *> pure ()Map each element of a collection to a monadic action, evaluate these actions from left to right, and ignore the results. For a version that doesn't ignore the results see . Evaluate each monadic action in the collection from left to right, and ignore the results. For a version that doesn't ignore the results see . is I with its arguments flipped. For a version that ignores the results see . is P with its arguments flipped. For a version that doesn't ignore the results see .       BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DRjCollection of things that can be made mutable, modified and then freezed into an MutableFreezed collection    BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )069:;<DR#&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 trueFReturn 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 true2Filter 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;<=DR 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#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )09;DR89:;<=>?@>?@89:;<=IBSD-style -- Maintainer : Alfredo Di Napoli <alfredo.dinapoli@gmail.com> experimentalportableNone $)0ABDORT Returns the length of this 8, by summing each inner length. Complexity: O(n) where n0 is the number of chunks, as U.length u is O(1). Returns F* if the given element is contained in the . Complexity: O(n) where n0 is the number of chunks, as U.length u is O(1). Fold a  leftwards strictly. Implemented internally using a double fold on the nested Array structure. Other folds implemented analogously. Equality between X. This function is fiddly to write as is not enough to compare for equality the inner 3/(s), we need an element-by-element comparison., +  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.5      !"#$%&'()*+,-./01234567:e     : e    1      !"#$%&'()*+,-./01234567! BSD-style*Nicolas Di Prima <nicolas@primetype.co.uk>statbleportableNone)0DR8 9:;<=>?@ABC88 8 9:;<=>?@ABC  BSD-styleHaskell Foundation experimentalportableNone )0:DORTI Foundation's Parser monad.-Its implementation is based on the parser in memory.Presult of executing the parser over the given inputQ!the parser failed with the given  ParserErrorR3the parser complete successfuly with the remaining ChunkS+the parser needs more input, pass an empty Chunk or mempty3 to tell the parser you don't have anymore inputs.Tcommon parser error definitionU meaning the parser was short of CountOf Element of input.V-The parser needed more data, only when using  parseOnlyW when using elementX when using elements or stringYthe satisfy or satisfy_ function failed,Z"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 P\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 D (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 parsera/take one element if satisfy the given predicateb/take one element if satisfy the given predicateeCTake the remaining elements from the current position in the streamh!consume every chunk of the streamj.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 ',')@DEFGHI JKLMNOPQRSTUVWXY Z[  \]^_`abcdefghij  klmnopqrstuv+_DEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghij+I[Z\PQRSTUVWXY]JKLMNO_^`iabcdefgh_jFGHDE,DEFGHI  JKLMNOPQRSTUVWXY Z[  \]^_`abcdefghij  klmnopqrstuv" BSD-styleHaskell Foundation experimentalportableNone )0:BDIR|7Opaque packed array of characters in the ASCII encoding GCreate a string composed of a number @n of Chars (Unicode code points).<if the input @s contains less characters than required, then SCreate a string with the remaining Chars after dropping @n Chars from the beginning :Split on the input string using the predicate as separatore.g. splitOn (== ',') "," == ["",""] splitOn (== ',') ",abc," == ["","abc",""] splitOn (== ':') "abc" == ["abc"] splitOn (== ':') "abc::def" == ["abc","","def"] splitOn (== ':') "::abc::def" == ["","","abc","","def"]Copy the AsciiString :Allocate a MutableAsciiString of a specific size in bytes.cConvert a Byte Array representing UTF8 data directly to a string without checking for UTF8 validitycIf the input contains invalid sequences, it will trigger runtime async errors when processing data.In doubt, use  fromBytes/ | }                  ~ $in number of bytes, not of elements.    ! " # $ %|}~ |}~},  | }                  ~     ! " # $ % BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DR &!for support of if .. then .. else ' ( &P  !"#$&'CF()*+,-./01DE2IJK456789:;GHQa`dju}3MNO ' ( & ' ( &None )0DORT<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. )%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. *WProvide new output to be sent downstream. This constructor has three fields: the next Pipe< to be used, a finalization function, and the output value. +^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. ,Processing with this Pipe) is complete, providing the final result. -4Require running of a monadic action to get the next Pipe. .EReturn leftover input, which should be provided to future operations. Await for a value from upstream.Send a value downstream.Same as W, but additionally takes a finalizer to be run if the downstream component terminates.\Provide leftover input to be consumed by the next component in the current monadic binding.%Run a conduit pipeline to completion.*Run a pure conduit pipeline to completion.Run a conduit pipeline in a ! context for acquiring resources. /Internal: run a PipePSend the output of the first Conduit component to the second Conduit component.B 0 1 2 3 4 5 6 7 8 9 : ; < = > ? ) * + , - . @ finalizer / 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 Z [ 0 1 ; < > ? ) * + , - . C1 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 Z [$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 functionNone)0BDR \ \ \ BSD-style Foundation experimentalportableNone)0DR!Print a string to standard output0Print a string with a newline to standard output+Get the arguments from the terminal commandVWbcbcWV% BSD-styleFoundation maintainersNone)0DIRAn amount of nanosecondsAn amount of nanoseconds&None)0DR'None)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  ] ^ ] ^( 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 ` a b c d e f g h i j k ` a b c d e f g h i j k BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DR l5Return the element at a specific index from a Bitmap.5If the index @n is out of bounds, an error is raised. mMReturn the element at a specific index from an array without bounds checking.NReading from invalid memory can return unpredictable and invalid values. use  l if unsure. n&make an array from a list of elements. otransform an array to a list. p"Check if two vectors are identical qCompare 2 vectors r7Append 2 arrays together by creating a new bigger arrayTODO completely non optimized> s t u v w x y z { | } ~  l m n o p q r  } ~  l m r < s t u v w x y z { | } ~  l m n o p q r  BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0BDR 35 35None)0DR 9Incremental Hashing state. Represent an hashing algorithm$the base primitive of this class is  ", append mix a Word8 in the stateThe class allow to define faster mixing function that works on bigger Word size and any unboxed array of any PrimType elements .Associate type when finalizing the state with  ?Associate type when initializing the state (e.g. a Key or seed) Create a new Hashing context Create a new Hashing context .Finalize the state and returns the hash result :Mix a Word8 (Byte) into the state and return the new state 4Mix a Word16 into the state and return the new state 4Mix a Word32 into the state and return the new state 4Mix a Word64 into the state and return the new state =Mix an arbitrary sized unboxed array and return the new state    BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalgoodNone)0BDR FNV1a 64 bit stateFNV1a 32 bit stateFNV1 64 bit stateFNV1 32 bit state FNV1(a) hash (64 bit variants) FNV1(a) hash (32 bit variants) 6compute FNV1 (32 bit variant) of a raw piece of memory 7compute FNV1a (32 bit variant) of a raw piece of memory 6compute FNV1 (64 bit variant) of a raw piece of memory 7compute FNV1a (64 bit variant) of a raw piece of memory            BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalgoodNone)0DR"Type with the ability to be hashedHashable doesn't have any specific rules, and it's made for raw speed. More specifically don't expect different type representing the same data to hash to the same value .hashMix (1 :: Integer) /= hashMix (1 :: Word8)True   BSD-style*Nicolas Di Prima <nicolas@primetype.co.uk> experimentalportableNone )09:;DIRIPv4 data type "0.0.0.0" "127.0.0.1"Parse a IPv4 address    + BSD-style*Nicolas Di Prima <nicolas@primetype.co.uk> experimentalportableNone )09;DR IPv6 data typeequivalent 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``::`         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 Key same as hash], except also specifies the number of sipround iterations for compression (C) and digest (D).#                            * BSD-style FoundationNone)0DR  , BSD-style experimentalGoodNone )0DRT RNG 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.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.[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 DS 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 DRG7A monad constraint that allows to generate random bytes6Run a pure computation with a Random Generator in the "                            None %&)0ADORT Generator monad         ! " # $ % & ' ( )       ! " % &           ! " # $ % & ' ( )None $)09;DR'How to generate an arbitrary value for a"Call one of the generator weighted( * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K' * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J KNone)0DR Loptional user specified seed MParameters for the generatoradefault: * 32bits long numbers; * array of 512 elements max; * string of 8192 bytes max. N1the number of tests to perform on every property. default: 100 O create the default configurationsee Config for details P Q R L M N S T U V W X Y Z [ O \ ] ^ Q R L M N S T U V W X Y Z [ O ] ^ P Q R L M N S T U V W X Y Z [ O \ ] ^None )09;DR _'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 pass _ ` a b c d e f g h i j3name of the function used for comparaison, e.g. (<)#function used for value comparaisonvalue left of the operatorvalue right of the operator k l m n o _ ` a b c d e f h i _ ` a b c d e f g h i j k l m n o4 BSD-styleFoundation maintainersNone%&)0ADIORT!different type of tests supported pnumber of tests and failures qName of a test Followed rResult of a property run%Name of a test !"#$ s t u v w x y z { p q | } r ~ %  !"#$ s t u v w x y z { q | } r ~ %   !"#$ s t u v w x y z { p q | } r ~ % None%&)0:ADORT  r ~   - BSD-styleFoundation maintainersNone %&)0ADORT&'(  !"#$%&'(  !"#%$&'(&'(. BSD-styleFoundation maintainersNone%&)0ADIORT 9internal check monad for facilitating the tests traversal) Run tests ) *))   ) */None )0:DR/0 1234 56789/01234/02134 /0 1234 567890 BSD-style foundation experimentalportableNone)0DR 'errors related to FileName manipulation 0this means a null byte was found in the FileName 5this 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 exceptionsB,conversion of a FilePath into a list of Char"this function may throw exceptionsC/build a file path from a given list of filename7this is unsafe and is mainly needed for testing purposeD(build a file name from a given ByteArray7this is unsafe and is mainly needed for testing purpose) < = >?@ A BCDEFGHIJKLMNO <=>?@ABCDE =>?@<ABCDE  <  = >?@ A BCDEFGHIJKLMNOn BSD-style foundation experimentalportableNone)0DR<=AB=<AB BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DR gContains 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.    (c) Vincent Hanquez 2014 BSD-styleVincent Hanquez provisionalnon-portable (requires POSIX)None)0DR Memory synchronization flags perform asynchronous write. perform synchronous write. invalidate cache data. Advice to put on memory.only define the posix one.  no specific advice, the default. BExpect page references in random order. No readahead should occur. RExpect page references in sequential order. Page should be readahead aggressively. IExpect access in the near future. Probably a good idea to readahead early (Do not expect access in the near future. Memory protection  Mapping flag )memory changes are shared between process %memory changes are private to process Map pages of memory.vIf fd is present, this memory will represent the file associated. Otherwise, the memory will be an anonymous mapping.use mmap Unmap pages of memoryuse munmap 7give 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 mprotect 4memorySync synchronize memory with physical storage.FOn an anonymous mapping this function does not have any effect. call msync &Return the operating system page size.call sysconf' *The address to map to if MapFixed is used.The length of the mapping1the memory protection associated with the mapping       None)0DR  BSD-style Foundation experimentalportableNone)0DRU2list 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 fileVClose a handleW-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.W is implemented in terms of hGetBuf. hGetNonBlocking is similar to W, 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 W. Like W, 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.YY 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@ZIRead a binary file and return the whole content in one contiguous buffer.[oFold over chunks file calling the callback function for each chunks read from the file, until the end of file. UVW X YZ[Fold callback functioninitial accumulator File to read qponm=UVW XYZ[ UVW X YZ[  BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DRbcqponmUVWXYZ[bcqponmUVYWXZ[1 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 purpose_XReturns a list of the program's command line arguments (not including the program name).^_`aP  !"#$&'CF()*+,-./01DE2IJK3456789;GHQ[YXZ^a`dfjihgrstuvxw    $%&,-.}~3MNO^_`a`auN_!O  [ZYX$ #P,-.$%& 1DE2IJK'CF(4;GH,-./67895+0Q3*)}~a`3M&drts^jihg"fxwv   ^^_`a#None)0DRbOperator version of .eSend values downstream.bcdefghbcdefghebcdfghbcdefghb2       !"#"$%&'()*)+,-,./0123454647489:;<;=;>;?;@ABCDEFEGEGHIHJHKHLHMHNHOHPHQHRHSHTHUHVHWHXHYHZH[H\H]H^H_`abcdefghijklkmknkokpkqkrkstutvtwxyz{|}~4:      <<<<<<ABDDDDDDDDDEEHHHHHHIIIIJJJJKKKKKKKKKKKLLLLMMMMMMMMMMMMMMOOOOOOOPPP    Q QQQQQQQQRRRRRRRRRRR !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHISJSJSKSKTLUMUNUOUPWQWRWSWTWUWVWWWXWYYZYZY[Y[Y4Y\Y]Y^`_```a`b`cdefghijklmnooppqqrrsspptuvwxqyqz{5|}7~@2187~@218ssssttttuuuuuuuuuuuuuuuwwwwwxxxxxxxxx    yy{{{{{{      !"#$%&'()*+, -./0m12394567488:;9:;<=>?@ABCDEFGHIJ^]KLMNOP>Q?RSTUVW127<X=Y~Z[\]^_BCDE`abcdefghFGHIijklmnopqrstuvwxyz{|}~!!!!!!!!!!!!                                > T                       """~""5"""""""""""""$$$$%%%%%%%%%%%%%% % % % % &&'''(((((((((()))) !"#$%&'()**+,-./01234+5++)+*+*+++6+7+8+9+:+;+<+=+>+?+@+ABC,D,E,F,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z[\]^_`abcdefghijklmcnopq-r-s-t..u.v.w.x.y/z/z/{/|/}/~///////00o0000000000000000000000011#######222222224444444555555599999:::::::::::::::;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<     Att !"!#!$!%&'(<)*4B+B,B-B./01C2CC2C3CC4C5C6C7C8C9C:D;D<D=D>D?F@F@FAFBFCFDFEFFFGFHFIHJHKILIMINIOIPIQIRISITIUIVIWIXIYIZI[I\I]I^I_J`JaJbJcJdJeJfJgJhJiJjJkJlJmJnJoKpKqKrKsKtKuKvKwKxKyKzK{K|K}K~KKKKKKKKKKKKKKKKKLL<LLLLLLMMNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPQQQQQQQQRRR R R - S SSSSSSSSSSSSSSSSSSSS S!S"S#S$S%S&S'S(S)S*S+S,S-S.S/S0T1T2T2T3T3T4T4TLT5T6T7T8T9T:T;T<T=T>U?U@UAUBUCUDUEUFUGUHUIUJUKULUMUNUOUPUQURUSUTUUUVUWUXUYUZU[U\U]U^U_U`UaUbUcUdUeUfUgUhUiUjUkVlmnWoWpWqWrWsWtWuWvWwWxWyWzW{W|W}W~WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXY3YYYYY9YYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZ[[[[[[[[\\\\\A\\\\\]]]]]A]]]]]^^^^^^^^^^^^^^^^^^^^^_________````3````3```aa2aaaaaaaaaaaaaaaa4bb2bbbbbbbbbbbbbbbb4cccccc d dre erf f f fffffffffffffffffff f!f"f#f$f%f&f'f(f)g*g+g,g-g.h/h0h1h2h3h4h5h6h7h8h9h:h;h<h=h>h?h@hAhBhChDhEhFhGhHhIhJhKhLhMhNhOhPhQhRhShThUhVhWhXhYhZh[h\h]h^h_h`hahbhchdhehfhghhhihjhkhlhmhnhohphqhrhshthuhvhwhxhyhzh{h|h}h~hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhjjjjjjjjjjjjjjjjjjjjjjkkklllllllllllYXqyrrQrRrr1rstttuuuuuuuuuuuuuuuuuuuuv4vvw|w}www\w]w^wwwwwww9wwwwwwwwwww4wwwwwwwwww w w w ww wwww3wwwwwwwwwxyyyyyyy3yyyyzz{{{{ {5{!{"{#{>{?{{{Q{R{{{{${%{7{~{&{'{7{({){S{*{+{{{C{{8{{{@{,{2{{1{{{{{{{{{{{{{-{.{/{0{1{2{Z{[3434353536363737383839393:3:3;3;3<3<3=3=3>3>3?3?3@3@3A3A3B3B3C3C3D3D3E3E3F3F3G3G3H3H3I3J3K3L3L3M3M3N3N3O3O|m|P|Q|R||S}T}}}}U}V}W}X}}Y}Z~~~[~\~X~~~]~^_a`abccdefghimjkil$mnopqrrs7>?tQRuSU8 4~75v21Cw-.xyZ[\]^zr{|}~+/39\]^ 59./347>?+QR@7~218Z[-./48k397;:>?QR12\!!             ">"?""""""""""j"k"7""Q"R"""S"""4"""2""1""""                    '' ( ) ) ) ) ) ) ) ) !) ") #) $) %\9 & ' ( )^]437>?@21@ * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H"#$% C D I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g( h i+5+ i+ j+ k+ h+ l+ m+ n+ o+ p q r s t u v w x y z { | } } ~ ~BC q r  ,D, , , , , , , , , [              $ %            p        . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . / / i/ 0 0 0 0 0 0 0 0 0 0 00o0 !0 "0 #0 $0 %0 &0 '0 (0 ) * + , * - . / 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 Z [1 \ ](foundation-0.0.13-LaWPedULkTN458TLbKLwZD FoundationFoundation.Network.IPv4Foundation.Primitive.NatFoundation.Class.StorableFoundation.System.InfoFoundation.MonadFoundation.IO.TerminalFoundation.Class.BifunctorFoundation.Parser Foundation.IOFoundation.BitsFoundation.StrictFoundation.PrimitiveFoundation.Math.TrigonometryFoundation.Monad.ReaderFoundation.NumericalFoundation.ForeignFoundation.List.ListNFoundation.ArrayFoundation.Primitive.BlockFoundation.StringFoundation.VFS.PathFoundation.VFS.URIFoundation.ConvertibleFoundation.CollectionFoundation.Primitive.BlockNFoundation.Monad.StateFoundation.Tuple.NthFoundation.Array.InternalFoundation.String.ReadFoundation.String.BuilderFoundation.System.EntropyFoundation.List.DListFoundation.String.ASCIIFoundation.ConduitFoundation.Conduit.TextualFoundation.Time.TypesFoundation.Time.BindingsFoundation.Time.StopWatchFoundation.TimingFoundation.Timing.MainFoundation.HashingFoundation.Network.IPv6Foundation.RandomFoundation.CheckFoundation.Check.MainFoundation.UUIDFoundation.VFS.FilePathFoundation.IO.FileMap#Foundation.System.Bindings.PosixDefFoundation.String.InternalFoundation.Primitive.Base16Foundation.Numerical.PrimitivesFoundation.Monad.MonadIOFoundation.Internal.TypeableFoundation.Internal.ProxyFoundation.Internal.PrimTypesFoundation.Internal.PrimitiveFoundation.Internal.NaturalFoundation.Internal.NumLiteralFoundation.Internal.IsListFoundation.Internal.IdentityFoundation.Internal.EnvironmentFoundation.Internal.CallStackFoundation.Internal.BaseFoundation.Internal.ByteSwapFoundation.Internal.MonadTransFoundation.Monad.ExceptionFoundation.Monad.TransformerFoundation.Monad.IdentityFoundation.Monad.BaseFoundation.Numerical.FloatingFoundation.Numerical.NumberFoundation.Numerical.Additive#Foundation.Numerical.MultiplicativeFoundation.PartialFoundation.Primitive.EndiannessFoundation.Primitive.Floating!Foundation.Primitive.IntegralConv Foundation.Numerical.SubtractiveFoundation.Primitive.MonadFoundation.Primitive.FinalPtr%Foundation.Primitive.Types.OffsetSizeFoundation.Primitive.ExceptionFoundation.Primitive.NormalFormFoundation.Primitive.RuntimeFoundation.Primitive.TypesFoundation.System.Bindings.HsFoundation.Primitive.Block.Base"Foundation.Primitive.Block.MutableFoundation.Primitive.Types.Ptr Foundation.Primitive.UArray.AddrFoundation.Primitive.UArray.BA Foundation.Primitive.UTF8.HelperFoundation.Primitive.UTF8.TableFoundation.Primitive.UTF8.TypesFoundation.Primitive.UTF8.AddrFoundation.Primitive.UTF8.BAFoundation.Primitive.UtilsFoundation.String.UTF8.AddrFoundation.String.UTF8.BA Foundation.System.Bindings.Linux"Foundation.System.Bindings.Network Foundation.System.Bindings.PosixFoundation.System.BindingsFoundation.System.Bindings.Time Foundation.System.Entropy.CommonFoundation.System.Entropy.UnixElementFoundation.VFSFilePathURIFoundation.Collection.NonEmptyFoundation.Collection.ListFoundation.Collection.KeyedFoundation.Primitive.TheseFoundation.TupleFoundation.Boot.List Foundation.Primitive.UArray.BaseFoundation.Boot.Builder Foundation.Array.Unboxed.Mutable"Foundation.Array.Unboxed.ByteArrayFoundation.Array.Unboxed#Foundation.String.Encoding.Encoding!Foundation.String.Encoding.ASCII7%Foundation.String.Encoding.ISO_8859_1 Foundation.String.Encoding.UTF16 Foundation.String.Encoding.UTF32Foundation.String.ModifiedUTF8Foundation.Primitive.UTF8.BaseFoundation.Primitive.ErrorFoundation.Primitive.ShowFoundation.String.UTF8Foundation.Array.BoxedFoundation.Collection.CopyFoundation.Collection.ElementFoundation.Collection.Buildable Foundation.Collection.CollectionFoundation.Collection.FoldableFoundation.Collection.Indexed"Foundation.Collection.InnerFunctorFoundation.Collection.Mappable traverse_ sequenceA_mapM_ sequence_traverse sequenceAmapMsequenceforM_forMFoundation.Collection.Mutable Foundation.Collection.SequentialFoundation.Collection.Zippable Foundation.Array.Chunked.UnboxedFoundation.Primitive.ImportsFoundation.Conduit.InternalFoundation.Foreign.AllocFoundation.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 Applicative GHC.TypeLitsKnownNatMonoid GHC.TypesBoolCharDoubleFloatIntGHC.IntInt8Int16Int32Int64 integer-gmpGHC.Integer.TypeIntegerMaybeOrderingRationalIOWordGHC.WordWord8Word16Word32Word64GHC.PtrPtr Data.EitherEitherNat+*^<=?-CmpNatFalseNothingJustTrueLeftRightLTEQGT 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 ExceptionnatVal<= 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<>maxminstrict1strict2strict3strict4strict5strict6 HasNegationnegate Fractional fromRationalIntegral fromInteger ifThenElseByteSwap Trigonometrypisincostanasinacosatansinhcoshtanhasinhacoshatanh$fTrigonometryDouble$fTrigonometryFloat MonadBracketgeneralBracket MonadCatchcatch MonadThrowthrow MonadFailureFailuremFail MonadTransliftReaderT runReaderT MonadReader ReaderContextask$fMonadReaderReaderT$fMonadCatchReaderT$fMonadThrowReaderT$fMonadFailureReaderT$fMonadIOReaderT$fMonadTransReaderT$fMonadReaderT$fApplicativeReaderT$fFunctorReaderT FloatingPoint floatRadix floatDigits floatRange floatDecode floatEncode IsNatural toNatural IsIntegral toIntegerAdditiveazeroscale Divisible/ IDivisibledivmoddivModMultiplicative midentityrecip PartialErrorPartialpartial fromPartialBEunBELEunLE Endianness LittleEndian BigEndiantoBEfromBEtoLEfromLE endianness IntegralCast integralCastIntegralUpsizeintegralUpsizeIntegralDownsizeintegralDownsizeintegralDownsizeCheck Subtractive DifferenceIntegralRoundingroundUp roundDown roundTruncate roundNearestSignedabssignumSign SignNegativeSignZero SignPositive$fIntegralRoundingFloat$fIntegralRoundingDouble$fIntegralRoundingRatio$fSignedDouble $fSignedFloat $fSignedInt64 $fSignedInt32 $fSignedInt16 $fSignedInt8 $fSignedInt$fSignedInteger$fEqSign PrimMonad PrimStatePrimVar primitive primThrow unPrimMonad primVarNew primVarRead primVarWriteFinalPtr FinalForeignfinalPtrSameMemory toFinalPtrtoFinalPtrForeign castFinalPtrwithFinalPtrNoTouch withFinalPtr touchFinalPtrwithUnsafeFinalPtrNatWithinBound NatInBoundOfNatNumMaxBound natValInt natValInt64 natValInt32 natValInt16 natValInt8 natValWord natValWord64 natValWord32 natValWord16 natValWord8ListNunListNtoListN replicateMunconsconsemptylengthcreate createFrom singletonelemappendmaximumminimumheadtailtakedropmapfoldlzipzip3zip4zip5zipWithzipWith3zipWith4zipWith5CountOfOffset OutOfBound NormalForm toNormalFormdeepseqforcePrimTypeprimSizeInBytesprimShiftToBytes primBaUIndex primMbaURead primMbaUWrite primAddrIndex primAddrRead primAddrWrite MutableBlockBlock unsafeIndex unsafeFreeze unsafeThawValidationFailure InvalidHeaderInvalidContinuation MissingByteBuildingFailurePathPathEnt PathPrefix PathSuffix splitPath buildPathparentfilenameprefixsuffixURIPath URIFragmentURIQuery URIAuthority URISchema $fPathURI ConvertibleConvertconvert$fConvertibleaaNonEmpty getNonEmptyunsafeCopyToPtrisPinnedisMutablePinned replicatethawfreezecopyindexfoldrfoldl'foldl1'foldr1snocsubunsnocsplitAt revSplitAtbreakspanallanysplitOnfindfilterreversesortBy intersperse MutableBlockNBlockNtoBlockNtoBlock$fNormalFormBlockN $fEqBlockN $fShowBlockNKeyedCollectionKeyValuelookupStateT runStateT MonadStateState withStategetput$fMonadStateStateT$fMonadCatchStateT$fMonadThrowStateT$fMonadFailureStateT$fMonadIOStateT$fMonadTransStateT $fMonadStateT$fApplicativeStateT$fFunctorStateTTheseThisThatThdable ProductThirdthdSndable ProductSecondsndFstable ProductFirstfstTuple4Tuple3Tuple2NthableNthTynth$fNthable4Tuple4$fNthable3Tuple4$fNthable2Tuple4$fNthable1Tuple4$fNthable4(,,,)$fNthable3(,,,)$fNthable2(,,,)$fNthable1(,,,)$fNthable3Tuple3$fNthable2Tuple3$fNthable1Tuple3$fNthable3(,,)$fNthable2(,,)$fNthable1(,,)$fNthable2Tuple2$fNthable1Tuple2 $fNthable2(,) $fNthable1(,)UArrayMUArray newPinnednew BuildingState prevChunksprevChunksSizecurChunk chunkSizeBuilder runBuilder.<<..>>. alignRoundUpalignRoundDownmutableForeignMemwithMutablePtr foreignMemfromForeignPtr copyToPtrwithPtrrecast toHexadecimalStringerrorshowEncodingASCII7UTF8UTF16UTF32 ISO_8859_1 breakLineindicesreplace fromBytesfromBytesLenientfromBytesUnsafetoByteslineswords readIntegral readInteger readNatural readDouble readRationalreadFloatingExactupperlowertoBase64 toBase64URLtoBase64OpenBSDArchI386X86_64PowerPC PowerPC64SparcSparc64ARMARM64OSWindowsOSXLinuxAndroidBSDosarch compilerNamecpus$fShowOS$fEqOS$fOrdOS$fEnumOS $fBoundedOS$fDataOS $fShowArch$fEqArch $fOrdArch $fEnumArch $fBoundedArch $fDataArchemitemitChartoString$fMonoidBuilder$fIsStringBuilder getEntropyMArrayArrayCopy BuildableMutableStepbuildbuild_ CollectionnullnotElemnonEmpty nonEmpty_ nonEmptyFmapandor Fold1ableFoldablefoldr'IndexedCollection! findIndex InnerFunctorimapMappableMutableCollectionMutableFreezed MutableKey MutableValuemutNewmutUnsafeWritemutWrite mutUnsafeReadmutRead SequentialrevTakerevDrop breakElem takeWhile dropWhile intercalate partitionlastinit isPrefixOf isSuffixOf isInfixOf stripPrefix stripSuffix BoxedZippablezip6zip7unzipunzip3unzip4unzip5unzip6unzip7ZippablezipWith6zipWith7 ChunkedUArray StorableFixedsize alignmentStorablepeekpokeplusPtrpeekOffpokeOff peekArraypeekArrayEndedBy pokeArraypokeArrayEndedBy$fStorableFixedPtr$fStorableFixedLE$fStorableFixedBE$fStorableFixedWord64$fStorableFixedLE0$fStorableFixedBE0$fStorableFixedWord32$fStorableFixedLE1$fStorableFixedBE1$fStorableFixedWord16$fStorableFixedWord8$fStorableFixedInt64$fStorableFixedInt32$fStorableFixedInt16$fStorableFixedInt8$fStorableFixedFloat$fStorableFixedDouble$fStorableFixedChar$fStorableFixedCUChar$fStorableFixedCChar $fStorablePtr $fStorableLE $fStorableBE$fStorableWord64 $fStorableLE0 $fStorableBE0$fStorableWord32 $fStorableLE1 $fStorableBE1$fStorableWord16$fStorableWord8$fStorableInt64$fStorableInt32$fStorableInt16$fStorableInt8$fStorableFloat$fStorableDouble$fStorableChar$fStorableCUChar$fStorableCCharDList$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 $fEqCondition AsciiString$fZippableAsciiString$fSequentialAsciiString$fCollectionAsciiString$fInnerFunctorAsciiString$fIsListAsciiString$fIsStringAsciiString$fShowAsciiString$fMonoidAsciiString$fEqAsciiString$fOrdAsciiString ResourceTZipSink getZipSinkConduitawait awaitForeveryieldyieldOrleftover runConduitrunConduitPure runConduitResbracketConduitfuseputStrputStrLngetArgsSeconds NanoSeconds$fPrimTypeSeconds$fPrimTypeNanoSeconds$fShowNanoSeconds$fEqNanoSeconds$fOrdNanoSeconds$fAdditiveNanoSeconds$fEnumNanoSeconds$fBoundedNanoSeconds $fShowSeconds $fEqSeconds $fOrdSeconds$fAdditiveSeconds $fEnumSeconds$fBoundedSecondsmeasuringNanoSecondsgetMonotonicTimeStopWatchPrecise startPrecise stopPreciseMeasure measurementsitersTimingtimeDifftimeBytesAllocated stopWatchmeasure defaultMain$fFunctorTimingPlan$fApplicativeTimingPlan$fMonadTimingPlan MutableBitmapBitmapHasherFNV1a_64FNV1a_32FNV1_64FNV1_32HashablehashMixIPv4loopback fromTupletoTuple ipv4Parser$fStorableFixedIPv4$fStorableIPv4$fIsStringIPv4$fNormalFormIPv4 $fShowIPv4$fEqIPv4 $fOrdIPv4$fHashableIPv4IPv6 ipv6Parseripv6ParserPreferredipv6ParserIpv4Embeddedipv6ParserCompressed$fStorableFixedIPv6$fStorableIPv6$fIsStringIPv6 $fShowIPv6$fHashableIPv6$fNormalFormIPv6$fEqIPv6 $fOrdIPv6Sip1_3Sip2_4RNGv1RNGMonadRandomStaterunRandomState RandomGen randomNew randomNewFromrandomGeneraterandomGenerateWord64randomGenerateF32randomGenerateF64 MonadRandomgetRandomBytesgetRandomWord64 getRandomF32 getRandomF64withRandomGenerator$fRandomGenRNGv1$fMonadRandomMonadRandomState$fMonadMonadRandomState$fApplicativeMonadRandomState$fFunctorMonadRandomState$fMonadRandomIOGen Arbitrary arbitrary frequencyoneofbetween IsPropertypropertyPropertyPropunProp PropertyCheckforAll===propertyCompare propertyAnd propertyFailTestUnitGroup CheckPlanChecktestNamevalidatepickiterateProperty$fMonadStateCheckMain$fFunctorCheckMain$fApplicativeCheckMain$fMonadCheckMain$fMonadIOCheckMainUUIDnilnewUUID fromBinary uuidParser$fStorableFixedUUID$fStorableUUID$fHashableUUID$fNormalFormUUID $fShowUUID$fEqUUID $fOrdUUIDFileName RelativityAbsoluteRelativefilePathToStringfilePathToLStringunsafeFilePathunsafeFileName extension$fPathFilePath$fMonoidFileName$fIsStringFileName$fShowFileName$fExceptionFileName_Invalid$fIsStringFilePath$fExceptionFilePath_Invalid $fOrdFilePath $fEqFilePath$fShowFilePath$fEqRelativity$fShowRelativity$fShowFilePath_Invalid $fEqFileName$fShowFileName_InvalidopenFile closeFilehGethPutwithFilereadFile foldTextFile fileMapReadfileMapReadWithLString fromCounttoCount.| sourceFile sourceHandleyieldssinkFile sinkHandlesinkList COpenFlags CSysconfName CMemSyncFlags CMemAdviceCMemMappingFlags CMemProtFlagsCFdCErrnoSystem.Posix.TypesCModeCOffunsafeConvertByte hexWord16 hexWord32TabletableLotableHiIntegralConvertintegralConvert intToWord$fIntegralConvertInt64Word64$fIntegralConvertInt32Word32$fIntegralConvertInt16Word16$fIntegralConvertInt8Word8Pinned#Bool#CountOf#Offset# FileSize# PinnedStatusbool# compatAndI#compatQuotRemInt#compatCopyAddrToByteArray#compatCopyByteArrayToAddr# compatMkWeak#PinnedUnpinnedcompatIsMutableByteArrayPinned#compatIsByteArrayPinned#toPinnedStatus# compatGetSizeofMutableByteArray#compatShrinkMutableByteArray#compatResizeMutableByteArray#W#integerToNatural$fFractionalCDouble$fFractionalCFloat$fFractionalDouble$fFractionalFloat$fFractionalRatio$fHasNegationCDouble$fHasNegationCFloat$fHasNegationDouble$fHasNegationFloat$fHasNegationCInt$fHasNegationWord64$fHasNegationWord32$fHasNegationWord16$fHasNegationWord8$fHasNegationWord$fHasNegationInt64$fHasNegationInt32$fHasNegationInt16$fHasNegationInt8$fHasNegationInt$fHasNegationInteger$fIntegralCDouble$fIntegralCFloat$fIntegralDouble$fIntegralFloat$fIntegralCUIntPtr$fIntegralCOff$fIntegralCInt$fIntegralCSize$fIntegralInt64$fIntegralInt32$fIntegralInt16$fIntegralInt8$fIntegralWord64$fIntegralWord32$fIntegralWord16$fIntegralWord8$fIntegralWord $fIntegralInt$fIntegralNatural$fIntegralIntegerSystem.Environment lookupEnv Text.Read readMaybeGHC.Stack.Types HasCallStack internalError Data.DataDatagfoldlgunfoldtoConstr dataTypeOf dataCast1 dataCast2gmapTgmapQlgmapQrgmapQgmapQigmapMgmapMpgmapMo showsPrecshowList GHC.GenericsGenericRepfromto mkNoRepTypeDataType Data.FoldableGHC.IOthrowIObyteSwap$fByteSwapWord64$fByteSwapWord32$fByteSwapWord16 byteSwap64 byteSwap32 byteSwap16Reader runReaderrunState $fMonadReader$fApplicativeReader$fFunctorReader $fMonadState$fApplicativeState$fFunctorState$fMonadBracketIO$fMonadCatchIO$fMonadThrowIO$fMonadFailureEither$fMonadFailureMaybe IdentityT runIdentityT$fMonadCatchIdentityT$fMonadThrowIdentityT$fMonadFailureIdentityT$fMonadIOIdentityT$fMonadTransIdentityT$fMonadIdentityT$fApplicativeIdentityT$fFunctorIdentityT$fFloatingPointDouble$fFloatingPointFloat$fIsNaturalCSize$fIsNaturalWord64$fIsNaturalWord32$fIsNaturalWord16$fIsNaturalWord8$fIsNaturalWord$fIsNaturalNatural$fIsIntegralCSize$fIsIntegralWord64$fIsIntegralWord32$fIsIntegralWord16$fIsIntegralWord8$fIsIntegralWord$fIsIntegralNatural$fIsIntegralInt64$fIsIntegralInt32$fIsIntegralInt16$fIsIntegralInt8$fIsIntegralInt$fIsIntegralIntegerscaleNum$fAdditiveCSize$fAdditiveDouble$fAdditiveFloat$fAdditiveWord64$fAdditiveWord32$fAdditiveWord16$fAdditiveWord8$fAdditiveNatural$fAdditiveWord$fAdditiveInt64$fAdditiveInt32$fAdditiveInt16$fAdditiveInt8 $fAdditiveInt$fAdditiveIntegerpowereven$fDivisibleDouble$fDivisibleFloat$fDivisibleRatio$fIDivisibleWord64$fIDivisibleWord32$fIDivisibleWord16$fIDivisibleWord8$fIDivisibleWord$fIDivisibleNatural$fIDivisibleInt64$fIDivisibleInt32$fIDivisibleInt16$fIDivisibleInt8$fIDivisibleInt$fIDivisibleInteger$fMultiplicativeRatio$fMultiplicativeDouble$fMultiplicativeFloat$fMultiplicativeWord64$fMultiplicativeWord32$fMultiplicativeWord16$fMultiplicativeWord8$fMultiplicativeWord$fMultiplicativeNatural$fMultiplicativeInt64$fMultiplicativeInt32$fMultiplicativeInt16$fMultiplicativeInt8$fMultiplicativeInt$fMultiplicativeInteger partialErrorfromJust fromRightfromLeft$fExceptionPartialError$fOrdBE$fOrdLEintegerToDoublenaturalToDoubledoubleExponantintegerToFloatnaturalToFloatintegralDownsizeBounded intToInt64 int64ToInt wordToWord64 word64ToWord word64ToWord#word64ToWord32s wordToChar wordToInt charToInt$fIntegralCastInt64Word64$fIntegralCastWord64Int64$fIntegralCastIntWord$fIntegralCastWordInt$fIntegralDownsizeNaturalWord64$fIntegralDownsizeNaturalWord32$fIntegralDownsizeNaturalWord16$fIntegralDownsizeNaturalWord8 $fIntegralDownsizeIntegerNatural$fIntegralDownsizeIntegerWord64$fIntegralDownsizeIntegerWord32$fIntegralDownsizeIntegerWord16$fIntegralDownsizeIntegerWord8$fIntegralDownsizeIntegerInt64$fIntegralDownsizeIntegerInt32$fIntegralDownsizeIntegerInt16$fIntegralDownsizeIntegerInt8$fIntegralDownsizeWord16Word8$fIntegralDownsizeWord32Word16$fIntegralDownsizeWord32Word8$fIntegralDownsizeWordWord32$fIntegralDownsizeWordWord16$fIntegralDownsizeWordWord8$fIntegralDownsizeWord64Word32$fIntegralDownsizeWord64Word16$fIntegralDownsizeWord64Word8$fIntegralDownsizeInt64Int$fIntegralDownsizeInt64Int32$fIntegralDownsizeInt64Int16$fIntegralDownsizeInt64Int8$fIntegralDownsizeIntInt32$fIntegralDownsizeIntInt16$fIntegralDownsizeIntInt8$fIntegralUpsizeNaturalInteger$fIntegralUpsizeWord64Natural$fIntegralUpsizeWord64Integer$fIntegralUpsizeWordWord64$fIntegralUpsizeWordNatural$fIntegralUpsizeWordInteger$fIntegralUpsizeWord32Natural$fIntegralUpsizeWord32Integer$fIntegralUpsizeWord32Word$fIntegralUpsizeWord32Word64$fIntegralUpsizeWord16Natural$fIntegralUpsizeWord16Integer$fIntegralUpsizeWord16Word$fIntegralUpsizeWord16Word64$fIntegralUpsizeWord16Word32$fIntegralUpsizeWord8Natural$fIntegralUpsizeWord8Integer$fIntegralUpsizeWord8Int$fIntegralUpsizeWord8Int64$fIntegralUpsizeWord8Int32$fIntegralUpsizeWord8Int16$fIntegralUpsizeWord8Word$fIntegralUpsizeWord8Word64$fIntegralUpsizeWord8Word32$fIntegralUpsizeWord8Word16$fIntegralUpsizeInt64Integer$fIntegralUpsizeIntInt64$fIntegralUpsizeIntInteger$fIntegralUpsizeInt32Integer$fIntegralUpsizeInt32Int$fIntegralUpsizeInt32Int64$fIntegralUpsizeInt16Integer$fIntegralUpsizeInt16Int$fIntegralUpsizeInt16Int64$fIntegralUpsizeInt16Int32$fIntegralUpsizeInt8Integer$fIntegralUpsizeInt8Int$fIntegralUpsizeInt8Int64$fIntegralUpsizeInt8Int32$fIntegralUpsizeInt8Int16$fSubtractiveChar$fSubtractiveDouble$fSubtractiveFloat$fSubtractiveWord64$fSubtractiveWord32$fSubtractiveWord16$fSubtractiveWord8$fSubtractiveWord$fSubtractiveNatural$fSubtractiveInt64$fSubtractiveInt32$fSubtractiveInt16$fSubtractiveInt8$fSubtractiveInt$fSubtractiveIntegerorderingToSign unPrimMonad_unsafePrimCastunsafePrimToSTunsafePrimToIOunsafePrimFromIO primTouch $fPrimMonadST $fPrimMonadIOequalcompare_ $fOrdFinalPtr $fEqFinalPtr$fShowFinalPtr impossibleSize8Offset8FileSize offsetSubsizeSub+..==# offsetOfE offsetPlusE offsetMinusE offsetRecast offsetShiftR offsetShiftL offsetCastsizeCastsizeLastOffset sizeAsOffset offsetAsSizesizeOfE csizeOfSize csizeOfOffset sizeOfCSSize sizeOfCSize$fIntegralCastWordCountOf$fIntegralCastIntCountOf$fMonoidCountOf$fSubtractiveCountOf$fAdditiveCountOf$fIsNaturalCountOf$fIsIntegralCountOf $fNumCountOf$fIntegralCastWordOffset$fIntegralCastIntOffset$fSubtractiveOffset$fIsNaturalOffset$fIsIntegralOffsetOutOfBoundOperation InvalidRecastRecastDestinationSizeRecastSourceSizeOOB_Read OOB_Write OOB_MemSet OOB_MemCopy OOB_Index outOfBoundprimOutOfBound isOutOfBound$fExceptionInvalidRecast$fExceptionOutOfBound$fNormalForm(,,,,,,,)$fNormalForm(,,,,,,)$fNormalForm(,,,,,)$fNormalForm(,,,,)$fNormalForm(,,,)$fNormalForm(,,)$fNormalForm(,)$fNormalForm[]$fNormalFormBE$fNormalFormLE$fNormalFormEither$fNormalFormMaybe$fNormalFormCountOf$fNormalFormOffset$fNormalFormPtr$fNormalFormCDouble$fNormalFormCFloat$fNormalFormCULLong$fNormalFormCLLong$fNormalFormCULong$fNormalFormCLong$fNormalFormCUInt$fNormalFormCInt$fNormalFormCUShort$fNormalFormCShort$fNormalFormCSChar$fNormalFormCUChar$fNormalFormCChar$fNormalForm()$fNormalFormBool$fNormalFormChar$fNormalFormDouble$fNormalFormFloat$fNormalFormNatural$fNormalFormWord$fNormalFormWord64$fNormalFormWord32$fNormalFormWord16$fNormalFormWord8$fNormalFormInteger$fNormalFormInt$fNormalFormInt64$fNormalFormInt32$fNormalFormInt16$fNormalFormInt8unsafeUArrayUnpinnedMaxSize GHC.IO.UnsafeunsafePerformIOPrimMemoryComparable sizeRecast primBaIndex primMbaRead primMbaWriteprimArrayIndexprimMutableArrayReadprimMutableArrayWritesizeIntsizeWordshiftInt shiftWordsizeRecastBytes sizeInBytes offsetInBytesoffsetInElementsprimOffsetRecastoffsetIsAlignedprimOffsetRecastBytes primOffsetOfEprimWordGetByteAndShiftprimWord64GetByteAndShiftprimWord64GetHiLo$fPrimMemoryComparableBE$fPrimMemoryComparableLE$fPrimMemoryComparableCUChar$fPrimMemoryComparableCChar$fPrimMemoryComparableChar$fPrimMemoryComparableInt64$fPrimMemoryComparableInt32$fPrimMemoryComparableInt16$fPrimMemoryComparableInt8$fPrimMemoryComparableWord64$fPrimMemoryComparableWord32$fPrimMemoryComparableWord16$fPrimMemoryComparableWord8$fPrimMemoryComparableWord$fPrimMemoryComparableInt $fPrimTypeBE $fPrimTypeLE$fPrimTypeCUChar$fPrimTypeCChar$fPrimTypeChar$fPrimTypeDouble$fPrimTypeFloat$fPrimTypeInt64$fPrimTypeInt32$fPrimTypeInt16$fPrimTypeInt8$fPrimTypeWord64$fPrimTypeWord32$fPrimTypeWord16$fPrimTypeWord8$fPrimTypeWord $fPrimTypeIntsysHsMemFindByteAddrsysHsMemFindByteBasysHsMemcmpPtrPtrsysHsMemcmpPtrBasysHsMemcmpBaPtrsysHsMemcmpBaBasysHsCoreGetErrnointernalFromListinternalToListinternalCompare unsafeNewunsafeCopyElementsunsafeCopyBytesunsafeCopyBytesRO unsafeRead unsafeWrite blockType lengthBytesempty_ mutableEmpty equalMemcmp compareMemcmpconcatunsafeCopyElementsROtouch mutableTouch $fIsListBlock $fMonoidBlock $fOrdBlock $fEqBlock $fShowBlock$fNormalFormBlock $fDataBlockmutableLengthSizemutableGetAddriterSetreadwritemutableLengthBytesAddraddrPlus addrPlusSz addrPlusCSzptrPlus ptrPlusSz ptrPlusCSz Immutable primIndex findIndexElemfindIndexPredicatefoldl1UTF8Char asUTF8CharUTF8_1UTF8_2UTF8_3UTF8_4maskContinuation# maskHeader2# maskHeader3# maskHeader4#or3#or4#toChar#toChar1toChar2toChar3toChar4numBytesskipNextHeaderValue headerIsAscii charToBytesisContinuation getNbBytesisContinuation# getNbBytes#unTable contTable headTable StepASCII StepDigitStepBackisValidStepASCIIisValidStepDigit$fExceptionValidationFailurenextAsciiDigit primWriteprimRead primIndex64 nextAscii expectAsciinextprevprevSkipprimCopyFreezedBytesprimCopyFreezedBytesOffsetprimCopyFreezedW32primCopyFreezedW64 primMutableByteArraySlideToStartprimMutableAddrSlideToStart copyFilterCWatchDescriptor 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 getHErrnoherr_HostNotFound herr_NoDataherr_NoRecovery herr_TryAgainCDirentCDir 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 CTimeZoneCTimeVal CTimeSpecCClockIdsysTimeGetTimeOfDaysysTimeClockGetTimesysTimeClockGetRessize_CTimeSpecofs_CTimeSpec_Secondsofs_CTimeSpec_NanoSeconds size_CTimeValsize_CTimeZone size_CTimeTsysTime_CLOCK_REALTIMEsysTime_CLOCK_MONOTONIC sysTime_CLOCK_PROCESS_CPUTIME_IDsysTime_CLOCK_THREAD_CPUTIME_IDsysTime_CLOCK_MONOTONIC_RAWsysTime_CLOCK_REALTIME_COARSEsysTime_CLOCK_BOOTTIMEsysTime_CLOCK_REALTIME_ALARMsysTime_CLOCK_BOOTTIME_ALARMEntropySystemMissing$fExceptionEntropySystemMissing entropyGather EntropyCtxEntropySyscallc_sysrandom_linux entropyOpen entropyCloseentropyMaximumSizeopenDevgatherDevEntropysupportSyscallunMBlockunBlocktoOffset wordsWhen$fKeyedCollection[]$fFunctorThese$fBifunctorThese$fNormalFormThese$fThdableTuple4$fThdableTuple3$fThdable(,,,) $fThdable(,,)$fSndableTuple4$fSndableTuple3$fSndableTuple2$fSndable(,,,) $fSndable(,,) $fSndable(,)$fFstableTuple4$fFstableTuple3$fFstableTuple2$fFstable(,,,) $fFstable(,,) $fFstable(,)$fNormalFormTuple4$fNormalFormTuple3$fBifunctorTuple2$fNormalFormTuple2sum vFromListvToListvComparecopyAtunsafeCopyAtRO ValidRange UArrayBackendUArrayBA UArrayAddrMUArrayBackend MUArrayMBA MUArrayAddr arrayTypeoffsetoffsetsValidRange newUnpinned newNative unsafeIndexerunsafeFreezeShrink onBackend onBackendPrimonMutableBackend unsafeDewrap unsafeDewrap2pureST equalBytes vCompareBytesvCompareMemcmpmemcmp$fIsListUArray$fMonoidUArray $fOrdUArray $fEqUArray $fShowUArray$fNormalFormUArray $fDataUArray$fMonadFailureBuilder mutableLength copyFromPtrsizeInMutableBytesOfContent mutableSamewithMutablePtrHint mutableOffsetMutableByteArraymutableByteArraySetunsafeCopyFrom createFromIO createFromPtrupdate freezeShrink unsafeSlide unsafeUpdate unsafeRecast unsafeTake unsafeDrop breakElemBytecountFromStartmapIndex builderAppend builderBuild builderBuild_toBase64InternaloutputLengthBase64convert3Foreign.C.TypesCCharCSCharCUCharCShortCUShortCIntCUIntCLongCULongCLLongCULLongCFloatCDoubleCPtrdiffCSizeCWchar CSigAtomicCClockCTime CUSeconds CSUSecondsCFileCFposCJmpBufCIntPtrCUIntPtrCIntMaxCUIntMaxError encodingNext convertFromTo encodingWriteisAsciiASCII7_InvalidByteOutOfBound CharNotAsciiaone$fEncodingASCII7$fExceptionASCII7_InvalidISO_8859_1_Invalid NotISO_8859_1$fEncodingISO_8859_1$fExceptionISO_8859_1_Invalid UTF16_InvalidInvalidUnicode$fEncodingUTF16$fExceptionUTF16_Invalid UTF32_Invalid$fEncodingUTF32$fExceptionUTF32_Invalid fromModified accessBytesbuildByteArray MutableStringsToList sFromList stringType$fNormalFormString $fDataString$fIsListString$fIsStringString $fShowString EncoderUTF8mutableValidateindexN splitIndexcharMapfromChunkBytesdecimalDigitsBAdecimalDigitsPtrReadFloatingCallbacknextWithIndexerwriteWithBuilder writeUTF8CharcountCharMoreThanBytesfromEncoderBytestoEncoderBytes stringDewrap$fEncodingEncoderUTF8ET onNewArrayfreezeUntilIndex $fIsListArray $fOrdArray $fEqArray $fShowArray $fMonoidArray$fFunctorArray$fNormalFormArray $fDataArray $fCopyString $fCopyArray $fCopyUArray $fCopyBlock$fCopy[] builderLift$fBuildableString$fBuildableArray$fBuildableUArray$fCollectionNonEmpty$fCollectionString$fCollectionArray$fCollectionUArray$fCollectionBlock$fCollection[]$fIsListNonEmpty$fFold1ableBlock$fFold1ableArray$fFold1ableUArray $fFold1able[]$fFoldableBlock$fFoldableArray$fFoldableUArray $fFoldable[]$fIndexedCollectionString$fIndexedCollectionArray$fIndexedCollectionUArray$fIndexedCollectionBlock$fIndexedCollection[]$fInnerFunctorString$fInnerFunctorArray$fInnerFunctorUArray$fInnerFunctor[]$fMappableArray $fMappable[]$fMutableCollectionMArray$fMutableCollectionMutableBlock$fMutableCollectionMUArraymconcatCollection$fSequentialString$fSequentialArray$fSequentialUArray$fSequentialBlock$fSequential[]uncons2uncons3uncons4uncons5uncons6uncons7uncurry2uncurry3uncurry4uncurry5uncurry6uncurry7$fBoxedZippableArray$fBoxedZippable[]$fZippableString$fZippableArray$fZippableUArray $fZippable[]findPos splitChunkremoveArraySize $fIndexedCollectionChunkedUArray$fSequentialChunkedUArray$fCollectionChunkedUArray$fFoldableChunkedUArray$fIsListChunkedUArray$fMonoidChunkedUArray$fNormalFormChunkedUArray$fEqChunkedUArrayunDList runParserSuccessNoMoreMoreendOfParserSource runParser_failuresuccessrepeatErepeatAMutableAsciiString cucharToChar charToCUChar cucharMapFP64FP32PipeYieldAwaitDonePipeMLeftoverrunPipe 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 allocaBytes secondInNano getGCStats TimingPlan runTimingPlan MainConfigmainHelpmainListBenchs mainVerbose mainOtherdefaultMainConfig parseArgs configHelp bitsPerTy shiftPerTy maskPerTy bitmapIndex 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 takeAWord16SipHashSipKeymixBaSipIncrementalSipIncremental0SipIncremental1SipIncremental2SipIncremental3SipIncremental4SipIncremental5SipIncremental6SipIncremental7 InternalStateSip newSipStatemix8Primmix8mix32mix64finishdoRoundprocessfinalize loopRounds andMask64$fHasherSip1_3$fHasherSip2_4c_rngv1_generate_f64c_rngv1_generate_f32c_rngv1_generate_word64c_rngv1_generate rngv1KeySize rngv1Generaterngv1GenerateWord64rngv1GenerateF32rngv1GenerateF64runGenGenSeedGenRng GenParamsgenMaxSizeIntegralgenMaxSizeArraygenMaxSizeStringgenRnggenRngNewNoFail genGenerator genWithRng genWithParams $fMonadGen$fApplicativeGen $fFunctorGenarbitraryIntegerarbitraryNatural arbitraryChararbitraryWord64arbitraryInt64 arbitraryF64 arbitraryF32arbitraryUArrayOfgenMax$fArbitrary(,,,,,)$fArbitrary(,,,,)$fArbitrary(,,,)$fArbitrary(,,)$fArbitrary(,)$fArbitraryEither$fArbitraryMaybe$fArbitraryDouble$fArbitraryFloat$fArbitraryString$fArbitraryBool$fArbitraryCountOf$fArbitraryChar$fArbitraryInt8$fArbitraryInt16$fArbitraryInt32$fArbitraryInt64$fArbitraryWord8$fArbitraryWord16$fArbitraryWord32$fArbitraryWord64$fArbitraryWord$fArbitraryInt$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 testProperty withComponentparseHexFileName_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