From: wren ng thornton <wren@freegeek.org>
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).