src/Control/Addressbook/Streaming.hs

@@ -29,7 +29,6 @@ import qualified Data.ByteString.Lazy.Char8 as LBC
 import System.IO.Unsafe (unsafeInterleaveIO)
 import Control.Parallel.Strategies (rseq, parMap)
 import qualified Data.List as L
-import Control.Monad (unless)
 
 combine :: (MonadUnliftIO m, MonadResource m, MonadThrow m, MonadIO m) => ConduitM FilePath Header m ()
 combine = await >>= \case
@@ -47,13 +46,12 @@ run = do
   let datFile = datDir </> ".addressbook.dat"
   original <- Set.fromList . map LBS.toStrict . lbsLines <$> LBS.readFile datFile
   xs <- LBS.getContents >>= stream
-  let set = original `Set.union` F.fold (parMap rseq F.fold (chunks 200 xs))
+  let set = original `Set.union` F.fold (parMap rseq F.fold (chunks 20 xs))
-  unless (original == set) $
+  runResourceT $
-    runResourceT $
+    runConduit $
-      runConduit $
+         CL.sourceList (Set.elems set)
-           CL.sourceList (Set.elems set)
+      .| C.map (<> "\n")
-        .| C.map (<> "\n")
+      .| CB.sinkFileCautious datFile
-        .| CB.sinkFileCautious datFile
   where
     separate = \case
       From x -> [x]

src/Data/Email/Header.hs

@@ -1,5 +1,4 @@
 {-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE ApplicativeDo #-}
 module Data.Email.Header where
 
 import qualified Data.Foldable as F
@@ -22,39 +21,28 @@ data Header
 
 decode :: ByteString -> Either String Header
 decode = parseOnly parseHeader
-{-# INLINE decode #-}
+  where
-
+    parseHeader :: Parser Header
-parseHeader :: Parser Header
+    parseHeader = parseFrom <|> parseTo
-parseHeader = parseFrom <|> parseTo
+    parseFrom :: Parser Header
-{-# INLINE parseHeader #-}
+    parseFrom = From <$> (string "From:" *> emptySpace *> (bracketEmail <|> email))
-
+    parseTo :: Parser Header
-parseFrom :: Parser Header
+    parseTo = To <$> (string "To:" *> emptySpace *> emails)
-parseFrom = From <$> (string "From:" *> emptySpace *> (bracketEmail <|> email))
+    emptySpace = many' space
-
+    emails :: Parser (Vector ByteString)
-parseTo :: Parser Header
+    emails = V.fromList <$> (bracketEmail <|> email) `sepBy` char ','
-parseTo = To <$> (string "To:" *> emptySpace *> emails)
+    bracketEmail :: Parser ByteString
-
+    bracketEmail = do
-emptySpace :: Parser ()
+      _ <- manyTill anyChar (char '<')
-emptySpace = () <$ many' space
+      email
-
+    email :: Parser ByteString
-emails :: Parser (Vector ByteString)
+    email = do
-emails = V.fromList <$> (bracketEmail <|> email) `sepBy` char ','
+      _ <- many' space
-
+      name <- BC.pack <$> many' (satisfy (\c -> not (isSpace c) && c /= '@'))
-bracketEmail :: Parser ByteString
+      _ <- char '@'
-bracketEmail = do
+      rest <- BC.pack <$> many' (satisfy (\c -> not (isSpace c) && c /= ',' && c /= '>'))
-  _ <- manyTill anyChar (char '<')
+      _ <- many' (notChar ',')
-  email
+      pure (name <> "@" <> rest)
-{-# INLINE bracketEmail #-}
-
-email :: Parser ByteString
-email = do
-  _ <- many' space
-  name <- BC.pack <$> many' (satisfy (\c -> not (isSpace c) && c /= '@'))
-  _ <- char '@'
-  rest <- BC.pack <$> many' (satisfy (\c -> not (isSpace c) && c /= ',' && c /= '>' && c /= '<'))
-  _ <- many' (notChar ',')
-  pure (name <> "@" <> rest)
-{-# INLINE email #-}
 
 
 encode :: Header -> ByteString

test/Test/Data/Email.hs

@@ -31,7 +31,4 @@ tests = testGroup "Data.Email"
   [ testCase "Can parse a sample email" $ do
       got <- parseToList sample
       got @?= [ From "me@example.com", To ["you@example.com"]]
-  , testCase "Combined mailto" $ do
-      let got = decode "To: James Doe<james.doe@example.com<mailto:james.doe@example.com>>"
-      got @?= Right (To ["james.doe@example.com"])
   ]