Folks, These functions together can be taking 15-20% of my processing time. I'm trying to optimize the hell out of them. Would it be less expensive to convert each of them into a foreign function? Is there a way to optimize them further within Haskell? appU_wstr is particularly expensive and deals with reversing the words in a unicode string received little-endian. Thanks, Joel P.S appP_wstr :: Ptr Word8 -> Int -> String -> IO Int appP_wstr ptr ix [] = pickle short ptr ix 0 appP_wstr ptr ix a = do ix1 <- foldM (\ix' c -> pickle endianW16 ptr ix' $ word c) ix a pickle short ptr ix1 0 where word c = fromIntegral $ ord c appU_wstr :: Ptr Word8 -> Int -> IO (String, Int) appU_wstr ptr ix = do (a, ix1) <- unpickle endianW16 ptr ix appU_wstr' ix1 a [] where appU_wstr' ix 0 acc = return $!! (reverse acc, ix) appU_wstr' ix x acc = do (a, ix1) <- unpickle endianW16 ptr ix appU_wstr' ix1 a ((chr $ fromIntegral x):acc) {-# SPECIALIZE swap16 :: Word16 -> Word16 #-} {-# SPECIALIZE swap16 :: Int16 -> Int16 #-} swap16 :: Bits a => a -> a #ifdef BIG_ENDIAN swap16 v = (v `shiftR` 8) .|. (v `shiftL` 8) #else swap16 v = v #endif {-# SPECIALIZE swap32 :: Word32 -> Word32 #-} {-# SPECIALIZE swap32 :: Int32 -> Int32 #-} swap32 :: Bits a => a -> a #ifdef BIG_ENDIAN swap32 v = ( v `shiftR` 24) .|. ((v .&. 0x000000FF) `shiftL` 24) .|. ((v .&. 0x0000FF00) `shiftL` 8) .|. ((v .&. 0x00FF0000) `shiftR` 8) #else swap32 v = v #endif {-# SPECIALIZE swap64 :: Word64 -> Word64 #-} {-# SPECIALIZE swap64 :: Int64 -> Int64 #-} swap64 :: Bits a => a -> a #ifdef BIG_ENDIAN swap64 v = ( v `shiftR` 56) .|. ((v .&. 0x00000000000000FF) `shiftL` 56) .|. ((v .&. 0x00FF000000000000) `shiftR` 40) .|. ((v .&. 0x000000000000FF00) `shiftL` 40) .|. ((v .&. 0x0000FF0000000000) `shiftR` 24) .|. ((v .&. 0x0000000000FF0000) `shiftL` 24) .|. ((v .&. 0x000000FF00000000) `shiftR` 8) .|. ((v .&. 0x00000000FF000000) `shiftL` 8) #else swap64 v = v #endif -- http://wagerlabs.com/