Editing Wc (section)

== Avoid some code ==

The guard that checks the length is unneeded, since memchr takes a length
argument anyway.  It also calculates the next pointer for us, so avoid
recalculating it.  (Note that this is equivalent to using the 'count'
function, which has the same implementation).

<haskell>
import Foreign
import Foreign.ForeignPtr
import Foreign.C.Types

import System.Environment
import qualified Data.ByteString as B

#define STRICT3(f) f a b c | a `seq` b `seq` c `seq` False = undefined

main = do
    f <- head `fmap` getArgs
    B.readFile f >>= \(B.PS x s l) -> withForeignPtr x $ \p -> 
        go (p `plusPtr` s) (fromIntegral l) 0
    where
        go :: Ptr Word8 -> CSize -> Int -> IO ()
        STRICT3(go)
        go p l i = do
            let q  = memchr p 0x0a l
            if q == nullPtr
                then print i
                else do let k = fromIntegral $ q `minusPtr` p
                        go (q `plusPtr` 1) (l-k) (i+1)

foreign import ccall unsafe "string.h memchr" memchr
    :: Ptr Word8 -> CInt -> CSize -> Ptr Word8
</haskell>

Checking the Core, 'go' is now:

 Main.$wgo :: GHC.Prim.Addr#
              -> GHC.Prim.Word#
              -> GHC.Prim.Int#
              -> GHC.IOBase.IO ()

The code is certainly a bit simpler, at least.

 $ ghc -O -package fps -cpp -ffi wc.hs
 $ time ./wc /usr/share/dict/words
 98326
 ./wc /usr/share/dict/words  0.00s user 0.01s system 70% cpu 0.017 total

But we can't seem to squeeze any more out, at least on data this size.