iteratee-mtl 0.4.0.2 → 0.5.0.0

raw patch · 5 files changed

+59/−28 lines, 5 filesdep ~basedep ~containersPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: base, containers

API changes (from Hackage documentation)

Files

• iteratee-mtl.cabal +7/−7
• src/Data/Iteratee/IO/Fd.hs +8/−6
• src/Data/Iteratee/IO/Handle.hs +8/−6
• src/Data/Iteratee/Iteratee.hs +12/−9
• src/Data/Iteratee/ListLike.hs +24/−0

@@ -1,5 +1,5 @@ name:          iteratee-mtl-version:       0.4.0.2+version:       0.5.0.0 synopsis:      Iteratee-based I/O description:   The Iteratee monad provides strict, safe, and functional I/O. In addition@@ -37,7 +37,7 @@    if flag(splitBase)     build-depends:-      base >= 3 && < 5+      base >= 3 && < 6   else     build-depends:       base < 3@@ -55,11 +55,11 @@       unix >= 2 && < 3    build-depends:-    ListLike         >= 1.0     && < 2,-    MonadCatchIO-mtl >  0.3     && < 0.4,-    bytestring       >= 0.9     && < 0.10,-    containers       >= 0.2     && < 0.4,-    mtl              >= 1.1     && < 1.2+    ListLike                  >= 1.0     && < 2,+    MonadCatchIO-mtl          >  0.3     && < 0.4,+    bytestring                >= 0.9     && < 0.10,+    containers                >= 0.2     && < 0.5,+    mtl                       >= 1.1     && < 1.2    exposed-modules:     Data.Nullable

@@ -47,14 +47,16 @@   Ptr el   -> ByteCount   -> Fd-  -> m (Either SomeException (Bool, s))-makefdCallback p bufsize fd = do+  -> st+  -> m (Either SomeException ((Bool, st), s))+makefdCallback p bufsize fd st = do   liftIO $ GHC.Conc.threadWaitRead fd   n <- liftIO $ myfdRead fd (castPtr p) bufsize   case n of     Left _   -> return $ Left undefined-    Right 0  -> return $ Right (False, empty)-    Right n' -> liftM (\s -> Right (True, s)) $ readFromPtr p (fromIntegral n')+    Right 0  -> return $ Right ((False, st), empty)+    Right n' -> liftM (\s -> Right ((True, st), s)) $+                  readFromPtr p (fromIntegral n')  -- |The enumerator of a POSIX File Descriptor.  This version enumerates -- over the entire contents of a file, in order, unless stopped by@@ -67,7 +69,7 @@ enumFd bs fd iter = do   let bufsize = bs * (sizeOf (undefined :: el))   p <- liftIO $ mallocBytes bufsize-  enumFromCallback (makefdCallback p (fromIntegral bufsize) fd) iter+  enumFromCallback (makefdCallback p (fromIntegral bufsize) fd) () iter  -- |A variant of enumFd that catches exceptions raised by the @Iteratee@. enumFdCatch@@ -80,7 +82,7 @@   let bufsize = bs * (sizeOf (undefined :: el))   p <- liftIO $ mallocBytes bufsize   enumFromCallbackCatch (makefdCallback p (fromIntegral bufsize) fd)-    handler iter+    handler () iter   -- |The enumerator of a POSIX File Descriptor: a variation of @enumFd@ that

@@ -41,13 +41,15 @@   Ptr el   -> Int   -> Handle-  -> m (Either SomeException (Bool, s))-makeHandleCallback p bsize h = do+  -> st+  -> m (Either SomeException ((Bool, st), s))+makeHandleCallback p bsize h st = do   n' <- liftIO (CIO.try $ hGetBuf h p bsize :: IO (Either SomeException Int))   case n' of     Left e -> return $ Left e-    Right 0 -> return $ Right (False, empty)-    Right n -> liftM (\s -> Right (True, s)) $ readFromPtr p (fromIntegral n)+    Right 0 -> return $ Right ((False, st), empty)+    Right n -> liftM (\s -> Right ((True, st), s)) $+                 readFromPtr p (fromIntegral n)   -- |The (monadic) enumerator of a file Handle.  This version enumerates@@ -62,7 +64,7 @@ enumHandle bs h i = do   let bufsize = bs * sizeOf (undefined :: el)   p <- liftIO $ mallocBytes bufsize-  enumFromCallback (makeHandleCallback p bufsize h) i+  enumFromCallback (makeHandleCallback p bufsize h) () i  -- |An enumerator of a file handle that catches exceptions raised by -- the Iteratee.@@ -79,7 +81,7 @@ enumHandleCatch bs h handler i = do   let bufsize = bs * sizeOf (undefined :: el)   p <- liftIO $ mallocBytes bufsize-  enumFromCallbackCatch (makeHandleCallback p bufsize h) handler i+  enumFromCallbackCatch (makeHandleCallback p bufsize h) handler () i   -- |The enumerator of a Handle: a variation of enumHandle that

