úÎ!ŸT™Hh      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgNone"FHVdF bytesliceA slice of unmanaged memory. byteslice A slice of a h.  byteslice A slice of a i.  None_¬ bytesliceETake bytes while the predicate is true, aliasing the argument array. bytesliceEDrop bytes while the predicate is true, aliasing the argument array. bytesliceTake the first n& bytes from the argument, aliasing it. bytesliceDrop the first n? bytes from the argument, aliasing it. The new length will be len - n. bytesliceCreate a slice of B that spans the entire argument array. This aliases the argument.None $*FXk(‹ byteslice;Count the number of times the byte appears in the sequence. byteslice Variant of ; that returns an array of unsliced byte sequences. Unlike h, this is not a good producer for list fusion. (It does not return a list, so it could not be.) Prefer P if the result is going to be consumed exactly once by a good consumer. Prefer ] if the result of the split is going to be around for a while and inspected multiple times. byteslice Variant of & that drops the trailing element. See / for an explanation of why this may be useful. bytesliceÂBreak a byte sequence into pieces separated by the byte argument, consuming the delimiter. This function is a good producer for list fusion. It is common to immidiately consume the results of split with foldl',  traverse_, foldlM5, and being a good producer helps in this situation.4Note: this function differs from its counterpart in  bytestring^. If the byte sequence is empty, this returns a singleton list with the empty byte sequence. byteslice Variant of  that returns the result as a j instead of []*. This is also eligible for stream fusion. byteslice Variant of À that drops the trailing element. This behaves correctly even if the byte sequence is empty. This is a good producer for list fusion. This is useful when splitting a text file into lines.  Shttps://pubs.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap03.html#tag_03_392POSIXK mandates that text files end with a newline, so the list resulting from > always has an empty byte sequence as its last element. With %, that unwanted element is discarded.None$*Fk‡9 bytesliceIs the byte sequence empty?  bytesliceThe length of a slice of bytes.! byteslice!Extract the head and tail of the   , returning k if it is empty." byteslice Extract the init and last of the   , returning k if it is empty.# bytesliceWDoes the byte sequence begin with the given byte? False if the byte sequence is empty.$ bytesliceUDoes the byte sequence end with the given byte? False if the byte sequence is empty.% byteslice6Is the first argument a prefix of the second argument?& byteslice6Is the first argument a suffix of the second argument?' byteslice<Find the longest string which is a prefix of both arguments.( byteslice%Create a byte sequence with one byte.) byteslice&Create a byte sequence with two bytes.* byteslice(Create a byte sequence with three bytes.+ byteslice/Create an unsliced byte sequence with one byte., byteslice0Create an unsliced byte sequence with two bytes.- byteslice2Create an unsliced byte sequence with three bytes.. bytesliceReplicate a byte n times./ byteslice Variant of .$ that returns a unsliced byte array.0 bytesliceO(n)W Return the suffix of the second string if its prefix matches the entire first string.1 bytesliceO(n)‡ Return the suffix of the second string if its prefix matches the entire first string. Otherwise, return the second string unchanged.2 bytesliceO(n)W Return the prefix of the second string if its suffix matches the entire first string.3 bytesliceO(n)‡ Return the prefix of the second string if its suffix matches the entire first string. Otherwise, return the second string unchanged.4 byteslicevSplit a byte sequence on the first occurrence of the target byte. The target is removed from the result. For example:split1 0xA [0x1,0x2,0xA,0xB]Just ([0x1,0x2],[0xB])5 bytesliceƒSplit a byte sequence on the first and second occurrences of the target byte. The target is removed from the result. For example:(split2 0xA [0x1,0x2,0xA,0xB,0xA,0xA,0xA] Just ([0x1,0x2],[0xB],[0xA,0xA])6 byteslice‹Split a byte sequence on the first, second, and third occurrences of the target byte. The target is removed from the result. For example:(split3 0xA [0x1,0x2,0xA,0xB,0xA,0xA,0xA]Just ([0x1,0x2],[0xB],[],[0xA])7 byteslice*Is the byte a member of the byte sequence?8 byteslice'Take bytes while the predicate is true.9 byteslice'Drop bytes while the predicate is true.: byteslice]Index into the byte sequence at the given position. This index must be less than the length.; bytesliceO(n) ; p bT returns the prefix remaining after dropping characters that satisfy the predicate p from the end of t.< bytesliceO(n) < p b@ returns the longest suffix of elements that satisfy predicate p.= bytesliceTake the first n( bytes from the argument. Precondition: n "d len> bytesliceDrop the first n( bytes from the argument. Precondition: n "d len? byteslice4Left fold over bytes, non-strict in the accumulator.@ byteslice5Right fold over bytes, non-strict in the accumulator.A byteslice0Left fold over bytes, strict in the accumulator.B bytesliceyLeft fold over bytes, strict in the accumulator. The reduction function is applied to each element along with its index.C byteslice1Right fold over bytes, strict in the accumulator.D bytesliceConvert the sliced   to an unsliced i,. This reuses the array backing the sliced  ] if the slicing metadata implies that all of the bytes are used. Otherwise, it makes a copy.E byteslice Variant of DD that unconditionally makes a copy of the array backing the sliced  5 even if the original array could be reused. Prefer D.F byteslice Convert a ll consisting of only characters in the ASCII block to a byte sequence. Any character with a codepoint above U+007F is replaced by U+0000.G byteslice Convert a l† consisting of only characters representable by ISO-8859-1. These are encoded with ISO-8859-1. Any character with a codepoint above U+00FF is replace an unspecified byte.H byteslice8Interpret a byte sequence as text encoded by ISO-8859-1.I bytesliceCreate a slice of  & that spans the entire argument array.J byteslicetIs the byte sequence, when interpreted as ISO-8859-1-encoded text, a singleton whose element matches the character?K byteslicetIs the byte sequence, when interpreted as ISO-8859-1-encoded text, a doubleton whose elements match the characters?L byteslicetIs the byte sequence, when interpreted as ISO-8859-1-encoded text, a tripleton whose elements match the characters?M byteslicewIs the byte sequence, when interpreted as ISO-8859-1-encoded text, a quadrupleton whose elements match the characters?N byteslicewIs the byte sequence, when interpreted as ISO-8859-1-encoded text, a quintupleton whose elements match the characters?O byteslicevIs the byte sequence, when interpreted as ISO-8859-1-encoded text, a sextupleton whose elements match the characters?P byteslicevIs the byte sequence, when interpreted as ISO-8859-1-encoded text, a septupleton whose elements match the characters?Q bytesliceCopy the byte sequence into a mutable buffer. The buffer must have enough space to accomodate the byte sequence, but this this is not checked.R byteslicekYields a pinned byte sequence whose contents are identical to those of the original byte sequence. If the  ByteArrayn backing the argument was already pinned, this simply aliases the argument and does not perform any copying.S byteslice[Yields a pointer to the beginning of the byte sequence. It is only safe to call this on a   backed by a pinned  ByteArray.T bytesliceUTouch the byte array backing the byte sequence. This sometimes needed after calling S so that the  ByteArray! does not get garbage collected.U bytesliceThe empty byte sequence.V bytesliceRead   directly from the specified m. The resulting  & are pinned. This is implemented with hGetBuf.W bytesliceOutputs   to the specified m. This is implemented with hPutBuf.. bytesliceDesired length n bytesliceByte to replicateQ byteslice Destination bytesliceDestination Offset bytesliceSource@  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVW@ U !"()*.+,-/89<;?A@CB7456%&0123'#$JKLMNOP=>:QRSTDEFGIHVWNone "$;FHVd˜ä X bytesliceA cons-list of byte sequences.[ byteslice:Concatenate chunks into a single contiguous byte sequence.\ byteslice Variant of [( that returns an unsliced byte sequence.] byteslice,The total number of bytes in all the chunks.^ byteslice˜Copy the contents of the chunks into a mutable array. Precondition: The destination must have enough space to house the contents. This is not checked._ byteslice3Reverse chunks but not the bytes within each chunk.` byteslice Variant of _l that allows the caller to provide an initial list of chunks that the reversed chunks will be pushed onto.a byteslice5Read a handle's entire contents strictly into chunks.b byteslice,Create a list of chunks with a single chunk.c byteslice Variant of b$ where the single chunk is unsliced.d byteslice This uses concat to form an equivalence class.^ byteslice Destination bytesliceDestination offset bytesliceSource byteslice=Returns the next index into the destination after the payload XYZ[\]^_`abc XYZ][\_`bc^an        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[#P\]^_H`abcdefdeghijhklhimhnop(byteslice-0.2.1.0-4zZrBARFvnX30ltfKUiVoeData.Bytes.TypesData.Bytes.Mutable Data.BytesData.Bytes.ChunksData.Bytes.ByteUnmanagedBytes$sel:address:UnmanagedBytes$sel:length:UnmanagedBytes MutableBytes$sel:array:MutableBytes$sel:offset:MutableBytes$sel:length:MutableBytesBytes$sel:array:Bytes$sel:offset:Bytes$sel:length:Bytes $fMonoidBytes$fSemigroupBytes $fOrdBytes $fEqBytes $fShowBytes $fIsListBytes takeWhile dropWhile unsafeTake unsafeDropfromMutableByteArraycountsplitU splitInitUsplit splitNonEmpty splitInitnulllengthunconsunsnocisBytePrefixOfisByteSuffixOf isPrefixOf isSuffixOflongestCommonPrefix singleton doubleton tripleton singletonU doubletonU tripletonU replicate replicateU stripPrefixstripOptionalPrefix stripSuffixstripOptionalSuffixsplit1split2split3elem unsafeIndex dropWhileEnd takeWhileEndfoldlfoldrfoldl'ifoldl'foldr' toByteArraytoByteArrayClonefromAsciiStringfromLatinString toLatinString fromByteArray equalsLatin1 equalsLatin2 equalsLatin3 equalsLatin4 equalsLatin5 equalsLatin6 equalsLatin7 unsafeCopypincontentstouchemptyhGethPutChunks ChunksCons ChunksNilconcatconcatUreverse reverseOnto hGetContents fromBytes $fEqChunks$fMonoidChunks$fSemigroupChunks $fShowChunks(primitive-0.7.0.0-9xMM76CsovTEGnXCHiCdRJData.Primitive.ByteArrayMutableByteArray ByteArraybaseGHC.BaseNonEmpty GHC.MaybeNothingStringGHC.IO.Handle.TypesHandle