y$e      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdportable experimentaldons@cse.unsw.edu.auportable experimentalDon Stewart <dons@galois.com> DA space-efficient representation of a Word8 vector, supporting many  efficient operations. A  ! contains 8-bit characters only. 1Instances of Eq, Ord, Read, Show, Data, Typeable eO(n) Converts a   to a '[a]', using a conversion function. fO(n) Convert a '[a]' into a   using some  conversion function 6The 0 pointer. Used to indicate the empty Bytestring. O(1)& Build a ByteString from a ForeignPtr O(1), Deconstruct a ForeignPtr from a ByteString 8A way of creating ByteStrings outside the IO monad. The Int 9 argument gives the final size of the ByteString. Unlike  5 the ByteString is not reallocated if the final size " is less than the estimated size. Create ByteString of size l and use action f to fill it' s contents. BGiven the maximum size needed and a function to make the contents * of a ByteString, createAndTrim makes the  . The generating 7 function is required to return the actual final size (<= the maximum @ size), and the resulting byte array is realloced to this size. CcreateAndTrim is the main mechanism for creating custom, efficient G ByteString functions, using Haskell or C functions to fill the space. <Wrapper of mallocForeignPtrBytes with faster implementation ! for GHC 6.5 builds newer than 060606 Conversion between g  and h . Should compile to a no-op. Unsafe conversion between h  and g . This is a no-op and & silently truncates to 8 bits Chars > '\255'. It is provided as * convenience for ByteString construction. KSelects words corresponding to white-space characters in the Latin-1 range  ordered by frequency. 4Selects white-space characters in the Latin-1 range FJust like unsafePerformIO, but we inline it. Big performance gains as 0 it exposes lots of things to further inlining.  Very unsafe. In : particular, you should do no memory allocation inside an   block. On Hugs this is just unsafePerformIO.       portable experimental#dons@galois.com, duncan@haskell.org DA space-efficient representation of a Word8 vector, supporting many  efficient operations. A ! contains 8-bit characters only. 1Instances of Eq, Ord, Read, Show, Data, Typeable The data type invariant:  Every ByteString is either  or consists of non-null  s. J All functions must preserve this, and the QC properties must check this. ,In a form that checks the invariant lazily. Smart constructor for &. Guarantees the data type invariant. !CConsume the chunks of a lazy ByteString with a natural right fold. "GConsume the chunks of a lazy ByteString with a strict, tail-recursive,  accumulating left fold. #:Currently set to 32k, less the memory management overhead $9Currently set to 4k, less the memory management overhead %FThe memory management overhead. Currently this is tuned for GHC only.  !"#$%  !"#$%  !"#$%portable experimental(dons@cse.unsw.edu.au, duncan@haskell.org& A variety of i  for non-empty ByteStrings. & omits the G check for the empty case, so there is an obligation on the programmer 6 to provide a proof that the ByteString is non-empty. ' A variety of j  for non-empty ByteStrings. ' omits the # check for the empty case. As with &, the programmer must < provide a separate proof that the ByteString is non-empty. (Unsafe  : index (subscript) operator, starting from 0, returning a g  C This omits the bounds check, which means there is an accompanying G obligation on the programmer to ensure the bounds are checked in some  other way. ) A variety of k  which omits the checks on n so there is an 6 obligation on the programmer to provide a proof that 0 <= n <= l  xs. * A variety of m  which omits the checks on n so there is an 6 obligation on the programmer to provide a proof that 0 <= n <= l  xs. +O(n)< Pack a null-terminated sequence of bytes, pointed to by an  Addr#< (an arbitrary machine address assumed to point outside the  garbage-collected heap) into a  ByteString. A much faster way to  create an Addr#3 is with an unboxed string literal, than to pack a @ boxed string. A unboxed string literal is compiled to a static char  []B by GHC. Establishing the length of the string requires a call to   strlen(3) , so the Addr#, must point to a null-terminated buffer (as  is the case with string# literals in GHC). Use , 2 if you know the length of the string statically.  An example:  * literalFS = unsafePackAddress "literal"# This function is unsafe-. If you modify the buffer pointed to by the  original Addr#6 this modification will be reflected in the resulting   ByteString%, breaking referential transparency. Note this also won't work if you Add# has embedded '\0' characters in  the string (strlen will fail). ,O(1) ,( provides constant-time construction of   ByteStrings0 which is ideal for string literals. It packs a * null-terminated sequence of bytes into a  , given a raw  'Addr\#'. to the string, and the length of the string. This function is unsafe in two ways: = the length argument is assumed to be correct. If the length B argument is incorrect, it is possible to overstep the end of the  byte array.  if the underying Addr#( is later modified, this change will be  reflected in resulting  ByteString, breaking referential  transparency. If in doubt, don't use these functions. -O(1) Construct a  " given a Ptr Word8 to a buffer, a E length, and an IO action representing a finalizer. This function is  not available on Hugs. This function is unsafe&, it is possible to break referential C transparency by modifying the underlying buffer pointed to by the F first argument. Any changes to the original buffer will be reflected  in the resulting  ByteString. ./Explicitly run the finaliser associated with a  . I References to this value after finalisation may generate invalid memory  references. This function is unsafe, as there may be other   ByteStrings4 referring to the same underlying pages. If you use 6 this, you need to have a proof of some kind that all  s C ever generated from the underlying byte array are no longer live. /O(n) Build a  ByteString from a CString. This value will have no B finalizer associated to it, and will not be garbage collected by 4 Haskell. The ByteString length is calculated using  strlen(3),  and thus the complexity is a O(n). This function is unsafe . If the CString is later modified, this + change will be reflected in the resulting  ByteString , breaking  referential transparency. 0O(1) Build a  ByteString from a  CStringLen. This value will  have no7 finalizer associated with it, and will not be garbage * collected by Haskell. This operation has O(1) complexity as we $ already know the final size, so no  strlen(3) is required. This funtion is unsafe. If the original  CStringLen is later : modified, this change will be reflected in the resulting  ByteString, $ breaking referential transparency. 1O(n) Build a  ByteString from a malloced CString. This value will  have a free(3) finalizer associated to it. This funtion is unsafe. If the original CString is later : modified, this change will be reflected in the resulting  ByteString, $ breaking referential transparency. >This function is also unsafe if you call its finalizer twice,  which will result in a  double free error, or if you pass it  a CString not allocated with malloc. 2O(1) construction Use a  ByteString with a function requiring a  CString. 6This function does zero copying, and merely unwraps a  ByteString to  appear as a CString. It is unsafe in two ways: ! After calling this function the CString shares the underlying  byte buffer with the original  ByteString. Thus modifying the  CString=, either in C, or using poke, will cause the contents of the   ByteString5 to change, breaking referential transparency. Other   ByteStrings0 created by sharing (such as those produced via k   or m 1) will also reflect these changes. Modifying the CString 9 will break referential transparency. To avoid this, use   useAsCString%, which makes a copy of the original  ByteString.  CStrings7 are often passed to functions that require them to be " null-terminated. If the original  ByteString wasn't null terminated,  neither will the CString* be. It is the programmers responsibility  to guarantee that the  ByteString" is indeed null terminated. If in  doubt, use  useAsCString. 3O(1) construction Use a  ByteString with a function requiring a   CStringLen. 6This function does zero copying, and merely unwraps a  ByteString to  appear as a  CStringLen. It is unsafe: ! After calling this function the  CStringLen shares the underlying  byte buffer with the original  ByteString. Thus modifying the   CStringLen=, either in C, or using poke, will cause the contents of the   ByteString5 to change, breaking referential transparency. Other   ByteStrings0 created by sharing (such as those produced via k   or m 1) will also reflect these changes. Modifying the  CStringLen 9 will break referential transparency. To avoid this, use  useAsCStringLen%, which makes a copy of the original  ByteString. &'()*+,-./0123&'()*23/01+,-.&'()*+,-./0123portable experimentaldons@cse.unsw.edu.auknO(n) Equality on the   type.  still needed oO(n) o provides an p  for  ByteStrings supporting slices. 4O(1) The empty   5O(1) Convert a g  into a   6O(n) Convert a '[Word8]' into a  . FFor applications with large numbers of string literals, pack can be a C bottleneck. In such cases, consider using packAddress (GHC only). 7O(n) Converts a   to a '[Word8]'. 8O(1)% Test whether a ByteString is empty. 9O(1) 9* returns the length of a ByteString as an q . :O(n) :1 is analogous to (:) for lists, but of different & complexity, as it requires a memcpy. ;O(n) Append a byte to the end of a   <O(1)E Extract the first element of a ByteString, which must be non-empty. A An exception will be thrown in the case of an empty ByteString. =O(1)O Extract the elements after the head of a ByteString, which must be non-empty. A An exception will be thrown in the case of an empty ByteString. >O(1)> Extract the head and tail of a ByteString, returning Nothing  if it is empty. ?O(1)O Extract the last element of a ByteString, which must be finite and non-empty. A An exception will be thrown in the case of an empty ByteString. @O(1) Return all the elements of a   except the last one. A An exception will be thrown in the case of an empty ByteString. AO(n) Append two ByteStrings BO(n) B f xs( is the ByteString obtained by applying f to each  element of xs,. This function is subject to array fusion. CO(n) C xs% efficiently returns the elements of xs in reverse order. DO(n) The D function takes a g  and a    and ` intersperses'# that byte between the elements of  the  2. It is analogous to the intersperse function on  Lists. EThe E1 function transposes the rows and columns of its    argument. FF<, applied to a binary operator, a starting value (typically C the left-identity of the operator), and a ByteString, reduces the ; ByteString using the binary operator, from left to right. *This function is subject to array fusion. G 'foldl\'' is like F!, but strict in the accumulator. I However, for ByteStrings, all left folds are strict in the accumulator. HH1, applied to a binary operator, a starting value C (typically the right-identity of the operator), and a ByteString, G reduces the ByteString using the binary operator, from right to left. I 'foldr\'' is like H!, but strict in the accumulator. JJ is a variant of F that has no starting value 1 argument, and thus must be applied to non-empty  ByteStrings. , This function is subject to array fusion. A An exception will be thrown in the case of an empty ByteString. K 'foldl1\'' is like J!, but strict in the accumulator. A An exception will be thrown in the case of an empty ByteString. LL is a variant of H& that has no starting value argument, ' and thus must be applied to non-empty  s A An exception will be thrown in the case of an empty ByteString. M 'foldr1\'' is a variant of L, but is strict in the  accumulator. NO(n)$ Concatenate a list of ByteStrings. OMap a function over a   and concatenate the results PO(n)* Applied to a predicate and a ByteString, P determines if  any element of the   satisfies the predicate. QO(n) Applied to a predicate and a  , Q determines  if all elements of the   satisfy the predicate. RO(n) R" returns the maximum value from a    This function will fuse. A An exception will be thrown in the case of an empty ByteString. SO(n) S" returns the minimum value from a    This function will fuse. A An exception will be thrown in the case of an empty ByteString. TThe T( function behaves like a combination of B and  F9; it applies a function to each element of a ByteString, G passing an accumulating parameter from left to right, and returning a = final value of this accumulator together with the new list. UThe U( function behaves like a combination of B and  H9; it applies a function to each element of a ByteString, G passing an accumulating parameter from right to left, and returning a C final value of this accumulator together with the new ByteString. VV is similar to F#, but returns a list of successive 8 reduced values from the left. This function will fuse.  B scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...]  Note that & last (scanl f z xs) == foldl f z xs. WW is a variant of V& that has no starting value argument.  This function will fuse. 0 scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...] X*scanr is the right-to-left dual of scanl. YY is a variant of X& that has no starting value argument. ZO(n) Z n x is a ByteString of length n with x 2 the value of every element. The following holds:  0 replicate w c = unfoldr w (\u -> Just (u,u)) c This implemenation uses  memset(3) [O(n), where n# is the length of the result. The [ # function is analogous to the List 'unfoldr'. [ builds a D ByteString from a seed value. The function takes the element and  returns r 4 if it is done producing the ByteString or returns  s  (a,b), in which case, a" is the next byte in the string,  and b+ is the seed value for further production.  Examples: B unfoldr (\x -> if x <= 5 then Just (x, x + 1) else Nothing) 0  == pack [0, 1, 2, 3, 4, 5] \O(n) Like [, \! builds a ByteString from a seed C value. However, the length of the result is limited by the first  argument to \(. This function is more efficient than [ 1 when the maximum length of the result is known. The following equation relates \ and [: . snd (unfoldrN n f s) == take n (unfoldr f s) ]O(1) ] n, applied to a ByteString xs, returns the prefix  of xs of length n, or xs itself if n > 9 xs. ^O(1) ^ n xs returns the suffix of xs after the first n  elements, or [] if n > 9 xs. _O(1) _ n xs is equivalent to (] n xs, ^ n xs). ``, applied to a predicate p and a ByteString xs, 0 returns the longest prefix (possibly empty) of xs of elements that  satisfy p. aa p xs$ returns the suffix remaining after ` p xs. bb p is equivalent to e (t  . p). ;Under GHC, a rewrite rule will transform break (==) into a $ call to the specialised breakByte:  break ((==) x) = breakByte x  break (==x) = breakByte x cc7 breaks its ByteString argument at the first occurence 2 of the specified byte. It is more efficient than b as it is  implemented with  memchr(3). I.e. . break (=='c') "abcd" == breakByte 'c' "abcd" dd behaves like b but from the end of the   breakEnd p == spanEnd (not.p) ee p xs0 breaks the ByteString into two segments. It is  equivalent to (` p xs, a p xs) uu- breaks its ByteString argument at the first C occurence of a byte other than its argument. It is more efficient  than ' span (==)' - span (=='c') "abcd" == spanByte 'c' "abcd" ff behaves like e but from the end of the  .  We have  / spanEnd (not.isSpace) "x y z" == ("x y ","z") and  spanEnd (not . isSpace) ps  == H let (x,y) = span (not.isSpace) (reverse ps) in (reverse y, reverse x) gO(n) Splits a   into components delimited by G separators, where the predicate returns True for a separator element. G The resulting components do not contain the separators. Two adjacent = separators result in an empty component in the output. eg. 4 splitWith (=='a') "aabbaca" == ["","","bb","c",""] # splitWith (=='a') [] == [] hO(n) Break a  # into pieces separated by the byte ) argument, consuming the delimiter. I.e.  . split '\n' "a\nb\nd\ne" == ["a","b","d","e"] 0 split 'a' "aXaXaXa" == ["","X","X","X",""] $ split 'x' "x" == ["",""] and  ! intercalate [c] . split c == id  split == splitWith . (==) CAs for all splitting functions in this library, this function does 1 not copy the substrings, it just constructs new  ByteStrings that  are slices of the original. iThe i3 function takes a ByteString and returns a list of G ByteStrings such that the concatenation of the result is equal to the E argument. Moreover, each sublist in the result contains only equal  elements. For example,  < group "Mississippi" = ["M","i","ss","i","ss","i","pp","i"] It is a special case of j!, which allows the programmer to > supply their own equality test. It is about 40% faster than   groupBy (==) jThe j+ function is the non-overloaded version of i. kO(n) The k function takes a   and a list of   :s and concatenates the list after interspersing the first , argument between each element of the list. vO(n)B intercalateWithByte. An efficient way to join to two ByteStrings ? with a char. Around 4 times faster than the generalised join. lO(1)  . index (subscript) operator, starting from 0. mO(n) The m) function returns the index of the first  element in the given   which is equal to the query  element, or r  if there is no such element. % This implementation uses memchr(3). nO(n) The n( function returns the last index of the  element in the given   which is equal to the query  element, or r , if there is no such element. The following  holds:  elemIndexEnd c xs == 5 (-) (length xs - 1) `fmap` elemIndex c (reverse xs) oO(n) The o function extends m, by returning M the indices of all elements equal to the query element, in ascending order. % This implementation uses memchr(3). pIcount returns the number of times its argument appears in the ByteString   count = length . elemIndices ABut more efficiently than using length on the intermediate list. qThe q" function takes a predicate and a   and : returns the index of the first element in the ByteString  satisfying the predicate. rThe r function extends q, by returning the G indices of all elements satisfying the predicate, in ascending order. sO(n) s is the   membership predicate. tO(n) t is the inverse of s uO(n) u+, applied to a predicate and a ByteString, C returns a ByteString containing those characters that satisfy the 6 predicate. This function is subject to array fusion. vO(n) The v. function takes a predicate and a ByteString, = and returns the first element in matching the predicate, or r   if there is no such element. H find f p = case findIndex f p of Just n -> Just (p ! n) ; _ -> Nothing wO(n) The w5 function takes a predicate a ByteString and returns G the pair of ByteStrings with elements which do and do not satisfy the  predicate, respectively; i.e., 6 partition p bs == (filter p xs, filter (not . p) xs) xO(n) The x, function takes two ByteStrings and returns w  * iff the first is a prefix of the second. yO(n) The y, function takes two ByteStrings and returns w  * iff the first is a suffix of the second. The following holds:  4 isSuffixOf x y == reverse x `isPrefixOf` reverse y FHowever, the real implemenation uses memcmp to compare the end of the ) string only, with no reverse required.. z4Check whether one string is a substring of another.  isInfixOf  p s is equivalent to not (null (findSubstrings p s)). {CBreak a string on a substring, returning a pair of the part of the 8 string prior to the match, and the rest of the string. "The following relationships hold:  2 break (== c) l == breakSubstring (singleton c) l and:   findSubstring s l ==  if null s then Just 0 . else case breakSubstring s l of 4 (x,y) | null y -> Nothing < | otherwise -> Just (length x) 8For example, to tokenise a string, dropping delimiters:  J tokenise x y = h : if null t then [] else tokenise x (drop (length x) t) & where (h,t) = breakSubstring x y ,To skip to the first occurence of a string:   snd (breakSubstring x y) 2To take the parts of a string before a delimiter:  fst (breakSubstring x y) |6Get the first index of a substring in another string,  or r  if the string is not found.  findSubstring p s is equivalent to  listToMaybe (findSubstrings p s). }?Find the indexes of all (possibly overlapping) occurances of a  substring in a string. ~O(n) ~- takes two ByteStrings and returns a list of A corresponding pairs of bytes. If one input ByteString is short, A excess elements of the longer ByteString are discarded. This is  equivalent to a pair of 7 operations.  generalises ~' by zipping with the function given as B the first argument, instead of a tupling function. For example,   (+)6 is applied to two ByteStrings to produce the list of  corresponding sums. x:A specialised version of zipWith for the common case of a F simultaneous map over two bytestrings, to build a 3rd. Rewrite rules 6 are used to automatically covert zipWith into zipWith' when a pack is % performed on the result of zipWith. O(n) 4 transforms a list of pairs of bytes into a pair of * ByteStrings. Note that this performs two 6 operations. O(n)* Return all initial segments of the given  , shortest first. O(n)( Return all final segments of the given  , longest first. O(n)5 Sort a ByteString efficiently, using counting sort. O(n) construction Use a  ByteString with a function requiring a  null-terminated CString. The CString will be freed % automatically. This is a memcpy(3). O(n) construction Use a  ByteString with a function requiring a  CStringLen.  As for  useAsCString, this function makes a copy of the original  ByteString. O(n). Construct a new  ByteString from a CString. The  resulting  ByteString& is an immutable copy of the original  CString3, and is managed on the Haskell heap. The original  CString must be null terminated. O(n). Construct a new  ByteString from a  CStringLen. The  resulting  ByteString& is an immutable copy of the original  CStringLen.  The  ByteString6 is a normal Haskell value and will be managed on the  Haskell heap. O(n) Make a copy of the   with its own storage. = This is mainly useful to allow the rest of the data pointed  to by the  & to be garbage collected, for example B if a large string has been read in, and only a small part of it ' is needed in the rest of the program. Read a line from stdin. Read a line from a handle  Outputs a   to the specified y . A synonym for hPut, for compatibility 9Write a ByteString to a handle, appending a newline byte Write a ByteString to stdout 7Write a ByteString to stdout, appending a newline byte Read a   directly from the specified y . This : is far more efficient than reading the characters into a z   and then using 6.. First argument is the Handle to read from, E and the second is the number of bytes to read. It returns the bytes  read, up to n, or EOF.  is implemented in terms of { . 7If the handle is a pipe or socket, and the writing end  is closed, $ will behave as if EOF was reached.  hGetNonBlocking is identical to ", except that it will never block M waiting for data to become available, instead it returns only whatever data  is available. ,Read entire handle contents strictly into a  . EThis function reads chunks at a time, doubling the chunksize on each G read. The final buffer is then realloced to the appropriate size. For G files > half of available memory, this may lead to memory exhaustion.  Consider using  in this case. As with 6, the string representation in the file is assumed to  be ISO-8859-1. 7The Handle is closed once the contents have been read,  or if an exception is thrown. CgetContents. Read stdin strictly. Equivalent to hGetContents stdin  The y . is closed after the contents have been read. /The interact function takes a function of type ByteString -> ByteString L as its argument. The entire input from the standard input device is passed M to this function as its argument, and the resulting string is output on the  standard output device. $Read an entire file strictly into a  . This is far more . efficient than reading the characters into a z  and then using  6;. It also may be more efficient than opening the file and - reading it using hGet. Files are read using ' binary mode' on Windows,  for ' text mode') use the Char8 version of this function. Write a   to a file.  Append a   to a file. ||4 is a variant of findIndex, that returns the length < of the string if no element is found, rather than Nothing. }1Perform an operation with a temporary ByteString e 456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~e 4567:;A<>?=@89BCDkEFGJKHILMNOPQRSVWXYTUZ[\]^_`aefbdijhgxyz{|}stvuwlmonqrp~cd456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~portable experimentaldons@cse.unsw.edu.auDO(1) Convert a h  into a   O(n) Convert a z  into a   FFor applications with large numbers of string literals, pack can be a  bottleneck. O(n) Converts a   to a z . O(n) 1 is analogous to (:) for lists, but of different & complexity, as it requires a memcpy. O(n) Append a Char to the end of a   . Similar to  #, this function performs a memcpy. O(1)> Extract the head and tail of a ByteString, returning Nothing  if it is empty. O(1)E Extract the first element of a ByteString, which must be non-empty. O(1)G Extract the last element of a packed string, which must be non-empty. O(n)  f xs( is the ByteString obtained by applying f to each element of xs O(n) The  function takes a Char and a    and ` intersperses'' that Char between the elements of the   9. It is analogous to the intersperse function on Lists. <, applied to a binary operator, a starting value (typically C the left-identity of the operator), and a ByteString, reduces the ; ByteString using the binary operator, from left to right.  'foldl\''/ is like foldl, but strict in the accumulator. 1, applied to a binary operator, a starting value F (typically the right-identity of the operator), and a packed string, J reduces the packed string using the binary operator, from right to left.  'foldr\'' is a strict variant of foldr  is a variant of  that has no starting value 1 argument, and thus must be applied to non-empty  ByteStrings. A strict version of   is a variant of & that has no starting value argument, ' and thus must be applied to non-empty  s A strict variant of foldr1 Map a function over a   and concatenate the results )Applied to a predicate and a ByteString,  determines if  any element of the   satisfies the predicate. Applied to a predicate and a  ,  determines if  all elements of the   satisfy the predicate. " returns the maximum value from a   " returns the minimum value from a   The ( function behaves like a combination of  and  9; it applies a function to each element of a ByteString, G passing an accumulating parameter from left to right, and returning a = final value of this accumulator together with the new list. The ( function behaves like a combination of  and  9; it applies a function to each element of a ByteString, G passing an accumulating parameter from right to left, and returning a C final value of this accumulator together with the new ByteString.  is similar to #, but returns a list of successive  reduced values from the left:  B scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...]  Note that & last (scanl f z xs) == foldl f z xs.  is a variant of & that has no starting value argument: 0 scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...] *scanr is the right-to-left dual of scanl.  is a variant of & that has no starting value argument. O(n)  n x is a ByteString of length n with x 2 the value of every element. The following holds:  0 replicate w c = unfoldr w (\u -> Just (u,u)) c This implemenation uses  memset(3) O(n), where n# is the length of the result. The  # function is analogous to the List 'unfoldr'.  builds a D ByteString from a seed value. The function takes the element and  returns r 4 if it is done producing the ByteString or returns  s  (a,b), in which case, a' is the next character in the string,  and b+ is the seed value for further production.  Examples: T unfoldr (\x -> if x <= '9' then Just (x, succ x) else Nothing) '0' == "0123456789" O(n) Like , ! builds a ByteString from a seed C value. However, the length of the result is limited by the first  argument to (. This function is more efficient than  1 when the maximum length of the result is known. The following equation relates  and : ( unfoldrN n f s == take n (unfoldr f s) , applied to a predicate p and a ByteString xs, 0 returns the longest prefix (possibly empty) of xs of elements that  satisfy p.  p xs$ returns the suffix remaining after  p xs.  p is equivalent to  (t  . p). ~~7 breaks its ByteString argument at the first occurence 2 of the specified char. It is more efficient than  as it is  implemented with  memchr(3). I.e. . break (=='c') "abcd" == breakChar 'c' "abcd"  p xs0 breaks the ByteString into two segments. It is  equivalent to ( p xs,  p xs)  behaves like  but from the end of the  .  We have  / spanEnd (not.isSpace) "x y z" == ("x y ","z") and  spanEnd (not . isSpace) ps  == H let (x,y) = span (not.isSpace) (reverse ps) in (reverse y, reverse x)  behaves like  but from the end of the   breakEnd p == spanEnd (not.p) O(n) Break a  # into pieces separated by the byte ) argument, consuming the delimiter. I.e.  . split '\n' "a\nb\nd\ne" == ["a","b","d","e"] 0 split 'a' "aXaXaXa" == ["","X","X","X",""] $ split 'x' "x" == ["",""] and  ! intercalate [c] . split c == id  split == splitWith . (==) CAs for all splitting functions in this library, this function does 1 not copy the substrings, it just constructs new  ByteStrings that  are slices of the original. O(n) Splits a   into components delimited by G separators, where the predicate returns True for a separator element. G The resulting components do not contain the separators. Two adjacent = separators result in an empty component in the output. eg. 4 splitWith (=='a') "aabbaca" == ["","","bb","c",""] The + function is the non-overloaded version of i. O(1)  . index (subscript) operator, starting from 0. O(n) The ) function returns the index of the first  element in the given  # which is equal (by memchr) to the  query element, or r  if there is no such element. O(n) The ( function returns the last index of the  element in the given   which is equal to the query  element, or r , if there is no such element. The following  holds:  elemIndexEnd c xs == 5 (-) (length xs - 1) `fmap` elemIndex c (reverse xs) O(n) The  function extends , by returning M the indices of all elements equal to the query element, in ascending order. The " function takes a predicate and a   and T returns the index of the first element in the ByteString satisfying the predicate. The  function extends , by returning the G indices of all elements satisfying the predicate, in ascending order. Icount returns the number of times its argument appears in the ByteString   count = length . elemIndices Also   count '\n' == length . lines ABut more efficiently than using length on the intermediate list. O(n)  is the   membership predicate. This  implementation uses  memchr(3). O(n)  is the inverse of  O(n) +, applied to a predicate and a ByteString, C returns a ByteString containing those characters that satisfy the  predicate. O(n) The . function takes a predicate and a ByteString, = and returns the first element in matching the predicate, or r   if there is no such element. O(n) - takes two ByteStrings and returns a list of A corresponding pairs of Chars. If one input ByteString is short, A excess elements of the longer ByteString are discarded. This is  equivalent to a pair of  operations, and so space 3 usage may be large for multi-megabyte ByteStrings  generalises ' by zipping with the function given as B the first argument, instead of a tupling function. For example,   (+)3 is applied to two ByteStrings to produce the list  of corresponding sums. 4 transforms a list of pairs of Chars into a pair of * ByteStrings. Note that this performs two  operations.  A variety of  for non-empty ByteStrings.  omits B the check for the empty case, which is good for performance, but F there is an obligation on the programmer to provide a proof that the  ByteString is non-empty. 6 returns the pair of ByteStrings when the argument is + broken at the first whitespace byte. I.e.  break isSpace == breakSpace  efficiently returns the   argument with E white space Chars removed from the front. It is more efficient than 1 calling dropWhile for removing whitespace. I.e.  dropWhile isSpace == dropSpace 6 breaks a ByteString up into a list of ByteStrings at ? newline Chars. The resulting strings do not contain newlines.  is an inverse operation to . It joins lines, 0 after appending a terminating newline to each. 4 breaks a ByteString up into a list of words, which 3 were delimited by Chars representing white space. The  function is analogous to the  function, on words. KreadInt reads an Int from the beginning of the ByteString. If there is no G integer at the beginning of the string, it returns Nothing, otherwise ; it just returns the int read, and the rest of the string. GreadInteger reads an Integer from the beginning of the ByteString. If I there is no integer at the beginning of the string, it returns Nothing, E otherwise it just returns the int read, and the rest of the string. $Read an entire file strictly into a  . This is far more . efficient than reading the characters into a z  and then using  ;. It also may be more efficient than opening the file and  reading it using hGet. Write a   to a file.  Append a   to a file. i 489=@ACEN]^_ikxyz{|}i 4A=@89CkEN]^_ixyz{|}@portable experimentaldons@galois.comXO(1) The empty  O(1) Convert a g  into a  O(n) Convert a '[Word8]' into a . O(n) Converts a  to a '[Word8]'. O(c) Convert a list of strict  into a lazy  O(n) Convert a lazy  into a list of strict  O(1)% Test whether a ByteString is empty. O(n\c)/ * returns the length of a ByteString as an   O(1)  is analogous to '(:)' for lists. O(1) Unlike , 'cons\'' is N strict in the ByteString that we are consing onto. More precisely, it forces N the head and the first chunk. It does this because, for space efficiency, it * may coalesce the new byte onto the first 'chunk' rather than starting a  new 'chunk'. So that means you can'.t use a lazy recursive contruction like this:   let xs = cons\' c xs in xs You can however use  , as well as  and  , to build  infinite lazy ByteStrings. O(n\c)/ Append a byte to the end of a  O(1)E Extract the first element of a ByteString, which must be non-empty. O(1)> Extract the head and tail of a ByteString, returning Nothing  if it is empty. O(1)D Extract the elements after the head of a ByteString, which must be  non-empty. O(n\c)/@ Extract the last element of a ByteString, which must be finite  and non-empty. O(n\c)/ Return all the elements of a  except the last one. O(n\c)/ Append two ByteStrings O(n)  f xs( is the ByteString obtained by applying f to each  element of xs. O(n)  xs returns the elements of xs in reverse order. The  function takes a g  and a  and  ` intersperses'' that byte between the elements of the . 7 It is analogous to the intersperse function on Lists. The 1 function transposes the rows and columns of its   argument. <, applied to a binary operator, a starting value (typically C the left-identity of the operator), and a ByteString, reduces the ; ByteString using the binary operator, from left to right.  'foldl\'' is like !, but strict in the accumulator. 1, applied to a binary operator, a starting value C (typically the right-identity of the operator), and a ByteString, G reduces the ByteString using the binary operator, from right to left.  is a variant of  that has no starting value 1 argument, and thus must be applied to non-empty  ByteStrings. + This function is subject to array fusion.  'foldl1\'' is like !, but strict in the accumulator.  is a variant of & that has no starting value argument, ' and thus must be applied to non-empty s O(n)$ Concatenate a list of ByteStrings. Map a function over a  and concatenate the results O(n)* Applied to a predicate and a ByteString,  determines if  any element of the  satisfies the predicate. O(n) Applied to a predicate and a ,  determines  if all elements of the  satisfy the predicate. O(n) " returns the maximum value from a  O(n) " returns the minimum value from a  The ( function behaves like a combination of  and  9; it applies a function to each element of a ByteString, G passing an accumulating parameter from left to right, and returning a C final value of this accumulator together with the new ByteString. The ( function behaves like a combination of  and  9; it applies a function to each element of a ByteString, G passing an accumulating parameter from right to left, and returning a C final value of this accumulator together with the new ByteString.  is similar to #, but returns a list of successive 8 reduced values from the left. This function will fuse.  B scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...]  Note that & last (scanl f z xs) == foldl f z xs.  f x9 returns an infinite ByteString of repeated applications  of f to x: ' iterate f x == [x, f x, f (f x), ...]  x! is an infinite ByteString, with x the value of every  element. O(n)  n x is a ByteString of length n with x  the value of every element. @ ties a finite ByteString into a circular one, or equivalently, 5 the infinite repetition of the original ByteString. O(n) The # function is analogous to the List 'unfoldr'.  < builds a ByteString from a seed value. The function takes  the element and returns r  if it is done producing the  ByteString or returns s  (a,b), in which case, a is a " prepending to the ByteString and b" is used as the next element in a  recursive call. O(n\c)/  n, applied to a ByteString xs, returns the prefix  of xs of length n, or xs itself if n >  xs. O(n\c)/  n xs returns the suffix of xs after the first n  elements, or [] if n >  xs. O(n\c)/  n xs is equivalent to ( n xs,  n xs). , applied to a predicate p and a ByteString xs, 0 returns the longest prefix (possibly empty) of xs of elements that  satisfy p.  p xs$ returns the suffix remaining after  p xs.  p is equivalent to  (t  . p).  p xs0 breaks the ByteString into two segments. It is  equivalent to ( p xs,  p xs) O(n) Splits a  into components delimited by G separators, where the predicate returns True for a separator element. G The resulting components do not contain the separators. Two adjacent = separators result in an empty component in the output. eg. 4 splitWith (=='a') "aabbaca" == ["","","bb","c",""] # splitWith (=='a') [] == []  O(n) Break a # into pieces separated by the byte ) argument, consuming the delimiter. I.e.  . split '\n' "a\nb\nd\ne" == ["a","b","d","e"] 0 split 'a' "aXaXaXa" == ["","X","X","X",""] $ split 'x' "x" == ["",""] and  ! intercalate [c] . split c == id  split == splitWith . (==) CAs for all splitting functions in this library, this function does 1 not copy the substrings, it just constructs new  ByteStrings that  are slices of the original.  The  3 function takes a ByteString and returns a list of G ByteStrings such that the concatenation of the result is equal to the E argument. Moreover, each sublist in the result contains only equal  elements. For example,  < group "Mississippi" = ["M","i","ss","i","ss","i","pp","i"] It is a special case of  !, which allows the programmer to ! supply their own equality test.  The  + function is the non-overloaded version of  .  O(n) The   function takes a  and a list of  :s and concatenates the list after interspersing the first , argument between each element of the list.  O(c) . index (subscript) operator, starting from 0. O(n) The ) function returns the index of the first  element in the given  which is equal to the query  element, or r  if there is no such element. % This implementation uses memchr(3). O(n) The  function extends , by returning M the indices of all elements equal to the query element, in ascending order. % This implementation uses memchr(3). Icount returns the number of times its argument appears in the ByteString   count = length . elemIndices ABut more efficiently than using length on the intermediate list. The " function takes a predicate and a  and : returns the index of the first element in the ByteString  satisfying the predicate. O(n) The . function takes a predicate and a ByteString, = and returns the first element in matching the predicate, or r   if there is no such element. H find f p = case findIndex f p of Just n -> Just (p ! n) ; _ -> Nothing The  function extends , by returning the G indices of all elements satisfying the predicate, in ascending order. O(n)  is the  membership predicate. O(n)  is the inverse of  O(n) +, applied to a predicate and a ByteString, C returns a ByteString containing those characters that satisfy the  predicate. O(n) The 5 function takes a predicate a ByteString and returns G the pair of ByteStrings with elements which do and do not satisfy the  predicate, respectively; i.e., 6 partition p bs == (filter p xs, filter (not . p) xs) O(n) The , function takes two ByteStrings and returns w  * iff the first is a prefix of the second. O(n) The , function takes two ByteStrings and returns w  * iff the first is a suffix of the second. The following holds: 4 isSuffixOf x y == reverse x `isPrefixOf` reverse y O(n) - takes two ByteStrings and returns a list of A corresponding pairs of bytes. If one input ByteString is short, A excess elements of the longer ByteString are discarded. This is  equivalent to a pair of  operations.  generalises ' by zipping with the function given as B the first argument, instead of a tupling function. For example,   (+)6 is applied to two ByteStrings to produce the list of  corresponding sums. O(n) 4 transforms a list of pairs of bytes into a pair of * ByteStrings. Note that this performs two  operations. O(n)* Return all initial segments of the given , shortest first. O(n)( Return all final segments of the given , longest first. O(n) Make a copy of the  with its own storage. ? This is mainly useful to allow the rest of the data pointed  to by the & to be garbage collected, for example C if a large string has been read in, and only a small part of it ) is needed in the rest of the program. Read entire handle contents lazily into a  . Chunks  are read on demand, in at most k!-sized chunks. It does not block  waiting for a whole k-sized chunk, so if less than k bytes are F available then they will be returned immediately as a smaller chunk. The handle is closed on EOF. Read n bytes into a , directly from the  specified y , in chunks of size k. hGetNonBlockingN is similar to ", except that it will never block M waiting for data to become available, instead it returns only whatever data - is available. Chunks are read on demand, in k-sized chunks.  Read entire handle contents lazily into a  . Chunks 3 are read on demand, using the default chunk size. /Once EOF is encountered, the Handle is closed. !Read n bytes into a , directly from the specified y . "hGetNonBlocking is similar to !", except that it will never block M waiting for data to become available, instead it returns only whatever data  is available. #Read an entire file lazily into a . 8 The Handle will be held open until EOF is encountered. $Write a  to a file. % Append a  to a file. &9getContents. Equivalent to hGetContents stdin. Will read lazily ' Outputs a  to the specified y . (A synonym for hPut, for compatibility )Write a ByteString to stdout *7Write a ByteString to stdout, appending a newline byte +/The interact function takes a function of type ByteString -> ByteString L as its argument. The entire input from the standard input device is passed M to this function as its argument, and the resulting string is output on the  standard output device. 4 is a variant of findIndex, that returns the length < of the string if no element is found, rather than Nothing. U      !"#$%&'()*+U     &)*+#$% !"'(T      !"#$%&'()*++non-portable (imports Data.ByteString.Lazy) experimentaldons@cse.unsw.edu.au9,O(1) Convert a h  into a  -O(n) Convert a z  into a . .O(n) Converts a  to a z . /O(1) / is analogous to '(:)' for lists. 0O(1) Unlike /, 'cons\'' is N strict in the ByteString that we are consing onto. More precisely, it forces N the head and the first chunk. It does this because, for space efficiency, it * may coalesce the new byte onto the first 'chunk' rather than starting a  new 'chunk'. So that means you can'.t use a lazy recursive contruction like this:   let xs = cons\' c xs in xs You can however use / , as well as F and  , to build  infinite lazy ByteStrings. 1O(n) Append a Char to the end of a  . Similar to  /#, this function performs a memcpy. 2O(1)E Extract the first element of a ByteString, which must be non-empty. 3O(1)> Extract the head and tail of a ByteString, returning Nothing  if it is empty. 4O(1)G Extract the last element of a packed string, which must be non-empty. 5O(n) 5 f xs( is the ByteString obtained by applying f to each element of xs 6O(n) The 6 function takes a Char and a   and ` intersperses'' that Char between the elements of the  9. It is analogous to the intersperse function on Lists. 77<, applied to a binary operator, a starting value (typically C the left-identity of the operator), and a ByteString, reduces the ; ByteString using the binary operator, from left to right. 8 'foldl\''/ is like foldl, but strict in the accumulator. 991, applied to a binary operator, a starting value F (typically the right-identity of the operator), and a packed string, J reduces the packed string using the binary operator, from right to left. :: is a variant of 7 that has no starting value 1 argument, and thus must be applied to non-empty  ByteStrings. ; 'foldl1\'' is like :!, but strict in the accumulator. << is a variant of 9& that has no starting value argument, ' and thus must be applied to non-empty s =Map a function over a  and concatenate the results >)Applied to a predicate and a ByteString, > determines if  any element of the  satisfies the predicate. ?Applied to a predicate and a , ? determines if  all elements of the  satisfy the predicate. @@" returns the maximum value from a  AA" returns the minimum value from a  BB is similar to 7#, but returns a list of successive 8 reduced values from the left. This function will fuse.  B scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...]  Note that & last (scanl f z xs) == foldl f z xs. CThe C( function behaves like a combination of 5 and  79; it applies a function to each element of a ByteString, G passing an accumulating parameter from left to right, and returning a C final value of this accumulator together with the new ByteString. DThe D( function behaves like a combination of 5 and  99; it applies a function to each element of a ByteString, G passing an accumulating parameter from right to left, and returning a C final value of this accumulator together with the new ByteString. EE f x9 returns an infinite ByteString of repeated applications  of f to x: ' iterate f x == [x, f x, f (f x), ...] FF x! is an infinite ByteString, with x the value of every  element. GO(n) G n x is a ByteString of length n with x  the value of every element. HO(n) The H# function is analogous to the List 'unfoldr'.  H< builds a ByteString from a seed value. The function takes  the element and returns r  if it is done producing the  ByteString or returns s  (a,b), in which case, a is a " prepending to the ByteString and b" is used as the next element in a  recursive call. II, applied to a predicate p and a ByteString xs, 0 returns the longest prefix (possibly empty) of xs of elements that  satisfy p. JJ p xs$ returns the suffix remaining after I p xs. KK p is equivalent to L (t  . p). LL p xs0 breaks the ByteString into two segments. It is  equivalent to (I p xs, J p xs) MO(n) Break a # into pieces separated by the byte ) argument, consuming the delimiter. I.e.  . split '\n' "a\nb\nd\ne" == ["a","b","d","e"] - split 'a' "aXaXaXa" == ["","X","X","X"] $ split 'x' "x" == ["",""] and  ! intercalate [c] . split c == id  split == splitWith . (==) CAs for all splitting functions in this library, this function does 1 not copy the substrings, it just constructs new  ByteStrings that  are slices of the original. NO(n) Splits a  into components delimited by G separators, where the predicate returns True for a separator element. G The resulting components do not contain the separators. Two adjacent = separators result in an empty component in the output. eg. 4 splitWith (=='a') "aabbaca" == ["","","bb","c",""] OThe O+ function is the non-overloaded version of  . PO(1) . index (subscript) operator, starting from 0. QO(n) The Q) function returns the index of the first  element in the given # which is equal (by memchr) to the  query element, or r  if there is no such element. RO(n) The R function extends Q, by returning M the indices of all elements equal to the query element, in ascending order. SThe S" function takes a predicate and a  and T returns the index of the first element in the ByteString satisfying the predicate. TThe T function extends S, by returning the G indices of all elements satisfying the predicate, in ascending order. UIcount returns the number of times its argument appears in the ByteString  $ count == length . elemIndices  count '\n' == length . lines ABut more efficiently than using length on the intermediate list. VO(n) V is the  membership predicate. This  implementation uses  memchr(3). WO(n) W is the inverse of V XO(n) X+, applied to a predicate and a ByteString, C returns a ByteString containing those characters that satisfy the  predicate. YO(n) The Y. function takes a predicate and a ByteString, = and returns the first element in matching the predicate, or r   if there is no such element. ZO(n) Z- takes two ByteStrings and returns a list of A corresponding pairs of Chars. If one input ByteString is short, A excess elements of the longer ByteString are discarded. This is  equivalent to a pair of . operations, and so space 3 usage may be large for multi-megabyte ByteStrings [[ generalises Z' by zipping with the function given as B the first argument, instead of a tupling function. For example,  [ (+)3 is applied to two ByteStrings to produce the list  of corresponding sums. \\6 breaks a ByteString up into a list of ByteStrings at ? newline Chars. The resulting strings do not contain newlines. >As of bytestring 0.9.0.3, this function is stricter than its  list cousin. ]] is an inverse operation to \. It joins lines, 0 after appending a terminating newline to each. ^^4 breaks a ByteString up into a list of words, which 7 were delimited by Chars representing white space. And  tokens isSpace = words _The _ function is analogous to the ] function, on words. `?readInt reads an Int from the beginning of the ByteString. If @ there is no integer at the beginning of the string, it returns F Nothing, otherwise it just returns the int read, and the rest of the  string. aGreadInteger reads an Integer from the beginning of the ByteString. If I there is no integer at the beginning of the string, it returns Nothing, E otherwise it just returns the int read, and the rest of the string. bRead an entire file lazily into a . Use ' text mode' " on Windows to interpret newlines cWrite a  to a file. d Append a  to a file. W   !"&')*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdW,-./0123456 78:;9<=>?@ABCDFGEHIJLK OMN\^]_VWYXPQRSTUZ[`a&)*+bcd !"'9,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcd !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~IJKNORPSVXZ[\]^_`acdefghijklmnoptuvyzx|{~HIJKLMNOPRQSTUVWXYZ[\^_`bcdefghijnoqrstuvy{|}~IJKNOPRSVXZ[\^_`cdefgjhinotuvy|{~   P Q q M r         : bytestring-0.9.1.2Data.ByteString.InternalData.ByteString.Lazy.InternalData.ByteString.UnsafeData.ByteStringData.ByteString.Char8Data.ByteString.LazyData.ByteString.Lazy.Char8Data.ByteString.Fusionbase Data.Wordghc-prim GHC.Types Data.List GHC.Ordering Data.Maybe Data.BoolGHC.Bool System.IO Data.CharData.Intmemcpy_ptr_baoffc_count c_minimum c_maximum c_intersperse c_reversememcmpc_free_finalizerc_strlen ByteStringPSnullForeignPtrfromForeignPtr toForeignPtr unsafeCreatecreate createAndTrimcreateAndTrim'mallocByteStringw2cc2w isSpaceWord8 isSpaceChar8inlinePerformIOmemchrmemcpymemsetChunkEmpty invariantcheckInvariantchunk foldrChunks foldlChunksdefaultChunkSizesmallChunkSize chunkOverhead unsafeHead unsafeTail unsafeIndex unsafeTake unsafeDropunsafePackAddressunsafePackAddressLenunsafePackCStringFinalizerunsafeFinalizeunsafePackCStringunsafePackCStringLenunsafePackMallocCStringunsafeUseAsCStringunsafeUseAsCStringLenempty singletonpackunpacknulllengthconssnocheadtailunconslastinitappendmapreverse intersperse transposefoldlfoldl'foldrfoldr'foldl1foldl1'foldr1foldr1'concat concatMapanyallmaximumminimum mapAccumL mapAccumRscanlscanl1scanrscanr1 replicateunfoldrunfoldrNtakedropsplitAt takeWhile dropWhilebreak breakBytebreakEndspanspanEnd splitWithsplitgroupgroupBy intercalateindex elemIndex elemIndexEnd elemIndicescount findIndex findIndiceselemnotElemfilterfind partition isPrefixOf isSuffixOf isInfixOfbreakSubstring findSubstringfindSubstringszipzipWithunzipinitstailssort useAsCStringuseAsCStringLen packCStringpackCStringLencopygetLinehGetLinehPuthPutStr hPutStrLnputStrputStrLnhGethGetNonBlocking hGetContents getContentsinteractreadFile writeFile appendFilelinesunlineswordsunwordsreadInt readInteger fromChunkstoChunkscons'iteraterepeatcycle unpackWithpackWithGHC.WordWord8CharGHC.Listeq compareBytesOrderingIntNothingJust GHC.ClassesnotspanByteintercalateWithByteTruezipWith' GHC.IOBaseHandleGHC.BaseStringGHC.IOhGetBuffindIndexOrEndwithPtr breakChar breakSpace dropSpaceGHC.IntInt64 hGetContentsNhGetNhGetNonBlockingN