!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~portable experimentaldons@cse.unsw.edu.aum: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, but we also export it for  convenience. ff generalises ' by zipping with the function given as B the first argument, instead of a tupling function. For example,  f (+)6 is applied to two ByteStrings to produce the list of  corresponding sums. - 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" gg p xs0 breaks the ByteString into two segments. It is  equivalent to ( p xs,  p xs) O(n)B intercalateWithByte. An efficient way to join to two ByteStrings ? with a char. Around 4 times faster than the generalised join. hO(1) Convert a   into a  O(n) A first order equivalent of  filter . (==), for the common > case of filtering a single byte. It is more efficient to use   filterByte in this case.   filterByte == filter . (==) DfilterByte is around 10x faster, and uses much less space, than its  filter equivalent iO(n) i+, 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. 7 breaks its ByteString argument at the first occurence 2 of the specified byte. It is more efficient than q as it is  implemented with  memchr(3). I.e. . break (=='c') "abcd" == breakByte 'c' "abcd" O(n) Equality on the  type. jO(n) Append two ByteStrings k4Check whether one string is a substring of another. isSubstringOf  p s is equivalent to not (null (findSubstrings p s)). lThe l" function takes a predicate and a  and : returns the index of the first element in the ByteString  satisfying the predicate. mIcount returns the number of times its argument appears in the ByteString   count = length . elemIndices ABut more efficiently than using length on the intermediate list. nO(n) 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) oO(n) o is the  membership predicate. pO(n) The p function takes a  and a list of  :s and concatenates the list after interspersing the first , argument between each element of the list. qq p is equivalent to g (  . p). rO(n) The r) function returns the index of the first  element in the given  which is equal to the query  element, or   if there is no such element. % This implementation uses memchr(3). 4 is a variant of findIndex, that returns the length < of the string if no element is found, rather than Nothing. sO(n) Like , s! builds a ByteString from a seed C value. However, the length of the result is limited by the first  argument to s(. This function is more efficient than  1 when the maximum length of the result is known. The following equation relates s and : ( unfoldrN n f s == take n (unfoldr f s) t*scanr is the right-to-left dual of scanl. uO(n) u1 is analogous to (:) for lists, but of different & complexity, as it requires a memcpy. vv 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. wO(n) Append a byte to the end of a  xO(1) x* returns the length of a ByteString as an  . yO(1) The empty  z 'foldr\'' is like }!, but strict in the accumulator. {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. |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. }}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. ~ 'foldl\'' is like !, but strict in the accumulator. : Though actually foldl is also strict in the accumulator. <, 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. O(n) Converts a  to a '[Word8]'. O(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). O(n)$ Concatenate a list of ByteStrings. O(1)% Test whether a ByteString is empty. 1Perform an operation with a temporary ByteString O(n)  provides an   for  ByteStrings supporting slices. 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(n)  f xs( is the ByteString obtained by applying f to each  element of xs,. This function is subject to array fusion. O(n)  xs% efficiently returns the elements of xs in reverse order. O(n) The  function takes a   and a   and ` intersperses'# that byte between the elements of  the 2. It is analogous to the intersperse function on  Lists. The 1 function transposes the rows and columns of its   argument.  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. A An exception will be thrown in the case of an empty ByteString.  'foldl1\'' is like !, but strict in the accumulator. A An exception will be thrown in the case of an empty ByteString.  is a variant of }& 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.  'foldr1\'' is a variant of , but is strict in the  accumulator. 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   This function will fuse. A An exception will be thrown in the case of an empty ByteString. O(n) " returns the minimum value from a   This function will fuse. A An exception will be thrown in the case of an empty 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 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. O(n)? map Word8 functions, provided with the index at each position  is a variant of v& that has no starting value argument.  This function will fuse. 0 scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...]  is a variant of t& that has no starting value argument. 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  4 if it is done producing the ByteString or returns    (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(1)  n, applied to a ByteString xs, returns the prefix  of xs of length n, or xs itself if n > x xs. O(1)  n xs returns the suffix of xs after the first n  elements, or [] if n > x 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.  p xs$ returns the suffix remaining after  p xs.  behaves like q but from the end of the  breakEnd p == spanEnd (not.p)  behaves like g 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) 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. It is about 40% faster than   groupBy (==) The + function is the non-overloaded version of . O(1) . index (subscript) operator, starting from 0. O(n) The ( function returns the last index of the  element in the given  which is equal to the query  element, or  , 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 r, by returning M the indices of all elements equal to the query element, in ascending order. % This implementation uses memchr(3). The  function extends l, by returning the G indices of all elements satisfying the predicate, in ascending order. O(n)  is the inverse of o O(n) The . function takes a predicate and a ByteString, = and returns the first element in matching the predicate, or    if there is no such element. H find f p = case findIndex f p of Just n -> Just (p ! n) ; _ -> Nothing 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   * iff the first is a prefix of the second. O(n) The , function takes two ByteStrings and returns   * 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..  Alias of k 6Get the first index of a substring in another string,  or   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 C substring in a string. This function uses the Knuth-Morris-Pratt  string matching algorithm. 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. 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)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  . 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  . This : is far more efficient than reading the characters into a    and then using .  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  . 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   and then using  ;. 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. ffghijklmnopqrstuvwxyz{|}~fyhuwj|{xp~}zvtnsgqkoirlmfportable experimentaldons@cse.unsw.edu.auEO(n) and O(n\c) space A first order equivalent of  filter .  (==)/=, for the common case of filtering a single Char. It is more  efficient to use  filterChar in this case.   filterByte == filter . (==) DfilterChar is around 10x faster, and uses much less space, than its  filter equivalent O(n) +, applied to a predicate and a ByteString, C returns a ByteString containing those characters that satisfy the  predicate.  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  p xs$ returns the suffix remaining after  p xs. 6 returns the pair of ByteStrings when the argument is + broken at the first whitespace byte. I.e.  break isSpace == breakSpace  p is equivalent to  (  . p). O(1) Convert a   into a  O(n) Convert a   into a  FFor applications with large numbers of string literals, pack can be a  bottleneck. 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)  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) Converts a  to a  . 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  O(n)> map Char functions, provided with the index at each position 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), 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  4 if it is done producing the ByteString or returns    (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 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 . 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   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  , 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. O(n)  is the  membership predicate. This  implementation uses  memchr(3). O(n)  is the inverse of  O(n) The . function takes a predicate and a ByteString, = and returns the first element in matching the predicate, or    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. 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   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.  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. kjkpxy{    kyj{xpk    portable experimental(dons@cse.unsw.edu.au, duncan@haskell.orgX A variety of   for non-empty ByteStrings. X 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. Y A variety of   for non-empty ByteStrings. Y omits the # check for the empty case. As with X, the programmer must < provide a separate proof that the ByteString is non-empty. ZUnsafe : index (subscript) operator, starting from 0, returning a   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   which omits the checks on n so there is an 6 obligation on the programmer to provide a proof that 0 <= n <=   xs. \ A variety of   which omits the checks on n so there is an 6 obligation on the programmer to provide a proof that 0 <= n <=   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. ^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. aO(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. bO(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. cO(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  CStringLen 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. dO(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    or  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. eO(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    or  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. XYZ[\]^_`abcdeXYZ[\deabc]^_`portable experimentalDon Stewart <dons@galois.com><Wrapper of mallocForeignPtrBytes with faster implementation ! for GHC 6.5 builds newer than 060606 Create ByteString of size l and use action f to fill it' s contents. 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 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. 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. Conversion between   and  . Should compile to a no-op. Unsafe conversion between   and  . 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. O(n) Converts a  to a '[a]', using a conversion function. O(n) Convert a '[a]' into a  using some  conversion function     portable experimentaldons@galois.comZ O(n)( Return all final segments of the given , longest first. O(n) and O(n\c) space A first order equivalent of  filter .  (==)/=, for the common case of filtering a single byte. It is more  efficient to use  filterByte in this case.   filterByte == filter . (==) DfilterByte is around 10x faster, and uses much less space, than its  filter equivalent O(n) +, applied to a predicate and a ByteString, C returns a ByteString containing those characters that satisfy the  predicate. O(n)$ Concatenate a list of ByteStrings. O(n\c)/ Append two ByteStrings O(n) Convert a '[Word8]' into a .  generalises S' 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)  xs returns the elements of xs in reverse order. O(n) The , function takes two ByteStrings and returns   * iff the first is a prefix of the second. 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. O(n)  n x is a ByteString of length n with x  the value of every element. O(n) The ) function returns the index of the first  element in the given  which is equal to the query  element, or   if there is no such element. % This implementation uses memchr(3). 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.  p is equivalent to D (  . p). O(n) The # function is analogous to the List 'unfoldr'.  < builds a ByteString from a seed value. The function takes  the element and returns   if it is done producing the  ByteString or returns   (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)/ Append a byte to the end of a  O(n) Converts a  to a '[Word8]'. O(1) Convert a   into a  O(1) The empty  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(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) * f xs( is the ByteString obtained by applying f to each  element of xs. +The + function takes a   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. 00 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. 1 'foldl1\'' is like 0!, but strict in the accumulator. 22 is a variant of /& that has no starting value argument, ' and thus must be applied to non-empty s 3Map a function over a  and concatenate the results 4O(n)* Applied to a predicate and a ByteString, 4 determines if  any element of the  satisfies the predicate. 5O(n) Applied to a predicate and a , 5 determines  if all elements of the  satisfy the predicate. 6O(n) 6" returns the maximum value from a  7O(n) 7" returns the minimum value from a  8The 8( 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. 9The 9( 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. :O(n)? map Word8 functions, provided with the index at each position ;; 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. >>@ ties a finite ByteString into a circular one, or equivalently, 5 the infinite repetition of the original ByteString. ?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. AO(n\c)/ A n xs is equivalent to (? n xs, @ n xs). BB, applied to a predicate p and a ByteString xs, 0 returns the longest prefix (possibly empty) of xs of elements that  satisfy p. CC p xs$ returns the suffix remaining after B p xs. DD p xs0 breaks the ByteString into two segments. It is  equivalent to (B p xs, C p xs) EO(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') [] == [] FO(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. GThe G3 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 H!, which allows the programmer to ! supply their own equality test. HThe H+ function is the non-overloaded version of G. JO(c) . index (subscript) operator, starting from 0. KO(n) The K function extends , by returning M the indices of all elements equal to the query element, in ascending order. % This implementation uses memchr(3). LThe L" function takes a predicate and a  and : returns the index of the first element in the ByteString  satisfying the predicate. MO(n) The M. function takes a predicate and a ByteString, = and returns the first element in matching the predicate, or    if there is no such element. H find f p = case findIndex f p of Just n -> Just (p ! n) ; _ -> Nothing NThe N function extends L, by returning the G indices of all elements satisfying the predicate, in ascending order. OO(n) O is the  membership predicate. PO(n) P is the inverse of O QO(n) The Q5 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) RO(n) The R, function takes two ByteStrings and returns   * iff the first is a suffix of the second. The following holds: 4 isSuffixOf x y == reverse x `isPrefixOf` reverse y SO(n) S- 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. TO(n) T4 transforms a list of pairs of bytes into a pair of * ByteStrings. Note that this performs two  operations. UO(n)* Return all initial segments of the given , shortest first. VO(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. WRead 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. XRead n bytes into a , directly from the specified  . YhGetNonBlocking is similar to X", except that it will never block M waiting for data to become available, instead it returns only whatever data  is available. ZRead 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  . _A synonym for hPut, for compatibility `Write a ByteString to stdout a7Write a ByteString to stdout, appending a newline byte b/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 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  , 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. 4 is a variant of findIndex, that returns the length < of the string if no element is found, rather than Nothing. W  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abW #$%&(')!"*+,-.01/234567;89:=><?@ABCDGHU FEROPMQJKLNSTV]`abZ[\WXY^_I+non-portable (imports Data.ByteString.Lazy) experimentaldons@cse.unsw.edu.au:O(n) and O(n\c) space A first order equivalent of  filter .  (==)/=, for the common case of filtering a single Char. It is more  efficient to use  filterChar in this case.   filterByte == filter . (==) DfilterChar is around 10x faster, and uses much less space, than its  filter equivalent cO(n) c+, applied to a predicate and a ByteString, C returns a ByteString containing those characters that satisfy the  predicate. dO(n) Convert a   into a . eO(1) Convert a   into a  fIcount 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. gO(n) g n x is a ByteString of length n with x  the value of every element. hO(n) Converts a  to a  . iO(1) i is analogous to '(:)' for lists. jO(1) Unlike i, '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 i , as well as  and > , to build  infinite lazy ByteStrings. kO(n) Append a Char to the end of a  . Similar to  i#, this function performs a memcpy. lO(1)E Extract the first element of a ByteString, which must be non-empty. mO(1)> Extract the head and tail of a ByteString, returning Nothing  if it is empty. nO(1)G Extract the last element of a packed string, which must be non-empty. oO(n) o f xs( is the ByteString obtained by applying f to each element of xs pO(n) The p 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. rr<, 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. s 'foldl\''/ is like foldl, but strict in the accumulator. tt1, 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. uu is a variant of r that has no starting value 1 argument, and thus must be applied to non-empty  ByteStrings. v 'foldl1\'' is like u!, but strict in the accumulator. ww is a variant of t& that has no starting value argument, ' and thus must be applied to non-empty s xMap a function over a  and concatenate the results y)Applied to a predicate and a ByteString, y determines if  any element of the  satisfies the predicate. zApplied to a predicate and a , z determines if  all elements of the  satisfy the predicate. {{" returns the maximum value from a  ||" returns the minimum value from a  }} is similar to r#, 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. ~The ~( function behaves like a combination of o and  r9; 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. O(n)> map Char functions, provided with the index at each position  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) The # function is analogous to the List 'unfoldr'.  < builds a ByteString from a seed value. The function takes  the element and returns   if it is done producing the  ByteString or returns   (a,b), in which case, a is a " prepending to the ByteString and b" is used as the next element in a  recursive call. , 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  (  . p).  p xs0 breaks the ByteString into two segments. It is  equivalent to ( p xs,  p xs) 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"] - 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 G. 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   if there is no such element. 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. O(n)  is the  membership predicate. This  implementation uses  memchr(3). O(n)  is the inverse of  O(n) The . function takes a predicate and a ByteString, = and returns the first element in matching the predicate, or    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 h 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. 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. 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 lazily into a . Use ' text mode' " on Windows to interpret newlines Write a  to a file.  Append a  to a file. X  !"'),>?@AGUVWXY]^`abcdefghijklmnopqrstuvwxyz{|}~Xedh ijklmn')!"op,rsuvtwxyz{|}~g>?@AGU cfV]`abWXY^qportable 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 experimentaldons@cse.unsw.edu.au/Fuse to flat loop functions 1HProjection functions that are fusion friendly (as in, we determine when  they are inlined) B Iteration over over ByteStrings  Iteration over over ByteStrings CKData type for accumulators which can be ignored. The rewrite rules rely on K the fact that no bottoms of this type are ever constructed; hence, we can  assume  (_ :: NoAcc)  x = x. G Strict Maybe H Strict pair Type of loop functions I Special forms of loop arguments H These are common special cases for the three function arguments of gen K and loop; we give them special names to make it easier to trigger RULES F applying in the special cases represented by these arguments. The   INLINE [1]> makes sure that these functions are only inlined in the last  two simplifier phases. I In the case where the accumulator is not needed, it is better to always  explicitly return a value `()'), rather than just copy the input to the = output, as the former gives GHC better local information. +Element function expressing a mapping only J5Element function implementing a filter function only K-Element function expressing a reduction only LA strict foldEFL. M4Element function expressing a prefix reduction only N-Element function implementing a map and fold O/Element function implementing a map with index 1'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVW1B2/CW1P0QIJKLMNORSTUVA;@?>=<:7*'.8+(,96)35-4HFGDE !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghUijklmnopqrstuvwxyz{|}~zy~x}wz{w~yx}zy~x}w         i           bytestring-0.9.0.4Data.ByteString.InternalData.ByteStringData.ByteString.Lazy.InternalData.ByteString.LazyData.ByteString.FusionData.ByteString.UnsafeData.ByteString.Char8Data.ByteString.Lazy.Char8base Data.Word Data.Bool Data.MaybeGHC.ExtsData.Ord System.IO Data.Char Data.ListData.IntmemcpymallocByteStringcreatePS ByteStringmemcpy_ptr_baoffc_count c_minimum c_maximum c_intersperse c_reversememcmpc_free_finalizerc_strlennullForeignPtrfromForeignPtr toForeignPtr unsafeCreate createAndTrimcreateAndTrim'w2cc2w isSpaceWord8 isSpaceChar8inlinePerformIOmemchrmemmovememsetChunkEmpty invariantcheckInvariantchunk foldrChunks foldlChunksdefaultChunkSizesmallChunkSize chunkOverheadfuseNoAccNoAccEFLfuseNoAccMapEFLfuseNoAccFilterEFLfuseNoAccAccEFLfuseMapNoAccEFL fuseMapMapEFLfuseMapFilterEFL fuseMapAccEFLfuseEFL loopSndAccloopArrloopLfuseFilterNoAccEFLfuseFilterMapEFLfuseFilterFilterEFLfuseFilterAccEFLfuseAccNoAccEFL fuseAccMapEFLfuseAccFilterEFL fuseAccAccEFL sequenceLoops doFilterLoop doMapLoop doNoAccLoop doDownLoopdoUpLoop loopWrapperloopUNoAccJustSNothingS:*:MaybeSPairSmapEFL filterEFLfoldEFLfoldEFL'scanEFL mapAccumEFL mapIndexEFLloopAccunSPloopUploopDown loopNoAccloopMap loopFilter unsafeHead unsafeTail unsafeIndex unsafeTake unsafeDropunsafePackAddressunsafePackAddressLenunsafePackCStringFinalizerunsafeFinalizeunsafePackCStringunsafePackCStringLenunsafePackMallocCStringunsafeUseAsCStringunsafeUseAsCStringLenzipWithspan singletonfilterappend isSubstringOf findIndexcount replicateelem intercalatebreak elemIndexunfoldrNscanrconsscanlsnoclengthemptyfoldr'initlastfoldrfoldl'foldlunpackpackconcatnullheadtailunconsmapreverse intersperse transposefoldl1foldl1'foldr1foldr1' concatMapanyallmaximumminimum mapAccumL mapAccumR mapIndexedscanl1scanr1unfoldrtakedropsplitAt takeWhile dropWhilebreakEndspanEnd splitWithsplitgroupgroupByjoinindex elemIndexEnd elemIndices findIndicesnotElemfind partition isPrefixOf isSuffixOf isInfixOf findSubstringfindSubstringszipunzipinitstailssort useAsCStringuseAsCStringLen packCStringpackCStringLencopygetLinehGetLinehPuthPutStr hPutStrLnputStrputStrLnhGethGetNonBlocking hGetContents getContentsinteractreadFile writeFile appendFilelinesunlineswordsunwordsreadInt readInteger fromChunkstoChunkscons'iteraterepeatcyclezipWith'spanByteintercalateWithByteGHC.WordWord8 filterByte breakByteeqGHC.BasenotNothingfindIndexOrEndIntwithPtr compareBytesOrderingJustTrue GHC.IOBaseHandleString filterChar dropSpace breakSpaceCharGHC.List unpackWithpackWithGHC.IntInt64 hGetContentsNhGetNhGetNonBlockingNGHC.PrimseqAccEFL