diff --git a/Data/Conduit/List.hs b/Data/Conduit/List.hs
--- a/Data/Conduit/List.hs
+++ b/Data/Conduit/List.hs
@@ -217,7 +217,7 @@
     push = fmap (Producing conduit) . lift . f
     close = return []
 
--- | 'concatMap' with accumerator.
+-- | 'concatMap' with an accumulator.
 --
 -- Since 0.2.0
 concatMapAccum :: Resource m => (a -> accum -> (accum, [b])) -> accum -> Conduit a m b
@@ -227,7 +227,7 @@
                        in return $ StateProducing state' result
     close _ = return []
 
--- | 'concatMapM' with accumerator.
+-- | 'concatMapM' with an accumulator.
 --
 -- Since 0.2.0
 concatMapAccumM :: Resource m => (a -> accum -> m (accum, [b])) -> accum -> Conduit a m b
diff --git a/Data/Conduit/Util/Conduit.hs b/Data/Conduit/Util/Conduit.hs
--- a/Data/Conduit/Util/Conduit.hs
+++ b/Data/Conduit/Util/Conduit.hs
@@ -13,9 +13,11 @@
       -- *** Sequencing
     , SequencedSink
     , sequenceSink
+    , sequence
     , SequencedSinkResponse (..)
     ) where
 
+import Prelude hiding (sequence)
 import Control.Monad.Trans.Resource
 import Control.Monad.Trans.Class
 import Data.Conduit.Types.Conduit
@@ -206,3 +208,39 @@
         Emit _ os -> return os
         Stop -> return []
         StartConduit c -> conduitClose c
+
+-- | Specialised version of 'sequenceSink'
+--
+-- Note that this function will return an infinite stream if provided a
+-- @SinkNoData@ constructor. In other words, you probably don\'t want to do
+-- @sequence . return@.
+--
+-- Since 0.2.1
+sequence :: Resource m => Sink input m output -> Conduit input m output
+sequence (SinkData spush sclose) = Conduit (push spush) (close sclose)
+  where
+    push spush' input = do
+        res <- spush' input
+        case res of
+            Processing spush'' sclose'' ->
+                return $ Producing (Conduit (push spush'') (close sclose'')) []
+            Done Nothing output ->
+                return $ Producing (Conduit (push spush) (close sclose)) [output]
+            Done (Just input') output -> do
+                res' <- push spush input'
+                case res' of
+                    Producing conduit' output' ->
+                        return $ Producing conduit' (output:output')
+                    Finished _ _ -> error "impossible [sequence]"
+    close sclose' = fmap (:[]) sclose'
+
+sequence (SinkNoData output) = Conduit
+    { conduitPush = \input -> return $ Finished (Just input) (repeat output)
+    , conduitClose = return $ repeat output
+    }
+sequence (SinkLift msink) = Conduit
+    { conduitPush = \input -> do
+        sink <- msink
+        conduitPush (sequence sink) input
+    , conduitClose = return []
+    }
diff --git a/Data/Conduit/Util/Source.hs b/Data/Conduit/Util/Source.hs
--- a/Data/Conduit/Util/Source.hs
+++ b/Data/Conduit/Util/Source.hs
@@ -7,6 +7,7 @@
 -- on the base types.
 module Data.Conduit.Util.Source
     ( sourceState
+    , sourceStateIO
     , SourceStateResult (..)
     , sourceIO
     , SourceIOResult (..)
@@ -74,6 +75,32 @@
                 release key
                 return Closed
             IOOpen val -> return $ Open (src key state) val
+
+-- | A combination of 'sourceIO' and 'sourceState'.
+--
+-- Since 0.2.1
+sourceStateIO :: ResourceIO m
+              => IO state -- ^ resource and/or state allocation
+              -> (state -> IO ()) -- ^ resource and/or state cleanup
+              -> (state -> m (SourceStateResult state output)) -- ^ Pull function. Note that this need not explicitly perform any cleanup.
+              -> Source m output
+sourceStateIO alloc cleanup pull0 =
+    Source
+        { sourcePull = do
+            (key, state) <- withIO alloc cleanup
+            pull key state
+        , sourceClose = return ()
+        }
+  where
+    src key state = Source (pull key state) (release key)
+
+    pull key state = do
+        res <- lift $ pull0 state
+        case res of
+            StateClosed -> do
+                release key
+                return Closed
+            StateOpen state' val -> return $ Open (src key state') val
 
 -- | Transform the monad a 'Source' lives in.
 --
diff --git a/conduit.cabal b/conduit.cabal
--- a/conduit.cabal
+++ b/conduit.cabal
@@ -1,5 +1,5 @@
 Name:                conduit
-Version:             0.2.0
+Version:             0.2.1
 Synopsis:            Streaming data processing library.
 Description:
 	Conduits are an approach to the streaming data problem. It is meant as an alternative to enumerators\/iterators, hoping to address the same issues with different trade-offs based on real-world experience with enumerators. For more information, see <http://www.yesodweb.com/book/conduit>.
diff --git a/test/main.hs b/test/main.hs
--- a/test/main.hs
+++ b/test/main.hs
@@ -11,6 +11,7 @@
 import qualified Data.Conduit.Binary as CB
 import qualified Data.Conduit.Text as CT
 import Data.Conduit (runResourceT)
+import Data.Maybe (fromMaybe)
 import qualified Data.List as DL
 import Control.Monad.ST (runST)
 import Data.Monoid
@@ -241,6 +242,34 @@
                             )
             nums <- CLazy.lazyConsume $ mconcat $ map incr [1..10]
             liftIO $ nums @?= [1..10]
+
+    describe "sequence" $ do
+        it "simple sink" $ do
+            let sumSink :: C.Resource m => C.Sink Int m Int
+                sumSink = do
+                    ma <- CL.head
+                    case ma of
+                        Nothing -> return 0
+                        Just a  -> (+a) . fromMaybe 0 <$> CL.head
+
+            res <- runResourceT $ CL.sourceList [1..11]
+                             C.$= C.sequence sumSink
+                             C.$$ CL.consume
+            res @?= [3, 7, 11, 15, 19, 11]
+
+        it "sink with unpull behaviour" $ do
+            let sumSink :: C.Resource m => C.Sink Int m Int
+                sumSink = do
+                    ma <- CL.head
+                    case ma of
+                        Nothing -> return 0
+                        Just a  -> (+a) . fromMaybe 0 <$> CL.peek
+
+            res <- runResourceT $ CL.sourceList [1..11]
+                             C.$= C.sequence sumSink
+                             C.$$ CL.consume
+            res @?= [3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 11]
+           
 
     describe "sequenceSink" $ do
         it "simple sink" $ do