h*l~f      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|} ~                                                0.2.14.0  Safe-InferredA Safe-Inferredk Safe-Inferred %1 byteslice A slice of a . Safe-Inferred Safe-Inferred*1&  Safe-Inferred %018  bytesliceA slice of unmanaged memory. byteslice A slice of a . bytesliceA  whose compile-time-known length is represented by a phantom type variable. Consumers of this data constructor must be careful to preserve the expected invariant. byteslice A slice of a  whose compile-time-known length is represented by a phantom type variable. Consumers of this data constructor must be careful to preserve the expected invariant.     Safe-Inferred-T& bytesliceThe empty byte sequence.  bytesliceThe empty pinned byte sequence.! bytesliceThe empty pinned byte sequence." bytesliceYields a pinned byte sequence whose contents are identical to those of the original byte sequence. If the  ByteArray backing the argument was already pinned, this simply aliases the argument and does not perform any copying.# bytesliceConvert the sliced  to an unsliced +. This reuses the array backing the sliced  if the slicing metadata implies that all of the bytes are used. Otherwise, it makes a copy.$ byteslice Variant of # that unconditionally makes a copy of the array backing the sliced 4 even if the original array could be reused. Prefer #.% 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.& bytesliceCreate a slice of & that spans the entire argument array.' bytesliceCreate a slice of  that spans the entire  of 8-bit words.( bytesliceThe length of a slice of bytes.) byteslice1Hash byte sequence with 32-bit variant of FNV-1a.* byteslice1Hash byte sequence with 64-bit variant of FNV-1a.+ byteslice4Left fold over bytes, non-strict in the accumulator., byteslice0Left fold over bytes, strict in the accumulator.- byteslice bytesliceIndex into the byte sequence at the given position. This index must be less than the length.? byteslice!Access the first byte. The given  must be non-empty.@ bytesliceConvert the sliced  to an unsliced +. This reuses the array backing the sliced  if the slicing metadata implies that all of the bytes are used. Otherwise, it makes a copy.A bytesliceReplicate a byte n times.B byteslice Variant of A$ that returns a unsliced byte array.E bytesliceO(n) Returns true if any byte in the sequence satisfies the predicate.F bytesliceO(n) Returns true if all bytes in the sequence satisfy the predicate.% byteslice Destination bytesliceDestination Offset bytesliceSourceA bytesliceDesired length n bytesliceByte to replicate* !"2%#$34&'(-1+,./0)*56789=>?;:<@ABCDEF Safe-InferredG byteslice Convert a  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 replaced by an unspecified byte.H byteslice8Interpret a byte sequence as text encoded by ISO-8859-1.I bytesliceIs the byte sequence, when interpreted as ISO-8859-1-encoded text, a singleton whose element matches the character?J bytesliceIs the byte sequence, when interpreted as ISO-8859-1-encoded text, a doubleton whose elements match the characters?K bytesliceIs the byte sequence, when interpreted as ISO-8859-1-encoded text, a tripleton whose elements match the characters?L bytesliceIs the byte sequence, when interpreted as ISO-8859-1-encoded text, a quadrupleton whose elements match the characters?M bytesliceIs the byte sequence, when interpreted as ISO-8859-1-encoded text, a quintupleton whose elements match the characters?N bytesliceIs the byte sequence, when interpreted as ISO-8859-1-encoded text, a sextupleton whose elements match the characters?O bytesliceIs the byte sequence, when interpreted as ISO-8859-1-encoded text, a septupleton whose elements match the characters?P bytesliceIs the byte sequence, when interpreted as ISO-8859-1-encoded text, an octupleton whose elements match the characters?Q bytesliceIs the byte sequence, when interpreted as ISO-8859-1-encoded text, a 9-tuple whose elements match the characters?R bytesliceIs the byte sequence, when interpreted as ISO-8859-1-encoded text, a 10-tuple whose elements match the characters?S bytesliceIs the byte sequence, when interpreted as ISO-8859-1-encoded text, a 11-tuple whose elements match the characters?T bytesliceIs the byte sequence, when interpreted as ISO-8859-1-encoded text, a 12-tuple whose elements match the characters?X bytesliceDecode machine-sized word from decimal representation. Returns Nothing on overflow. Allows any number of leading zeros. Trailing non-digit bytes cause Nothing to be returned.HGXIJKLMNOPQRSTUVWHGXIJKLMNOPQRSTUVW Safe-Inferred" Y byteslice Convert a  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.\ bytesliceInterpret byte sequence as ASCII codepoints. Only available when building with text-2.0 and newer. Returns / if any of the bytes are outside of the range  0x00-0x7F] byteslice"Is the byte sequence equal to the NUL6-terminated C String? The C string must be a constant.YX]Z[\YX]Z[\ Safe-Inferred$^ bytesliceTake bytes while the predicate is true, aliasing the argument array._ bytesliceDrop bytes while the predicate is true, aliasing the argument array.` bytesliceTake the first n& bytes from the argument, aliasing it.a bytesliceDrop the first n> bytes from the argument, aliasing it. The new length will be len - n.b bytesliceCreate a slice of  that spans the entire argument array. This aliases the argument.^_`ab^_`ab Safe-Inferred-%2c bytesliceRead  directly from the specified . The resulting & are pinned. This is implemented with .d bytesliceOutputs  to the specified . This is implemented with .cd Safe-Inferred&e byteslice*Encode a 32-bit signed integer as 4 bytes.f byteslice,Encode a 32-bit unsigned integer as 4 bytes.g byteslice*Encode a 16-bit signed integer as 4 bytes.h byteslice,Encode a 16-bit unsigned integer as 4 bytes.i byteslice*Encode a 16-bit signed integer as 4 bytes.j byteslice,Encode a 16-bit unsigned integer as 4 bytes.hfjgeihfjgei Safe-Inferred(Wk byteslice*Encode a 32-bit signed integer as 4 bytes.l byteslice,Encode a 32-bit unsigned integer as 4 bytes.m byteslice*Encode a 16-bit signed integer as 4 bytes.n byteslice,Encode a 16-bit unsigned integer as 4 bytes.o byteslice*Encode a 16-bit signed integer as 4 bytes.p byteslice,Encode a 16-bit unsigned integer as 4 bytes.nlpmkonlpmkoNone '-3 q byteslice;Count the number of times the byte appears in the sequence.r byteslice Variant of t: that returns an array of unsliced byte sequences. Unlike t, this is not a good producer for list fusion. (It does not return a list, so it could not be.) Prefer t if the result is going to be consumed exactly once by a good consumer. Prefer r if the result of the split is going to be around for a while and inspected multiple times.s byteslice Variant of r& that drops the trailing element. See w. for an explanation of why this may be useful.t bytesliceBreak 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_, foldlM4, 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.u byteslice Variant of t6 that intended for use with stream fusion rather than build-foldr fusion.v byteslice Variant of t that returns the result as a  instead of []*. This is also eligible for stream fusion.w byteslice Variant of t 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.  https://pubs.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap03.html#tag_03_392POSIX mandates that text files end with a newline, so the list resulting from t= always has an empty byte sequence as its last element. With w%, that unwanted element is discarded.x bytesliceSplit 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])y bytesliceSplit 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])z bytesliceSplit 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]){ bytesliceSplit a byte sequence on the first, second, third, and fourth occurrences of the target byte. The target is removed from the result. For example:(split4 0xA [0x1,0x2,0xA,0xB,0xA,0xA,0xA]Just ([0x1,0x2],[0xB],[],[],[])| bytesliceSplit a byte sequence on the last occurrence of the target byte. The target is removed from the result. For example:$split1 0xA [0x1,0x2,0xA,0xB,0xA,0xC]Just ([0x1,0x2,0xA,0xB],[0xC]) qtrvuwsxyz{|  Safe-Inferred;} byteslice over ~ byteslice over  byteslicePerform an action on each line of the input, discarding results. To maintain a running state, see .Lines are extracted with with , which does not document its detection algorithm. As of writing (bytestring v0.11.1.0), lines are delimited by a single n1 character (UNIX-style, as all things should be). byteslicePerform an action on each line of the input, threading state through the computation. If you do not need to keep a state, see .Lines are extracted with with , which does not document its detection algorithm. As of writing (bytestring v0.11.1.0), lines are delimited by a single n1 character (UNIX-style, as all things should be). bytesliceO(n)/ Convert ASCII letters to lowercase. This adds 0x20 to bytes in the range  [0x41,0x5A] (A-Z C a-z) and leaves all other bytes alone. Unconditionally copies the bytes. bytesliceThrows an exception the  argument is non-ascii. bytesliceThrows an exception the  argument is non-ascii. bytesliceThrows an exception the  argument is non-ascii. bytesliceThrows an exception the  argument is non-ascii. byteslice"Throws an exception if any of the  arguments are non-ascii. bytesliceThrows an exception the  argument is non-ascii. bytesliceThrows an exception the  argument is non-ascii. bytesliceThrows an exception the  argument is non-ascii. bytesliceThrows an exception the  argument is non-ascii. bytesliceThrows an exception the  argument is non-ascii.}~}~ Safe-Inferred%'-> byteslice,Replace every non-overlapping occurrence of needle in haystack with  replacement. byteslice/Find locations of non-overlapping instances of needle within haystack. byteslice6Is the first argument an infix of the second argument?-Uses the Rabin-Karp algorithm: expected time O(n+m) , worst-case O(nm). bytesliceneedle, must not be empty byteslice replacement byteslicehaystack bytesliceneedle byteslicehaystack bytesliceString to search for bytesliceString to search in bytesliceString to search for bytesliceString to search in  Safe-Inferred%'Kf bytesliceA cons-list of byte sequences. byteslice%Add a byte sequence to the beginning. bytesliceRepeat the byte sequence over and over. Returns empty chunks when given a negative repetition count. bytesliceRepeat the byte over and over. This builds a single byte array that is at most 64KiB and shares that across every  ChunksCons cell.An as example, creating a 2GiB chunks this way would use 64KiB for the byte array, and there would be the additional overhead of the 2^15  ChunksCons* data constructors. On a 64-bit platform,  ChunksCons: takes 40 bytes, so the total memory consumption would be 2^16 + 40 * 2^15, which is roughly 1.37MB. The same reasoning shows that it takes about 83.95MB to represent a 128GiB chunks.The size of the shared payload is an implementation detail. Do not rely on this function producing 64KiB chunks. The implementation might one day change to something smarter that minimizes the memory footprint for very large chunks. byteslice2Are there any bytes in the chunked byte sequences? byteslice Variant of ? that ensure that the resulting byte sequence is pinned memory. byteslice,Concatenate chunks into a strict bytestring. byteslice:Concatenate chunks into a single contiguous byte sequence. byteslice Variant of ( that returns an unsliced byte sequence. byteslice Variant of / that returns an unsliced pinned byte sequence. byteslice,The total number of bytes in all the chunks. bytesliceCopy 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  that allows the caller to provide an initial list of chunks that the reversed chunks will be pushed onto. byteslice5Read a handle's entire contents strictly into chunks. byteslice5Read a handle's entire contents strictly into chunks. bytesliceRead an entire file strictly into chunks. If reading from a regular file, this makes an effort read the file into a single chunk. byteslice,Create a list of chunks with a single chunk. byteslice Variant of $ where the single chunk is unsliced. bytesliceLeft fold over all bytes in the chunks, strict in the accumulator. byteslice1Hash byte sequence with 32-bit variant of FNV-1a. byteslice1Hash byte sequence with 64-bit variant of FNV-1a. bytesliceOutputs  to the specified . This is implemented with d. bytesliceWrite 8 to a file, replacing the previous contents of the file. bytesliceBreak chunks of bytes into contiguous pieces separated by the byte argument. This is a good producer for list fusion. For this function to perform well, each chunk should contain multiple separators. Any piece that spans multiple chunks must be copied. byteslice This uses concat to form an equivalence class. byteslice'Number of times to repeat the sequence. byteslice%Number of times to replicate the byte byteslice Destination bytesliceDestination offset bytesliceSource byteslice=Returns the next index into the destination after the payload Safe-Inferred %'-1b1 byteslice!Extract the head and tail of the  , returning  if it is empty. byteslice Extract the init and last of the  , returning  if it is empty. bytesliceDoes the byte sequence begin with the given byte? False if the byte sequence is empty. bytesliceDoes 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?%"2#$34&'5678@cd !<(EFAB;:+,.0/-1trwsvuxCyz{|Dq)*=9>?%"2#$34&'5678@cd  Safe-Inferredf bytesliceEncode  using UTF-8. Since  is backed by a UTF-8 byte sequence, this does not perform a copy. bytesliceAttempt to interpret the byte sequence as UTF-8 encoded text. Returns ) if the bytes are not UTF-8 encoded text. bytesliceEncode  using UTF-8%. Only available when building with text-2.0 and newer. Since  is backed by a UTF-8 byte sequence, this does not perform a copy. byteslice&Attempt to interpret byte sequence as UTF-8 encoded %. Only available when building with text-2.1 and newer. Since  is backed by a UTF-8 byte sequence, this does not perform a copy.  !"##$%&''())*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgVhijklmLHnopqrstuvqrstuvwxyz{|}~      ~    R          P  K      7 4      5 ; 8 9 p  z    lm  h  j )byteslice-0.2.14.0-CTUAotiJ5syBA75iKmpPcgData.Bytes.InternalData.Bytes.Types Data.BytesData.Bytes.Text.Latin1Data.Bytes.Text.AsciiData.Bytes.MutableData.Bytes.Encode.LittleEndianData.Bytes.Encode.BigEndianData.Bytes.Text.AsciiExtData.Bytes.ChunksData.Bytes.Text.Utf8 bytesliceCstrlenData.Bytes.Internal.ShowData.Bytes.Text.Windows1252RepsData.Bytes.Pure Data.Bytes.IOData.Bytes.ByteData.Bytes.SearchBytes$sel:array:Bytes$sel:offset:Bytes$sel:length:Bytes $fMonoidBytes$fSemigroupBytes $fOrdBytes $fEqBytes $fShowBytes $fIsListBytesBytes#UnmanagedBytes$sel:address:UnmanagedBytes$sel:length:UnmanagedBytes MutableBytes$sel:array:MutableBytes$sel:offset:MutableBytes$sel:length:MutableBytes ByteArrayN$sel:array:ByteArrayNBytesN$sel:array:BytesN$sel:offset:BytesN $fShowBytesN$fShowByteArrayNempty emptyPinned emptyPinnedUpin toByteArraytoByteArrayClone unsafeCopy fromByteArray fromPrimArraylengthfnv1a32fnv1a64foldlfoldl'foldlMfoldrifoldl'foldr'foldrMcontentstoPinnedByteArraytoPinnedByteArrayClone toByteStringpinnedToByteStringfromByteStringfromLazyByteString unsafeDropmapUmapnull unsafeTake unsafeIndex unsafeHeadtoShortByteString replicate replicateUsplitTetragram1findTetragramIndexanyall fromStringtoStringequals1equals2equals3equals4equals5equals6equals7equals8equals9equals10equals11equals12equals13equals14equals15 decodeDecWord toShortText toShortTextUtoTextequalsCStringCaseInsensitive takeWhile dropWhilefromMutableByteArrayhGethPutint32word32int16word16int64word64countsplitU splitInitUsplit splitStream splitNonEmpty splitInitsplit1split2split3split4 splitEnd1 forLines_ foldLines hForLines_ hFoldLinestoLowerUdropWhileNotEqtakeWhileNotEqtakeWhileEndNotEqdropWhileEndEqanyEqreplace findIndices isInfixOfChunks ChunksCons ChunksNilcons replicateByte concatPinnedconcatByteStringconcatconcatU concatPinnedUreverse reverseOnto hGetContentsreadFile fromBytes writeFile $fEqChunks$fMonoidChunks$fSemigroupChunks $fShowChunksunconsunsnocisBytePrefixOfisByteSuffixOf isPrefixOf isSuffixOflongestCommonPrefix singleton doubleton tripleton singletonU doubletonU tripletonU stripPrefixstripOptionalPrefix stripSuffixstripOptionalSuffixelem dropWhileEnd takeWhileEndfromAsciiStringfromLatinString toLatinString fromCString# equalsLatin1 equalsLatin2 equalsLatin3 equalsLatin4 equalsLatin5 equalsLatin6 equalsLatin7 equalsLatin8 equalsLatin9 equalsLatin10 equalsLatin11 equalsLatin12 equalsCStringstripCStringPrefixtouch intercalateintercalateByte2toShortByteStringClonefromShortByteString fromShortTexttoLowerAsciiByteArrayCloneliftunlift concatArrayU concatArray withLength withLengthUfromTextghc-prim GHC.CStringcstringLength# showsSlicebaseData.Array.Byte ByteArrayGHC.Prim word8ToWord#MutableByteArray(primitive-0.9.0.0-2Ut0u6h4ou624O572IFc4SData.Primitive.PrimArray PrimArray*bytestring-0.12.2.0-DYd1yUTywj4J0IGT3WPznuData.ByteString.Internal.Type ByteStringData.ByteString.Short.InternalShortByteString countWhile countWhileEndGHC.BaseString GHC.MaybeNothingGHC.IO.Handle.TypesHandleGHC.IO.Handle.TexthGetBufhPutBufNonEmptyelemIndexLoop#GHC.IO.StdHandlesstdinData.ByteString.Char8hGetLine GHC.TypesCharbreakSubstringhGetContentsHint'text-short-0.1.6-LpYDzMmrwZTDCn3hcryAJ5Data.Text.Short.Internal ShortText!text-2.1.2-HpFCCJ7g1i1EgIdwpKMF9rData.Text.InternalText