@@ -256,10 +256,11 @@ -- |Create an enumerator from a callback function enumFromCallback ::  (Monad m, NullPoint s) =>-  m (Either SomeException (Bool, s))+  (st -> m (Either SomeException ((Bool, st), s)))+  -> st   -> Enumerator s m a-enumFromCallback = flip enumFromCallbackCatch-  (\NotAnException -> return Nothing)+enumFromCallback c st =+  enumFromCallbackCatch c (\NotAnException -> return Nothing) st  -- Dummy exception to catch in enumFromCallback -- This never gets thrown, but it lets us@@ -274,17 +275,19 @@ -- The exception handler is called if an iteratee reports an exception. enumFromCallbackCatch ::  (IException e, Monad m, NullPoint s) =>-  m (Either SomeException (Bool, s))+  (st -> m (Either SomeException ((Bool, st), s)))   -> (e -> m (Maybe EnumException))+  -> st   -> Enumerator s m a enumFromCallbackCatch c handler = loop   where-    loop iter = runIter iter idoneM on_cont-    on_cont k Nothing = c >>= either (return . k . EOF . Just) (uncurry check)+    loop st iter = runIter iter idoneM (on_cont st)+    on_cont st k Nothing = c st >>=+        either (return . k . EOF . Just) (uncurry check)       where-        check b = if b then loop . k . Chunk else return . k . Chunk-    on_cont k j@(Just e) = case fromException e of-      Just e' -> handler e' >>= maybe (loop . k $ Chunk empty)+        check (b,st') = if b then loop st' . k . Chunk else return . k . Chunk+    on_cont st k j@(Just e) = case fromException e of+      Just e' -> handler e' >>= maybe (loop st . k $ Chunk empty)                                  (return . icont k . Just) . fmap toException       Nothing -> return (icont k j) 

@@ -20,6 +20,7 @@   ,head   ,heads   ,peek+  ,roll   ,length   -- ** Nested iteratee combinators   ,take@@ -51,6 +52,7 @@ import qualified Data.ListLike.FoldableLL as FLL import Data.Iteratee.Iteratee import Control.Monad.Trans+import Control.Applicative import Data.Monoid import Data.Word (Word8) import qualified Data.ByteString as B@@ -168,6 +170,28 @@       | True        = idone (Just $ LL.head vec) s     step stream     = idone Nothing stream {-# INLINE peek #-}++-- | Return a chunk of `t' elements length, while consuming `d' elements+--   from the stream.  Useful for creating a "rolling average" with convStream.+roll :: (Monad m, Functor m, Nullable s, LL.ListLike s el, LL.ListLike s' s) =>+  Int+  -> Int+  -> Iteratee s m s'+roll t d | t > d  = liftI step+  where+    step (Chunk vec)+      | LL.length vec >= d =+          idone (LL.singleton $ LL.take t vec) (Chunk $ LL.drop d vec)+      | LL.length vec >= t =+          idone (LL.singleton $ LL.take t vec) mempty <* drop (d-LL.length vec)+      | LL.null vec        = liftI step+      | True               = liftI (step' vec)+    step stream            = idone LL.empty stream+    step' v1 (Chunk vec)   = step . Chunk $ v1 `mappend` vec+    step' v1 stream        = idone (LL.singleton v1) stream+roll t d = LL.singleton <$> joinI (take t stream2stream) <* drop (d-t)+  -- d is >= t, so this version works+{-# INLINE roll #-}   -- |Drop n elements of the stream, if there are that many.