On 3/21/11 4:40 PM, Brandon Moore wrote:
> Is there an efficient way to iterate over the bytes of a ByteString?
The code I've been using (rather similar to your unsafe map) is:
import qualified Data.ByteString.Internal as BSI
import qualified Foreign.ForeignPtr as FFI
foldIO :: (a -> Word8 -> IO a) -> a -> ByteString -> IO a
foldIO f z0 (BSI.PS fp off len) =
FFI.withForeignPtr fp $ \p0 -> do
let q = p0 `plusPtr` (off+len)
let go z p
| z `seq` p `seq` False = undefined
| p == q = return z
| otherwise = do
w <- peek p
z' <- f z w
go z' (p `plusPtr` 1)
go z0 (p0 `plusPtr` off)
{-# INLINE foldIO #-}
Some things to note:
* It's a left fold rather than a right fold, just like foldM, except
that we can't generalize it to work for all monads. (We could do a right
fold just as easily by starting with p0`plusPtr`(off+len) and counting
down to p0`plusPtr`off if desired.)
* Because we're just keeping the head pointer, we can increment it as we
go instead of using peekElemOff. This improves the performance by only
performing one addition per loop (the p++) instead of two (ix++ and
*(p+ix)), and by requiring one less register (for ix).
* The inline pragma helps performance in a major way.
* I haven't actually looked at Core nor tried much to optimize it. This
just seems like the easiest way to allow the accumulator to perform IO
instead of being pure. (For pure code there's foldl'.)
--
Live well,
~wren