8      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                     !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~a BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableSafe)0DR BSD-style FoundationstableportableSafe)0DRNone )0<=BDR Safe)0DRPO! BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableSafe)0DRegf" 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 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) 4 # BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0BDRSize 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$None )0DIRF% 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)0DRE' BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableSafe)0DR(Safe )*0DR) BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DR/Only to use internally for internal error cases!for support of if .. then .. elseElkmnpo  !"#$%&;>'()*+,-./0<=1ABC3456789:?@TSU[dix~* BSD-stylePsychohistorians experimentalportableNone)0DRSimple Reader monadSimple State monad              +None)0DRMonad 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. ,None)0DRBasic Transformer classGLift a computation from an inner monad to the current transformer monadNone)0DR PO PO-None)0DR    .None)0DR  $PO None)0DRReader Transformer !" !" None)0DLRState Transformer #$ #$/None)09DRIEEE754 Floating Point%&%&0None)0DR>Number literals, convertible through the generic Integer type.Fall number are Enum'erable, meaning that you can move to next element'()*+,-./012345678'()*+,-./0123456781None)06DReRepresent class of things that can be added together, contains a neutral element and is commutative. )x + azero = x azero + x = x x + y = y + x9:;<=>?@ABCDEFG9:;<=>?@ABCDEFG62None )069;DR3Represent 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 elementRaise to power, repeated multiplication e.g. > a ^ 2 = a * a > a ^ 10 = (a ^ 5) * (a ^ 5) .. (^) :: (IsNatural n) => a -> n -> a+HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefg $HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefg7783None)0DR1Represent 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 Naturalhijklmnopqrstuhijklmnopqrstu64 BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DIRSize of a data structure.@More specifically, it represents the number of elements of type ty# that fit into the data structure.7lengthSize (fromList ['a', 'b', 'c', '']) :: Size CharSize 4Same caveats as  apply here.v"Size 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.wIOffset in bytes used for memory addressing (e.g. in a vector, string, ..)xFile size in bytesvwxyz{|}~vwxyz{|}~vwxyz{|}~5 BSD-style foundation experimentalportableNone)0DR5Defines 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  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.  BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )069;DRRound up, to the next integral.Also known as ceiling$Round down, to the previous integralAlso known as floorGTruncate to the closest integral to the fractional number closer to 0.TThis is equivalent to roundUp for negative Number and roundDown for positive NumberRound to the nearest integral roundNearest 3.64 > roundNearest 3.4 3-types that have sign and can be made absoluteSign of a signed number((  None)09DR 6 BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DIRBAn error related to the evaluation of a Partial value that failed.?it contains the name of the function and the reason for failurePartialiality wrapper."Throw an asynchronous PartialErrorCCreate a value that is partial. this can only be unwrap using the  functionDewrap a possible partial value*Partial function to get the head of a list1Partial function to grab the value inside a Maybe   7 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 m0type of variable associated with the PrimMonad mmUnwrap the State# token to pass to a function a primitive function that returns an unboxed state and a value. &Throw Exception in the primitive monad (Run a Prim monad from a dedicated state# &Build a new variable in the Prim Monad #Read the variable in the Prim Monad $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                8 BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )0BDR-Create a pointer with an associated finalizer3Check 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 ptr$create a new FinalPtr from a Pointer'Create a new FinalPtr from a ForeignPtr.Cast a finalized pointer from type a to type b}Looks at the raw pointer inside a FinalPtr, making sure the data pointed by the pointer is not finalized during the call to fUnsafe version of   9 BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )0BDR NRepresent 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 element-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 monadICast a Size linked to type A (Size A) to a Size linked to type B (Size B)   BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )069;DR          : 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 word; 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. < BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DR= 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 > type family"#the associated prefix of the given pathin the case of a ?@-, it is a void (i.e. `()`) in the case of a ?A!, it is the schema, host, port...#'the associated suffix of the given pathin the case of the ?@/, it is a void (i.e. `()`) in the case of the ?A!, 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.hs)get 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)0DR5 TODO this is not implemented yet +,-./01234567 +,-./0123456 563412/0-.+,+,-./01234567 BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )09;<=DR81Class of things that can be converted from a to b89:;89:89:89:;B BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DR?Simple helper to split a list repeatly when the predicate matchC BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )069;DR<1Collection of things that can be looked up by Key<=>?<=>?<=>? BSD-styleHaskell Foundation experimentalportableNone)0DR@UExtending the Storable type class to the types that can be sequenced in a structure.C&Storable type of self determined size.Glike D but at a given offset.Hlike E but at a given offset. @ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^ 9V@BACDEFGH CDE@AB9FVGH@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^ BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableSafe)0DRNLKMNMLKD BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)05DR_0Class of product types that have a third elementb1Class of product types that have a second elemente0Class of product types that have a first elementhStrict tuple (a,b,c,d)jStrict tuple (a,b,c)lStrict tuple (a,b) _`abcdefghijklm_`abcdefghijklm_`abcdefghijklm BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone ),09;<=DRnRA generalized version of indexed accessor allowing access to tuples n'th element.Indexing starts at 1, as g is used to get first element.nopqrstuvwxyz{|}~nopnopnopqrstuvwxyz{|}~None)0DRUnsafe Shift Left OperatorUnsafe Shift Right Operator&Round up (if needed) to a multiple of  alignment closst to m alignment needs to be a power of two.alignRoundUp 16 8 = 16 alignRoundUp 15 8 = 16(Round down (if needed) to a multiple of  alignment closest to m alignment needs to be a power of two /alignRoundDown 15 8 = 8 alignRoundDown 8 8 = 8Number to AlignAlignment (power of 2)Number to AlignAlignment (power of 2)E 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 F BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )0BDR 7A Mutable array of types built on top of GHC primitive./Element in this array can be modified in place.read a cell in a mutable array.2If the index is out of bounds, an error is raised.<read from a cell in a mutable array without bounds checking.NReading from invalid memory can return unpredictable and invalid values. use  if unsure.#Write to 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 without bounds checking.^Writing with invalid bounds will corrupt memory and your program will become unreliable. use  if unsure.-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 addresses&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.ECopy a number of elements from an array to another array with offsets1return the numbers of elements in a mutable array "the start pointer with a finalizer/the number of elements (in elements, not bytes)destination arrayoffset at destination source arrayoffset at sourcenumber of elements to copy  G BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone $)0BDR/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 interface 4Copy every cells of an existing array to a new array !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. 5Return the element at a specific index from an array.5If the index @n is out of bounds, an error is raised. MReturn the element at a specific index from an array without bounds checking.NReading from invalid memory can return unpredictable and invalid values. use   if unsure.+return the number of elements of the array.Copy 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.aAllocate a new array with a fill function that has access to the elements of the source array.%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.Create a new array of size /n by settings each cells through the function f.*Create a pinned array that is filled by a filler- function (typically an IO call like hGetBuf)&make an array from a list of elements.transform an array to a list."Check if two vectors are identicalCompare 2 vectors7Append 2 arrays together by creating a new bigger array9update an array by creating a new array with the updates.Jthe operation copy the previous array, modify it in place, then freeze it.J    "the start pointer with a finalizer/the number of elements (in elements, not bytes)destination arrayoffset at destination source arrayoffset at sourcenumber of elements to copy Source arrayLength of the destination array4Function called for each element in the source arrayReturns the filled new array !"#the size of the array,the function that set the value at the indexthe array createdthe size of the arrayfilling function that$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLME     !"#$'()*+,-./0123456789:;<=>?@ABCDEFGH     !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLM BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DRH BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DRElement type of a collectionI 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 collection$NonEmpty property for any Collection#This can only be made, through the  smart contructor1Smart 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.NOPQR NOPQRJ BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DR/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.hAlso note that if you want an efficient left-fold, you probably want to use foldl' instead of foldl. The reason for this is that latter does not force the "inner" results (e.g. z f x1 in the above example) before applying them to the operator (e.g. to (f x2)). This results in a thunk chain O(n) elements long, which then must be evaluated from the outside-in.QLeft-associative fold of a structure but 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.STSTK BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )069;DR.Collection of elements that can indexed by intUVUVLNone)06DRKA monomorphic functor that maps the inner values to values of the same typeWXWXM 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 trueThe 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.ZTakes 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. YZ[YZ[N BSD-style foundation experimentalportableNone)0DIR.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.-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 '.\\O 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.#]^_`abcdefghijk ]^_`abcdefghijkP BSD-style foundation experimentalportableNone )0:BDRlHassuming 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.mnllmnlQ BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DRjCollection of things that can be made mutable, modified and then freezed into an MutableFreezed collectiono  o BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )069;DRf<=>?j<=>?RNone)0DRpMutable Byte Array aliaspqrspqrspqrsS BSD-style Foundation experimentalportableNone)0:DRtZthe unit element use for the encoding. i.e. Word8 for ASCII7 or UTF8, Word16 for UTF16...uIdefine the type of error handling you want to use for the next function. %type Error UTF8 = Either UTF8_Invalidvnconsume an `Unit encoding` and return the Unicode point and the position of the next possible `Unit encoding`wYhelper 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 ```xtuvywInput's encoding typeOutput's encoding typethe input raw arrayxtuvywxtuvywT BSD-style Foundation experimentalportableNone)0BDRz>validate a given byte is within ASCII characters encoring size+This function check the 8th bit is set to 0{fconsume an Ascii7 char and return the Unicode point and the position of the next possible Ascii7 char |}~z{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|}~|}~z{U BSD-style Foundation experimentalportableNone)0BDR V BSD-style Foundation experimentalportableNone)0BDR W BSD-style Foundation experimentalportableNone)0BDR BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DRA  BSD-styleHaskell Foundation experimentalportableNone )0:BDIR7Opaque packed array of characters in the ASCII encodingGCreate a string composed of a number @n of Chars (Unicode code points).<if the input @s contains less characters than required, thenSCreate 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"] size in bytesCopy 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  fromBytes0$in number of bytes, not of elements. -X BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )0:BDIRADifferent way to encode a Character in UTF8 represented as an ADT6Opaque packed array of characters in the UTF8 encoding"Validate a bytearray for UTF8'nessUOn success Nothing is returned On Failure the position along with the failure reasonGCreate a string composed of a number @n of Chars (Unicode code points).<if the input @s contains less characters than required, thenSCreate a string with the remaining Chars after dropping @n Chars from the beginningCReturn the offset (in bytes) of the N'th sequence in an UTF8 String: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"]Split at a given index.Allocate a new StringI with a fill function that has access to the characters of the source String. size in bytesCopy the String5Allocate a MutableString of a specific size in bytes.=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 chunk*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.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 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.Z            Source string)Length of the destination string in bytes7Function called for each character in the source StringReturns the filled new string!"#$$in number of bytes, not of elements.%&'()*+,-./0123456789:;<=      $%1K           !"#$%&'()*+,-./0123456789:;<= BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DR          Y BSD-style Foundation experimentalportableNone)0DR!Print a string to standard output0Print a string with a newline to standard output BSD-styleHaskell Foundation experimentalportableNone )0:DORTSimple parser structure>?The continuation of the next buffer value, and the parsed value?<The continuation of the current buffer, and the error string3Simple parsing result, that represent respectively:failure: with the error message+continuation: that need for more input data9success: the remaining unparsed data and the parser value &not enough data to complete the parser!,only use in the event of Monad.fail function"the expected input#but received this data$"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 ',Get the next `Element input` from the parser(4Parse a specific `Element input` at current position]if the `Element input` is different than the expected one, this parser will raise a failure.)2Parse a sequence of elements from current position;if the following `Element input` don't match the expected input, completely, the parser will raise a failure+8Take @n elements from the current position in the stream,PTake elements while the @predicate hold from the current position in the stream-CTake the remaining elements from the current position in the stream.8Skip @n elements from the current position in the stream/WSkip `Element input` while the @predicate hold from the current position in the stream0OSkip all the remaining `Element input` from the current position in the stream&>? !"#$%@AB&'()*+,-./01234567R! "#$%&'()*+,-./0 !"#%$&(')*+,-./0R>? !"#$%@AB&'()*+,-./01234567 BSD-style foundation experimentalportableNone)0DR>4Enumeration of the known GHC supported architecture.M9get the operating system on which the program is running.Either return the known G or a strict  of the OS name.This function uses the base's C function.N<get the machine architecture on which the program is running1Either return the known architecture or a Strict  of the architecture name.This function uses the base's D function.Oget the compiler nameKget the compilerName from base package but convert it into a strict StringP*returns the number of CPUs the machine hasQ&endianness of the current architecture;<=>?@ABCDEFGHIJKLMNOPQDJIHG;<=>?@ABCDEFGHIJKLMNOPQGHIJKLM>?@ABCDEFNP;<=QODJIHG;<=>?@ABCDEFGHIJKLMNOPQ BSD-style FoundationstablegoodNone)0DR`Get some of the system entropy````Z BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )0BDRaMutable Array of ab Array of aE1return the numbers of elements in a mutable arrayF5Return the element at a specific index from an array.5If the index @n is out of bounds, an error is raised.GMReturn the element at a specific index from an array without bounds checking.NReading from invalid memory can return unpredictable and invalid values. use F if unsure.Hread a cell in a mutable array.2If the index is out of bounds, an error is raised.I<read from a cell in a mutable array without bounds checking.NReading from invalid memory can return unpredictable and invalid values. use H if unsure.J#Write to a cell in a mutable array.2If the index is out of bounds, an error is raised.K;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 J if unsure.L%Freeze a mutable array into an array..the MArray must not be changed after freezing.MThaw an immutable array.)The Array must not be used after thawing.N!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.O'Copy the element to a new element arrayPECopy a number of elements from an array to another array with offsetsQCopy 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.RaAllocate a new array with a fill function that has access to the elements of the source array.S&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.TCreate a new array of size /n by settings each cells through the function f.U7Append 2 arrays together by creating a new bigger arrayJaVbWXEFGHIJKLMNYOPdestination arrayoffset at destination source arrayoffset at sourcenumber of elements to copyQdestination arrayoffset at destination source arrayoffset at sourcenumber of elements to copyR Source arrayLength of the destination array4Function called for each element in the source arrayReturns the filled new arraySTthe size of the array,the function that set the value at the indexthe array createdZ[\]^_`Uabcdefghijklmnopqrstuvwxyz{|}~ abGKLMNYOPQS\HaVbWXEFGHIJKLMNYOPQRSTZ[\]^_`Uabcdefghijklmnopqrstuvwxyz{|}~[ BSD-style.Alfredo Di Napoli <alfredo.dinapoli@gmail.com> experimentalportableNone )0ABDORTReturns the length of this c8, by summing each inner length. Complexity: O(n) where n0 is the number of chunks, as U.length u is O(1).Returns >* if the given element is contained in the c. Complexity: O(n) where n0 is the number of chunks, as U.length u is O(1).TODO: Improve implementation.TODO: Improve implementation.Equality between cX. This function is fiddly to write as is not enough to compare for equality the inner /(s), we need an element-by-element comparison.$Take the first n elements from this c. TODO: Perform compaction? Compacting the underlying chunks will have the snag of copying data, but the pro of improving cache-friendliness and reduce data scattering.$cc#c\ BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DR5Return the element at a specific index from a Bitmap.5If the index @n is out of bounds, an error is raised.MReturn the element at a specific index from an array without bounds checking.NReading from invalid memory can return unpredictable and invalid values. use  if unsure.&make an array from a list of elements.transform an array to a list."Check if two vectors are identicalCompare 2 vectors7Append 2 arrays together by creating a new bigger arrayTODO completely non optimized=de de;de BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone )0BDR abcde baced]None)0DR f9Incremental Hashing state. Represent an hashing algorithm$the base primitive of this class is ", append mix a Word8 in the stateThe class allow to define faster mixing function that works on bigger Word size and any unboxed array of any PrimType elements.Associate type when finalizing the state with Create a new Hashing context.Finalize the state and returns the hash result:Mix a Word8 (Byte) into the state and return the new state4Mix a Word16 into the state and return the new state4Mix a Word32 into the state and return the new state4Mix a Word64 into the state and return the new state=Mix an arbitrary sized unboxed array and return the new state f ff^ BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalgoodNone )0BDIRFNV1(a) hash (64 bit variants)FNV1(a) hash (32 bit variants)6compute FNV1 (32 bit variant) of a raw piece of memory7compute FNV1a (32 bit variant) of a raw piece of memory6compute FNV1 (64 bit variant) of a raw piece of memory7compute FNV1a (64 bit variant) of a raw piece of memoryghij   ghijghij   _ BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalgoodNone)0DRk"Type with the ability to be hashedHashable doesn't have any specific rules, and it's made for raw speed. More specifically don't expect different type representing the same data to hash to the same value .hashMix (1 :: Integer) /= hashMix (1 :: Word8)Truekl   klkl   ` BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalgoodNone )0BDRm5Sip State 1-3 (1 compression rounds, 3 digest rounds)n5Sip 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).#$%&'()*+,-./0m1n2!3"456789:#;<=>?@Amn"4$%&'()*+,-./0m1n2!3"456789:#;<=>?@A BSD-style FoundationNone)0DR fghijklmn klfjihgmn BSD-style experimentalGoodNone)0DRoRNG 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.pGAn 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.q[A simple Monad class very similar to a State Monad with the state being a RandomGenerator.t,A Deterministic Random Generator (DRG) classu!Initialize a new random generatorv)Generate N bytes of randomness from a DRGw7A monad constraint that allows to generate random bytesy6Run a pure computation with a Random Generator in the qoBpqrstuvwxCyDEz{|}~ opqrstuvwxy wxqrstuvypooBpqrstuvwxCyDEz{|}~ BSD-style foundation experimentalportableNone)0DRF'errors related to FileName manipulationG0this means a null byte was found in the FileNameH5this means a path separator was found in the FileNameIencoding errorJ"some unknown trainling bytes found+A filename (or path entity) in the FilePath  Authorised"""."".." "foundation" Unauthorised"/""file/""/file" "file/path"K)error associated to filepath manipulationL2this 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 .M.define the Path separator for POSIX systems : /N convert a FileName into a String?This function may throw an exception associated to the encodingO*conversion of FileName into a list of Char"this function may throw exceptions,conversion of a FilePath into a list of Char"this function may throw exceptions/build a file path from a given list of filename7this is unsafe and is mainly needed for testing purpose(build a file name from a given ByteArray7this is unsafe and is mainly needed for testing purpose)FGHIJPKLQRMSTUVWXYZNO   FGHIJPKLQRMSTUVWXYZNO? BSD-style foundation experimentalportableNone)0DR !"#$%&'()* !"#$%&(')*a 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.][^_`a\][^_`a\][^_`a\b(c) Vincent Hanquez 2014 BSD-styleVincent Hanquez provisionalnon-portable (requires POSIX)None)0DRbMemory synchronization flagscperform asynchronous write.dperform synchronous write.einvalidate cache data.fAdvice to put on memory.only define the posix one.g no specific advice, the default.hBExpect page references in random order. No readahead should occur.iRExpect page references in sequential order. Page should be readahead aggressively.jIExpect access in the near future. Probably a good idea to readahead earlyk(Do not expect access in the near future.lMemory protectionm Mapping flagn)memory changes are shared between processo%memory changes are private to processpMap pages of memory.vIf fd is present, this memory will represent the file associated. Otherwise, the memory will be an anonymous mapping.use mmapqUnmap pages of memoryuse munmapr7give advice to the operating system about use of memorycall madvises%lock a range of process address spacecall mlockt'unlock a range of process address spacecall munlocku set protection of memory mappingcall mprotectv4memorySync synchronize memory with physical storage.FOn an anonymous mapping this function does not have any effect. call msyncw&Return the operating system page size.call sysconf'bcdefghijklxyz{mno|}~p*The address to map to if MapFixed is used.The length of the mapping1the memory protection associated with the mappingqrstuvwbcdefghijklxyz{mnopqrstuvwbcdefghijklxyz{mno|}~pqrstuvwcNone)0DR[^_`a\d BSD-style Foundation experimentalportableNone)0DR2list the file name in the given FilePath directoryqTODO: error management and not implemented yet getDirectory :: FilePath -> IO [FileName] getDirectory = undefinedOpen a new handle on the fileClose a handle-Read binary data directly from the specified .First argument is the Handle to read from, and the second is the number of bytes to read. It returns the bytes read, up to the specified size, or an empty array if EOF has been reached. is implemented in terms of hGetBuf.hGetNonBlocking is similar to , except that it will never block waiting for data to become available, instead it returns only whatever data is available. If there is no data available to be read,  returns an empty array.7Note: on Windows, this function behaves identically to .Like , except that a shorter array may be returned if there are not enough bytes immediately available to satisfy the whole request. N only blocks if there is no data available, and EOF has not yet been reached. filepath mode act opens a file using the mode and run acta. the by-product handle will be closed when act finish, either normally or through an exception.(The value returned is the result of act@IRead a binary file and return the whole content in one contiguous buffer.oFold over chunks file calling the callback function for each chunks read from the file, until the end of file. Fold callback functioninitial accumulator File to read `_^]\  BSD-style#Vincent Hanquez <vincent@snarc.org> experimentalportableNone)0DR `_^]\ `_^]\ 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&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.XReturns a list of the program's command line arguments (not including the program name).Elkmnpo  !"#$%&;>'()*+,-./0<=1ABC2345678:?@FNLKMQTSUW[ZYXabcdegfhijqrstuvwxyz{|}~_`abcdefghijklmb~Slmjkhiefgbcd_`aTxdz{y}|! lkponm NMLK$ #E0<=1ABC&;>'3:?@+,-.56784*/F2)(bj%UqruwvstacbhiQ[ZYX"Wgfeefghijhikhlmhlnhlohlpeqreqshithiuhivhiwhixhyzh{|h{}h~h~h~h~hihihihihihihlhleqhihieqhhhyhihieeeeehhhhhieh{eehhhhhhehihiehheeehh~hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh{hlhlhlhlhlhlhhhhhhhhhhhhihihihihihihihi hi hi hi h h heqeqeqeqeqeqeqeqeqeq %!%"%#%$%%%&+'+(+)+*+++,+-,.,/ 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A/B/C/D/E/F/G0H0I0J0K1L1M1N1O2P2Q2R2S2T2U2V2W2X2Y2Z3[3\3]4^4^4_4_ ` 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 { | } ~       6666777777777888888888899999999AACCCCDDDDDDDDDDDDDDDEFFGGGGGG H>I I I I IIIIIIIJJJJJKKKLLMM M!M"M#M$M%M&M'M(M)M*M+M,M-M.M/M0M1M2M3M4M5M6M7M8M9M:M;N<N<N=N>N?N@NANANBNCNDNENFNGOHOIOJOKOLOMONOOOPOQOROSOTOUOVOWOXOYOZO[Q\Q]Q^Q_Q`QaQbQcQdQeQfQgQhijklmnopqrstuvwxyzX{X|X}X~XXXXXXXXXXnXjXoXpYY ZZ[\\]^^^^__``@dd d d d d """""""" "!"""#"$"%e&#'#(#)%*%+%,%-%.%/%0%1%2%3%4%5%6%7%8%9%:%;%<%=%>%?%@%A%B%C%D%E%F%G%H%I%J%K%L%MhNOhNOhNPhQR)S)T)U)VhhhWXhWYhWZhW[hW\hW]hW^hW_hW`hWahWbhWchWdhWehWfhghhhhijhikhilhimhhWnhWohpqhrsh**t*u*t*v*u*w*x*y*z*{*|*}+~+++----------- 0  9 //0000000000000000001111111111111112222222222222222222222222222222233333333333333444444444444444444445h 666666666777777779999999 9 9 9 9 9999999999999:::::: ;!;";#;$;%;%;&;';(<)<)<*=+=,=,=-=.=/=0=1=2=3=497B5B!B#B%B/B0C67D8D9D:D;D<D=D>D?D@DADBDCDDDEDFDGDHEIEJEJEKEKELELEEMENEOEPEQERFSFTFUFVFWFXFYFZF[F\F]F^F_F`FaGlGbGbGcG GdGeGaG`GmGfGgGhGiGjGFGkGlGmGnGoGpGqGcGrGsGtG5GuGvGwGxGyG G G"G$GzG!G#G%G&G{GG'G(G G)G+G|G}G2G1G/G0G3G4G,G.GGGG~GGGGGIIIIIJJKKLLMMMNOOOOOOOOOOOOOOOPPPQRRRRSSSSS{STTT|T|TTTTTUTTUUUUUUUUUUV~V~VVVVVUVVWWWWWWUWWhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh "&Xic $!#%'()+ 120/34,.XXX X"XX&XXeXXlXXXXXXXXXXXXXXXXXXXXXUXcXqXXX X$X!X#X%X{X'X(X X)X+XpX XkXmXXX1X2X0X/X3X4X,X.XXXXXXXXXXXXXX, hhZZZbZcZSZTZUZVZaZ`ZbZlZYZdZeZXZmZFZZZlZcZiZjZtZ ZpZgZhZuZ Z Z Z"Z$Z!Z#Z%Z&Z{Z'Z)Z+Z|Z2Z1Z/Z0Z3Z4Z,Z ZqZ.Z Z ZZZZZZZZZZZZZZZZZ[ [ [[[i[ [[t[F[u[g[h[ ["[![#[&['[)[.[,[0[/[1[2[3[4[b[c[[ [!["[#[$\b\c\g\h\i\j\F\\\%\&\'\(\b\c\`\a\V\T\U\S\ \Z\t\X\u\ \ \"\$\&\'\+\|\2\1\/\0\)\3\4\,\.\\\\\)\*\+\,\-\.\/\0\1\2\3\4]5]6]7]8]9]:];]<]=]>]?^@^A^B^C^D^E^^^^^@^A^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`q`r`r```e`f`s`t`u`v`w`x`y`z`{`|`}`~`@aaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbhdddd'foundation-0.0.3-FMP5SrvUliFIUu1DipIC50 FoundationFoundation.Class.StorableFoundation.System.InfoFoundation.Class.BifunctorFoundation.MonadFoundation.Parser Foundation.IOFoundation.StrictFoundation.Monad.ReaderFoundation.Monad.StateFoundation.NumericalFoundation.Math.TrigonometryFoundation.PrimitiveFoundation.ForeignFoundation.VFS.PathFoundation.VFS.URIFoundation.ConvertibleFoundation.CollectionFoundation.Tuple.NthFoundation.BitsFoundation.ArrayFoundation.Array.InternalFoundation.String.ASCIIFoundation.StringFoundation.System.EntropyFoundation.HashingFoundation.RandomFoundation.VFS.FilePathFoundation.IO.FileMapFoundation.String.InternalFoundation.Numerical.PrimitivesFoundation.Monad.MonadIOFoundation.Internal.ProxyFoundation.Internal.PrimitiveFoundation.Internal.PrimTypesFoundation.Internal.NaturalFoundation.Internal.NumLiteralFoundation.Internal.IsListFoundation.Internal.IdentityFoundation.Internal.CallStackFoundation.Internal.BaseFoundation.Internal.MonadTransFoundation.Monad.ExceptionFoundation.Monad.TransformerFoundation.Monad.IdentityFoundation.Monad.BaseFoundation.Numerical.FloatingFoundation.Numerical.NumberFoundation.Numerical.Additive#Foundation.Numerical.Multiplicative Foundation.Numerical.SubtractiveFoundation.Internal.TypesFoundation.Internal.EnvironmentFoundation.PartialFoundation.Primitive.MonadFoundation.Primitive.FinalPtrFoundation.Primitive.TypesFoundation.Primitive.UtilsFoundation.String.UTF8Table Foundation.System.Entropy.CommonFoundation.System.Entropy.UnixElementFoundation.VFSFilePathURIFoundation.Collection.ListFoundation.Collection.KeyedFoundation.TupleFoundation.Array.Common Foundation.Array.Unboxed.MutableFoundation.Array.UnboxedFoundation.Collection.Element Foundation.Collection.CollectionFoundation.Collection.FoldableFoundation.Collection.Indexed"Foundation.Collection.InnerFunctor Foundation.Collection.SequentialFoundation.Collection.BuildableFoundation.Collection.ZippableFoundation.String.ModifiedUTF8Foundation.Collection.Mutable"Foundation.Array.Unboxed.ByteArray#Foundation.String.Encoding.Encoding!Foundation.String.Encoding.ASCII7%Foundation.String.Encoding.ISO_8859_1 Foundation.String.Encoding.UTF16 Foundation.String.Encoding.UTF32Foundation.String.UTF8Foundation.IO.TerminalFoundation.Array.Boxed Foundation.Array.Chunked.UnboxedFoundation.Array.BitmapFoundation.Hashing.HasherFoundation.Hashing.FNVFoundation.Hashing.HashableFoundation.Hashing.SipHash"Foundation.Foreign.MemoryMap.Types"Foundation.Foreign.MemoryMap.PosixFoundation.Foreign.MemoryMapFoundation.IO.Fileghc-primGHC.PrimseqbaseGHC.Base otherwise$GHC.EnumenumFrom enumFromThen enumFromToenumFromThenTo GHC.Classes==>=fail>>=>>fmapreturn Data.String fromStringGHC.Real fromIntegral realToFracGHC.ExtsIsListfromList fromListNtoListmemptymappendmconcat<*>pure*>BoundedEnumEqMonadFunctorOrdGHC.ShowShowData.Typeable.InternalTypeableIsString ApplicativeMonoid GHC.TypesBoolCharDoubleFloatIntGHC.IntInt8Int16Int32Int64 integer-gmpGHC.Integer.TypeIntegerMaybeOrderingRationalIOWordGHC.WordWord8Word16Word32Word64GHC.PtrPtr Data.EitherEitherFalseNothingJustTrueLeftRightLTEQGT System.InfocompilerVersionItem GHC.NaturalNatural Data.Version versionTags versionBranchVersionData.Bifunctorsecondfirstbimap BifunctorControl.Monad.IO.ClassliftIOMonadIO Control.Monad>=>Control.ApplicativeoptionalControl.Category.id Data.Monoid<>castPtrGHC.IO.Exception IOException GHC.ExceptiondisplayException fromException toException Exception GHC.IO.IOMode ReadWriteMode AppendMode WriteModeReadModeIOModepartitionEithersrightsleftseither Data.Proxy asProxyTypeOfProxy Data.Functionon Data.Functor<$>^^maxBoundminBoundfromEnumtoEnumpredsucc Data.MaybemapMaybe catMaybes listToMaybe maybeToList fromMaybe isNothingisJustmaybe Data.TupleswapuncurrycurryasTypeOfuntil$!flipconst=<<<$<*manysome<|>GHC.Err undefinederror SomeException/=compare<=&&||not<>maxminstrict1strict2strict3strict4strict5strict6 HasNegationnegate Fractional fromRationalIntegral fromInteger MonadCatchcatch MonadThrowthrow MonadFailureFailuremFail MonadTransliftReaderT$fMonadCatchReaderT$fMonadThrowReaderT$fMonadFailureReaderT$fMonadIOReaderT$fMonadTransReaderT$fMonadReaderT$fApplicativeReaderT$fFunctorReaderTStateT$fMonadCatchStateT$fMonadThrowStateT$fMonadFailureStateT$fMonadIOStateT$fMonadTransStateT $fMonadStateT$fApplicativeStateT$fFunctorStateT FloatingPoint floatRadix floatDigits floatRange floatDecode floatEncode IsNatural toNatural IsIntegral toIntegerAdditiveazero+scale Divisible/ IDivisibledivmoddivModMultiplicative midentity*^recip Subtractive Difference-SizeOffsetIntegralRoundingroundUp roundDown roundTruncate roundNearestSignedabssignumSign SignNegativeSignZero SignPositive$fIntegralRoundingFloat$fIntegralRoundingDouble$fIntegralRoundingRatio $fSignedInt64 $fSignedInt32 $fSignedInt16 $fSignedInt8 $fSignedInt$fSignedInteger$fEqSign Trigonometrypisincostanasinacosatansinhcoshtanhasinhacoshatanh$fTrigonometryDouble$fTrigonometryFloat PartialErrorPartialpartial fromPartial PrimMonad PrimStatePrimVar primitive primThrow unPrimMonad primVarNew primVarRead primVarWriteFinalPtr FinalForeignfinalPtrSameMemory toFinalPtrtoFinalPtrForeign castFinalPtrwithFinalPtrNoTouch withFinalPtrwithUnsafeFinalPtrPrimTypeprimSizeInBytes primBaUIndex primMbaURead primMbaUWrite primAddrIndex primAddrRead primAddrWritePathPathEnt PathPrefix PathSuffix splitPath buildPathparentfilenameprefixsuffixURIPath URIFragmentURIQuery URIAuthority URISchema $fPathURI ConvertibleConvertconvert$fConvertibleaaKeyedCollectionKeyValuelookup StorableFixedsize alignmentStorablepeekpokeplusPtrpeekOffpokeOff$fStorableFixedWord64$fStorableFixedWord32$fStorableFixedWord16$fStorableFixedWord8$fStorableFixedInt64$fStorableFixedInt32$fStorableFixedInt16$fStorableFixedInt8$fStorableFixedFloat$fStorableFixedDouble$fStorableFixedChar$fStorableWord64$fStorableWord32$fStorableWord16$fStorableWord8$fStorableInt64$fStorableInt32$fStorableInt16$fStorableInt8$fStorableFloat$fStorableDouble$fStorableCharThdable ProductThirdthdSndable ProductSecondsndFstable ProductFirstfstTuple4Tuple3Tuple2NthableNthTynth$fNthable4Tuple4$fNthable3Tuple4$fNthable2Tuple4$fNthable1Tuple4$fNthable4(,,,)$fNthable3(,,,)$fNthable2(,,,)$fNthable1(,,,)$fNthable3Tuple3$fNthable2Tuple3$fNthable1Tuple3$fNthable3(,,)$fNthable2(,,)$fNthable1(,,)$fNthable2Tuple2$fNthable1Tuple2 $fNthable2(,) $fNthable1(,).<<..>>. alignRoundUpalignRoundDown OutOfBoundMUArraymutableForeignMemUArrayUVecBAUVecAddr foreignMemfromForeignPtrrecast CollectionnulllengthelemnotElemmaximumminimumNonEmpty getNonEmptynonEmpty nonEmpty_Foldablefoldlfoldl'foldrfoldr'IndexedCollection! findIndex InnerFunctorimap SequentialtakerevTakedroprevDropsplitAt revSplitAtsplitOnbreak breakElem intersperse intercalatespanfilter partitionreverseunconsunsnocsnocconsfindsortBy singletonheadlasttailinit isPrefixOf isSuffixOf BuildingState prevChunksprevChunksSizecurChunk chunkSizeBuilder runBuilder BuildableMutableStepappendbuild BoxedZippablezipzip3zip4zip5zip6zip7unzipunzip3unzip4unzip5unzip6unzip7ZippablezipWithzipWith3zipWith4zipWith5zipWith6zipWith7MutableCollectionMutableFreezed MutableKey MutableValue unsafeThaw unsafeFreezethawfreezemutNewmutUnsafeWritemutWrite mutUnsafeReadmutRead AsciiStringtoBytes replicatecopycreatefromBytesUnsafelineswords$fZippableAsciiString$fSequentialAsciiString$fCollectionAsciiString$fInnerFunctorAsciiString$fIsListAsciiString$fIsStringAsciiString$fShowAsciiString$fMonoidAsciiString$fEqAsciiString$fOrdAsciiStringEncodingASCII7UTF8UTF16UTF32 ISO_8859_1ValidationFailure InvalidHeaderInvalidContinuation MissingByteString fromBytesfromBytesLenientputStrputStrLnParser runParserResult ParseFail ParseMoreParseOK ParserErrorExpected NotEnough MonadFail expectedInput receivedInput parseFeedparsehasMore anyElementelementelementsstring takeWhiletakeAllskip skipWhileskipAll$fAlternativeParser$fMonadPlusParser $fMonadParser$fApplicativeParser$fFunctorParser $fShowResult$fExceptionParserError$fShowParserError$fEqParserError$fOrdParserError Endianness LittleEndian BigEndianArchI386X86_64PowerPC PowerPC64SparcSparc64ARMARM64OSWindowsOSXLinuxAndroidBSDosarch compilerNamecpus endianness$fShowOS$fEqOS$fOrdOS$fEnumOS $fBoundedOS$fDataOS $fShowArch$fEqArch $fOrdArch $fEnumArch $fBoundedArch $fDataArch$fEqEndianness$fShowEndianness getEntropyMArrayArray ChunkedUArray MutableBitmapBitmapHasherFNV1a_64FNV1a_32FNV1_64FNV1_32HashablehashMixSip1_3Sip2_4RNGv1RNGMonadRandomStaterunRandomState RandomGen randomNewrandomGenerate MonadRandomgetRandomByteswithRandomGenerator$fRandomGenRNGv1$fMonadRandomMonadRandomState$fMonadMonadRandomState$fApplicativeMonadRandomState$fFunctorMonadRandomState$fMonadRandomIOFileName RelativityAbsoluteRelativefilePathToStringfilePathToLStringunsafeFilePathunsafeFileName extension$fPathFilePath$fMonoidFileName$fIsStringFileName$fShowFileName$fExceptionFileName_Invalid$fIsStringFilePath$fExceptionFilePath_Invalid $fOrdFilePath $fEqFilePath$fShowFilePath$fEqRelativity$fShowRelativity$fShowFilePath_Invalid $fEqFileName$fShowFileName_InvalidopenFile closeFilehGetwithFilereadFile foldTextFile fileMapReadfileMapReadWithLStringshowgetArgsIntegralConvertintegralConvert intToWord$fIntegralConvertInt64Word64$fIntegralConvertInt32Word32$fIntegralConvertInt16Word16$fIntegralConvertInt8Word8 PinnedStatusbool# compatAndI#compatQuotRemInt#compatCopyAddrToByteArray# compatMkWeak#isPinnedpinnedunpinned compatGetSizeofMutableByteArray#compatShrinkMutableByteArray#compatResizeMutableByteArray#W#Size#Offset# FileSize#$fFractionalCDouble$fFractionalCFloat$fFractionalDouble$fFractionalFloat$fFractionalRatio$fHasNegationCInt$fHasNegationWord64$fHasNegationWord32$fHasNegationWord16$fHasNegationWord8$fHasNegationWord$fHasNegationInt64$fHasNegationInt32$fHasNegationInt16$fHasNegationInt8$fHasNegationInt$fHasNegationInteger$fIntegralCDouble$fIntegralCFloat$fIntegralDouble$fIntegralFloat$fIntegralCOff$fIntegralCInt$fIntegralCSize$fIntegralInt64$fIntegralInt32$fIntegralInt16$fIntegralInt8$fIntegralWord64$fIntegralWord32$fIntegralWord16$fIntegralWord8$fIntegralWord $fIntegralInt$fIntegralNatural$fIntegralIntegerData.Functor.IdentityIdentity runIdentityGHC.Stack.Types HasCallStack internalError ifThenElseFP64FP32 Data.DataDatagfoldlgunfoldtoConstr dataTypeOf dataCast1 dataCast2gmapTgmapQlgmapQrgmapQgmapQigmapMgmapMpgmapMo showsPrecshowList GHC.GenericsGenericRepfromto mkNoRepTypeDataType Data.FoldableandGHC.IOthrowIOReaderState runReaderrunState $fMonadReader$fApplicativeReader$fFunctorReader $fMonadState$fApplicativeState$fFunctorState$fMonadCatchIO$fMonadThrowIO$fMonadFailureEither$fMonadFailureMaybe IdentityT runIdentityT$fMonadCatchIdentityT$fMonadThrowIdentityT$fMonadFailureIdentityT$fMonadIOIdentityT$fMonadTransIdentityT$fMonadIdentityT$fApplicativeIdentityT$fFunctorIdentityT runReaderT runStateT$fFloatingPointDouble$fFloatingPointFloat$fIsNaturalWord64$fIsNaturalWord32$fIsNaturalWord16$fIsNaturalWord8$fIsNaturalWord$fIsNaturalNatural$fIsIntegralWord64$fIsIntegralWord32$fIsIntegralWord16$fIsIntegralWord8$fIsIntegralWord$fIsIntegralNatural$fIsIntegralInt64$fIsIntegralInt32$fIsIntegralInt16$fIsIntegralInt8$fIsIntegralInt$fIsIntegralIntegerscaleNum$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$fSubtractiveDouble$fSubtractiveFloat$fSubtractiveWord64$fSubtractiveWord32$fSubtractiveWord16$fSubtractiveWord8$fSubtractiveWord$fSubtractiveNatural$fSubtractiveInt64$fSubtractiveInt32$fSubtractiveInt16$fSubtractiveInt8$fSubtractiveInt$fSubtractiveIntegerSize8Offset8FileSize+. offsetOfE offsetPlusE offsetMinusE offsetRecastsizeOfE$fSubtractiveSize$fAdditiveSize$fIsNaturalSize$fIsIntegralSize$fIntegralSize$fSubtractiveOffset$fAdditiveOffset$fIsNaturalOffset$fIsIntegralOffset$fIntegralOffsetunsafeUArrayUnpinnedMaxSize GHC.IO.UnsafeunsafePerformIOorderingToSign partialErrorfromJust fromRightfromLeft$fExceptionPartialError unPrimMonad_unsafePrimCastunsafePrimToSTunsafePrimToIOunsafePrimFromIO primTouch $fPrimMonadST $fPrimMonadIO sizeRecast primBaIndex primMbaRead primMbaWriteprimArrayIndexprimMutableArrayReadprimMutableArrayWriteprimOffsetRecast primOffsetOfE sizeAsOffset offsetAsSize$fPrimTypeCUChar$fPrimTypeCChar$fPrimTypeChar$fPrimTypeDouble$fPrimTypeFloat$fPrimTypeInt64$fPrimTypeInt32$fPrimTypeInt16$fPrimTypeInt8$fPrimTypeWord64$fPrimTypeWord32$fPrimTypeWord16$fPrimTypeWord8primCopyFreezedBytesprimCopyFreezedBytesOffsetprimCopyFreezedW32primCopyFreezedW64 primMutableByteArraySlideToStartprimMutableAddrSlideToStartisContinuation getNbBytesisContinuation# getNbBytes#TableunTable contTable headTableEntropySystemMissing$fExceptionEntropySystemMissing entropyGather EntropyCtxEntropySyscallc_sysrandom_linux entropyOpen entropyCloseentropyMaximumSizeopenDevgatherDevEntropysupportSyscall wordsWhen$fKeyedCollection[]toProxy$fThdableTuple4$fThdableTuple3$fThdable(,,,) $fThdable(,,)$fSndableTuple4$fSndableTuple3$fSndableTuple2$fSndable(,,,) $fSndable(,,) $fSndable(,)$fFstableTuple4$fFstableTuple3$fFstableTuple2$fFstable(,,,) $fFstable(,,) $fFstable(,)$fBifunctorTuple2OutOfBoundOperation InvalidRecastRecastDestinationSizeRecastSourceSizeOOB_Read OOB_Write OOB_MemSet OOB_Index$fExceptionInvalidRecast$fExceptionOutOfBoundread unsafeReadwrite unsafeWrite newPinnednewcopyAt mutableLengthMUVecMA MUVecAddrmutableArrayProxyTysizeInMutableBytesOfContent newUnpinned mutableSame newNativeindex unsafeIndexunsafeCopyAtROunsafeCopyFrom createFromIO vFromListvToListequalvCompareupdate arrayType vectorProxyTy unsafeIndexer unsafeDewrap lengthSizeunsafeFreezeShrink freezeShrink unsafeSlideemptyconcat unsafeUpdatewithPtrwithMutablePtr unsafeRecast splitElemsubmapmapIndex$fIsListUArray$fMonoidUArray $fOrdUArray $fEqUArray $fShowUArray $fDataUArray$fCollectionNonEmpty$fCollectionUArray$fCollection[]$fIsListNonEmpty$fFoldableUArray $fFoldable[]$fIndexedCollectionUArray$fIndexedCollection[]$fInnerFunctorUArray$fInnerFunctor[]mconcatCollection$fSequentialUArray$fSequential[]$fBuildableUArrayuncons2uncons3uncons4uncons5uncons6uncons7uncurry2uncurry3uncurry4uncurry5uncurry6uncurry7$fBoxedZippable[]$fZippableUArray $fZippable[] fromModified accessBytesbuildByteArray$fMutableCollectionMUArrayMutableByteArraymutableByteArraySetmutableByteArraySetBetweenmutableByteArrayMoveUnitError encodingNext convertFromTo encodingWriteisAsciinextASCII7_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_InvalidForeign.C.TypesCCharCSCharCUCharCShortCUShortCIntCUIntCLongCULongCLLongCULLongCFloatCDoubleCPtrdiffCSizeCWchar CSigAtomicCClockCTime CUSeconds CSUSecondsCFileCFposCJmpBufCIntPtrCUIntPtrCIntMaxCUIntMaxMutableAsciiString cucharToChar charToCUCharsToList sFromList cucharMapUTF8CharvalidateindexN splitIndexUTF8_1UTF8_2UTF8_3UTF8_4 EncoderUTF8 MutableString stringTypemutableValidateskipNextHeaderValuenextWithIndexerwriteWithBuilder asUTF8CharnumBytes writeUTF8Char charToBytescharMapfromEncoderBytesfromChunkBytestoEncoderBytes$fEncodingEncoderUTF8$fExceptionValidationFailure$fBuildableString$fZippableString$fSequentialString$fCollectionString$fInnerFunctorString$fIsListString$fIsStringString $fShowString $fDataStringSuccessgetMoregetAllflushAll onNewArrayfreezeUntilIndexaFoldlaFoldraFoldl'$fBuildableArray$fBoxedZippableArray$fZippableArray$fIndexedCollectionArray$fMutableCollectionMArray$fSequentialArray$fCollectionArray$fFoldableArray$fInnerFunctorArray $fIsListArray $fOrdArray $fEqArray $fShowArray $fMonoidArray$fFunctorArray $fDataArray $fIndexedCollectionChunkedUArray$fSequentialChunkedUArray$fCollectionChunkedUArray$fIsListChunkedUArray$fMonoidChunkedUArray$fEqChunkedUArray bitsPerTy shiftPerTy maskPerTy bitmapIndex unoptimised $fMutableCollectionMutableBitmap$fIndexedCollectionBitmap$fSequentialBitmap$fCollectionBitmap$fFoldableBitmap$fInnerFunctorBitmap$fIsListBitmap$fMonoidBitmap $fOrdBitmap $fEqBitmap $fShowBitmaphashMix8 HashResulthashEndhashNew 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$fHashableWord8SipHashSipKeymixBaSipIncrementalSipIncremental0SipIncremental1SipIncremental2SipIncremental3SipIncremental4SipIncremental5SipIncremental6SipIncremental7 InternalStateSip newSipStatemix8Primmix8mix32mix64finishdoRoundprocessfinalize loopRounds andMask64$fHasherSip1_3$fHasherSip2_4c_rngv1_generate rngv1KeySize rngv1GenerateFileName_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