Undo whitespace changes.
authorSean <burton.seanr@gmail.com>
Mon, 28 Sep 2015 21:26:21 +0000 (22:26 +0100)
committerSean <burton.seanr@gmail.com>
Mon, 28 Sep 2015 21:38:15 +0000 (22:38 +0100)
Data/ByteString.hs

index 93d7be8..79a02d6 100644 (file)
@@ -21,7 +21,7 @@
 -- Maintainer  : dons00@gmail.com, duncan@community.haskell.org
 -- Stability   : stable
 -- Portability : portable
---
+-- 
 -- A time and space-efficient implementation of byte vectors using
 -- packed Word8 arrays, suitable for high performance use, both in terms
 -- of large data quantities, or high speed requirements. Byte vectors
@@ -349,17 +349,17 @@ singleton c = unsafeCreate 1 $ \p -> poke p c
 --
 -- is compiled to:
 --
---  case mallocByteString 2 of
---      ForeignPtr f internals ->
---           case writeWord8OffAddr# f 0 255 of _ ->
+--  case mallocByteString 2 of 
+--      ForeignPtr f internals -> 
+--           case writeWord8OffAddr# f 0 255 of _ -> 
 --           case writeWord8OffAddr# f 0 127 of _ ->
---           case eqAddr# f f of
---                  False -> case compare (GHC.Prim.plusAddr# f 0)
+--           case eqAddr# f f of 
+--                  False -> case compare (GHC.Prim.plusAddr# f 0) 
 --                                        (GHC.Prim.plusAddr# f 0)
 --
 --
 
--- | /O(n)/ Convert a '[Word8]' into a 'ByteString'.
+-- | /O(n)/ Convert a '[Word8]' into a 'ByteString'. 
 --
 -- For applications with large numbers of string literals, pack can be a
 -- bottleneck. In such cases, consider using packAddress (GHC only).
@@ -802,11 +802,11 @@ replicate w c
     | otherwise = unsafeCreate w $ \ptr ->
                       memset ptr c (fromIntegral w) >> return ()
 
--- | /O(n)/, where /n/ is the length of the result.  The 'unfoldr'
--- function is analogous to the List \'unfoldr\'.  'unfoldr' builds a
--- ByteString from a seed value.  The function takes the element and
--- returns 'Nothing' if it is done producing the ByteString or returns
--- 'Just' @(a,b)@, in which case, @a@ is the next byte in the string,
+-- | /O(n)/, where /n/ is the length of the result.  The 'unfoldr' 
+-- function is analogous to the List \'unfoldr\'.  'unfoldr' builds a 
+-- ByteString from a seed value.  The function takes the element and 
+-- returns 'Nothing' if it is done producing the ByteString or returns 
+-- 'Just' @(a,b)@, in which case, @a@ is the next byte in the string, 
 -- and @b@ is the seed value for further production.
 --
 -- Examples:
@@ -897,7 +897,7 @@ dropWhile f ps = unsafeDrop (findIndexOrEnd (not . f) ps) ps
 --
 break :: (Word8 -> Bool) -> ByteString -> (ByteString, ByteString)
 break p ps = case findIndexOrEnd p ps of n -> (unsafeTake n ps, unsafeDrop n ps)
-#if __GLASGOW_HASKELL__
+#if __GLASGOW_HASKELL__ 
 {-# INLINE [1] break #-}
 #endif
 
@@ -913,7 +913,7 @@ break p ps = case findIndexOrEnd p ps of n -> (unsafeTake n ps, unsafeDrop n ps)
 -- | 'breakByte' breaks its ByteString argument at the first occurence
 -- of the specified byte. It is more efficient than 'break' as it is
 -- implemented with @memchr(3)@. I.e.
---
+-- 
 -- > break (=='c') "abcd" == breakByte 'c' "abcd"
 --
 breakByte :: Word8 -> ByteString -> (ByteString, ByteString)
@@ -924,7 +924,7 @@ breakByte c p = case elemIndex c p of
 {-# DEPRECATED breakByte "It is an internal function and should never have been exported. Use 'break (== x)' instead. (There are rewrite rules that handle this special case of 'break'.)" #-}
 
 -- | 'breakEnd' behaves like 'break' but from the end of the 'ByteString'
---
+-- 
 -- breakEnd p == spanEnd (not.p)
 breakEnd :: (Word8 -> Bool) -> ByteString -> (ByteString, ByteString)
 breakEnd  p ps = splitAt (findFromEndUntil p ps) ps
@@ -971,8 +971,8 @@ spanByte c ps@(PS x s l) =
 -- and
 --
 -- > spanEnd (not . isSpace) ps
--- >    ==
--- > let (x,y) = span (not.isSpace) (reverse ps) in (reverse y, reverse x)
+-- >    == 
+-- > let (x,y) = span (not.isSpace) (reverse ps) in (reverse y, reverse x) 
 --
 spanEnd :: (Word8 -> Bool) -> ByteString -> (ByteString, ByteString)
 spanEnd  p ps = splitAt (findFromEndUntil (not.p) ps) ps
@@ -1028,12 +1028,12 @@ splitWith p ps = loop p ps
 -- > 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 . (==)
---
+-- 
 -- As for all splitting functions in this library, this function does
 -- not copy the substrings, it just constructs new 'ByteStrings' that
 -- are slices of the original.
@@ -1063,7 +1063,7 @@ split w (PS x s l) = loop 0
 -- > group "Mississippi" = ["M","i","ss","i","ss","i","pp","i"]
 --
 -- It is a special case of 'groupBy', which allows the programmer to
--- supply their own equality test. It is about 40% faster than
+-- supply their own equality test. It is about 40% faster than 
 -- /groupBy (==)/
 group :: ByteString -> [ByteString]
 group xs
@@ -1120,7 +1120,7 @@ index ps n
 
 -- | /O(n)/ The 'elemIndex' function returns the index of the first
 -- element in the given 'ByteString' which is equal to the query
--- element, or 'Nothing' if there is no such element.
+-- element, or 'Nothing' if there is no such element. 
 -- This implementation uses memchr(3).
 elemIndex :: Word8 -> ByteString -> Maybe Int
 elemIndex c (PS x s l) = accursedUnutterablePerformIO $ withForeignPtr x $ \p -> do
@@ -1134,7 +1134,7 @@ elemIndex c (PS x s l) = accursedUnutterablePerformIO $ withForeignPtr x $ \p ->
 -- element, or 'Nothing' if there is no such element. The following
 -- holds:
 --
--- > elemIndexEnd c xs ==
+-- > elemIndexEnd c xs == 
 -- > (-) (length xs - 1) `fmap` elemIndex c (reverse xs)
 --
 elemIndexEnd :: Word8 -> ByteString -> Maybe Int
@@ -1288,7 +1288,7 @@ isPrefixOf (PS x1 s1 l1) (PS x2 s2 l2)
 
 -- | /O(n)/ The 'isSuffixOf' function takes two ByteStrings and returns 'True'
 -- iff the first is a suffix of the second.
---
+-- 
 -- The following holds:
 --
 -- > isSuffixOf x y == reverse x `isPrefixOf` reverse y
@@ -1330,8 +1330,8 @@ isInfixOf p s = isJust (findSubstring p s)
 -- >     where (h,t) = breakSubstring x y
 --
 -- To skip to the first occurence of a string:
---
--- > snd (breakSubstring x y)
+-- 
+-- > snd (breakSubstring x y) 
 --
 -- To take the parts of a string before a delimiter:
 --
@@ -1443,7 +1443,7 @@ zip ps qs
 -- | 'zipWith' generalises 'zip' by zipping with the function given as
 -- the first argument, instead of a tupling function.  For example,
 -- @'zipWith' (+)@ is applied to two ByteStrings to produce the list of
--- corresponding sums.
+-- corresponding sums. 
 zipWith :: (Word8 -> Word8 -> a) -> ByteString -> ByteString -> [a]
 zipWith f ps qs
     | null ps || null qs = []
@@ -1570,10 +1570,10 @@ packCStringLen (_, len) =
 
 ------------------------------------------------------------------------
 
--- | /O(n)/ Make a copy of the 'ByteString' with its own storage.
+-- | /O(n)/ Make a copy of the 'ByteString' with its own storage. 
 -- This is mainly useful to allow the rest of the data pointed
 -- to by the 'ByteString' to be garbage collected, for example
--- if a large string has been read in, and only a small part of it
+-- if a large string has been read in, and only a small part of it 
 -- is needed in the rest of the program.
 --
 copy :: ByteString -> ByteString
@@ -1746,7 +1746,7 @@ hPutNonBlocking h bs@(PS ps s l) = do
 hPutNonBlocking h bs = hPut h bs >> return empty
 #endif
 
--- | A synonym for @hPut@, for compatibility
+-- | A synonym for @hPut@, for compatibility 
 hPutStr :: Handle -> ByteString -> IO ()
 hPutStr = hPut
 
@@ -1776,7 +1776,7 @@ putStrLn = hPutStrLn stdout
 
 -- | Read a 'ByteString' directly from the specified 'Handle'.  This
 -- is far more efficient than reading the characters into a 'String'
--- and then using 'pack'. First argument is the Handle to read from,
+-- and then using 'pack'. First argument is the Handle to read from, 
 -- and the second is the number of bytes to read. It returns the bytes
 -- read, up to n, or 'empty' if EOF has been reached.
 --