diff --git a/iteratee-mtl.cabal b/iteratee-mtl.cabal
--- a/iteratee-mtl.cabal
+++ b/iteratee-mtl.cabal
@@ -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
diff --git a/src/Data/Iteratee/IO/Fd.hs b/src/Data/Iteratee/IO/Fd.hs
--- a/src/Data/Iteratee/IO/Fd.hs
+++ b/src/Data/Iteratee/IO/Fd.hs
@@ -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
diff --git a/src/Data/Iteratee/IO/Handle.hs b/src/Data/Iteratee/IO/Handle.hs
--- a/src/Data/Iteratee/IO/Handle.hs
+++ b/src/Data/Iteratee/IO/Handle.hs
@@ -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
diff --git a/src/Data/Iteratee/Iteratee.hs b/src/Data/Iteratee/Iteratee.hs
--- a/src/Data/Iteratee/Iteratee.hs
+++ b/src/Data/Iteratee/Iteratee.hs
@@ -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)
 
diff --git a/src/Data/Iteratee/ListLike.hs b/src/Data/Iteratee/ListLike.hs
--- a/src/Data/Iteratee/ListLike.hs
+++ b/src/Data/Iteratee/ListLike.hs
@@ -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.