Hi all, I have a piece of code where I'm serializing a datastructure with the following type [(Int, (Map DType (IntMap Int)))], using Binary.encode The thing is it is very slow: actually quite a bit slower than just using show. This seems rather suspicious. Any idea what could be going on? import qualified Data.Map as Map import qualified Data.IntMap as IntMap import Data.IntMap ((!)) import Vector import Atom import Control.Monad.State import Indexing (indexBy) import Data.List (foldl') import System import System.IO import Debug.Trace import qualified Data.Binary as Binary import qualified Data.ByteString.Lazy as BS data DType = Fol | For | Sol | Sor deriving (Eq,Enum,Ord,Show,Read) instance Binary.Binary DType where    get = do x <- Binary.get             return (toEnum x)    put x = Binary.put (fromEnum x) type Word = Int type Count = Int type WordMap = IntMap.IntMap find = IntMap.findWithDefault IntMap.empty distReps ::    Map.Map (Word,Word) Count            -> [(Int, (Map.Map DType (WordMap Count)))] distReps bidict =    let bigrams = Map.toList bidict        for = indexBy id bigrams        fol = indexBy swap bigrams        ws  = map (fst . fst) bigrams        r = flip map ws            $ \w -> (w,Map.fromList [ (Fol , find w fol)                                            , (For , find w for)                                            , (Sol , sox for fol w )                                            , (Sor , sox fol for w ) ])    in trace (show $ r == r)  r sox :: WordMap (WordMap Count)    -> WordMap (WordMap Count)    -> Word    -> WordMap Count sox fox foy w =    let xs = IntMap.keys (find w fox)        f !z x = let xv = find x foy                 in xv == xv `seq` z `plus` xv    in foldl' f IntMap.empty xs swap (!a,!b) = (b,a) readBigrams = fmap (map (\ [w,w',c] -> ((w,w'),read c))                . map words                      . lines )              getContents main = do  [f] <- getArgs  bigrams <- readBigrams  let (bigrams',as) = flip runState empty (atomize bigrams)      dr = distReps (Map.fromList bigrams')  write f dr  hPutStrLn stderr "Done this"  write (f++".atom") as --write f d =  writeFile f (show d) write f d = BS.writeFile f (Binary.encode d) atomize xs = mapM f xs    where f ((w,w'),!i) = do            !i_w <- toAtom w'            !i_w' <- toAtom w            let r = ((i_w,i_w'),i)            r == r `seq` return r -- Grzegorz