diff --git a/list-transformer.cabal b/list-transformer.cabal
--- a/list-transformer.cabal
+++ b/list-transformer.cabal
@@ -1,5 +1,5 @@
 name:                list-transformer
-version:             1.0.1
+version:             1.0.2
 synopsis:            List monad transformer
 description:         This library provides a list monad transformer that
                      enriches lists with effects and streams efficiently in
diff --git a/src/List/Transformer.hs b/src/List/Transformer.hs
--- a/src/List/Transformer.hs
+++ b/src/List/Transformer.hs
@@ -167,6 +167,14 @@
     Whichever one you prefer, all three variations still stream in constant
     space (unlike @"Control.Monad".`mapM`@, which buffers the entire output
     list before returning a single element).
+
+    This library is designed to stream results in constant space and does not
+    expose an obvious way to collect all the results into memory.  As a rule of
+    thumb if you think you need to collect all the results in memory try to
+    instead see if you can consume the results as they are being generated (such
+    as in all the above examples).  If you can stream the data from start to
+    finish then your code will use significantly less memory and your program
+    will become more responsive.
 -}
 module List.Transformer
     ( -- * ListT
@@ -177,6 +185,7 @@
     , select
     , take
     , drop
+    , takeWhile
     , unfold
     , zip
 
@@ -200,10 +209,13 @@
 #endif
 import Control.Monad (MonadPlus(..))
 import Control.Monad.Error.Class (MonadError(..))
+#if MIN_VERSION_base(4,9,0)
+import Control.Monad.Fail (MonadFail(..))
+#endif
 import Control.Monad.State.Class (MonadState(..))
 import Control.Monad.Reader.Class (MonadReader(..))
 import Control.Monad.Trans (MonadTrans(..), MonadIO(..))
-import Prelude hiding (drop, take, zip)
+import Prelude hiding (drop, pred, take, takeWhile, zip)
 
 import qualified Data.Foldable
 
@@ -269,6 +281,8 @@
             Nil       -> return Nil
             Cons x l' -> next (k x <|> (l' >>= k)) )
 
+    fail _ = mzero
+
 instance Monad m => Alternative (ListT m) where
     empty = ListT (return Nil)
 
@@ -283,6 +297,11 @@
 
     mplus = (<|>)
 
+#if MIN_VERSION_base(4,9,0)
+instance Monad m => MonadFail (ListT m) where
+    fail _ = mzero
+#endif
+
 instance (Monad m, Monoid a) => Monoid (ListT m a) where
     mempty  = pure mempty
     mappend = liftA2 mappend
@@ -466,6 +485,22 @@
         case s of
             Cons _ l' -> next (drop (n-1) l')
             Nil       -> return Nil)
+
+-- | @takeWhile pred xs@ takes elements from @xs@ until the predicate @pred@ fails
+--
+-- >>> let list xs = do x <- select xs; liftIO (print (show x)); return x
+-- >>> let sum = fold (+) 0 id
+-- >>> sum (takeWhile even (list [2,4,5,7,8]))
+-- "2"
+-- "4"
+-- "5"
+-- 6
+takeWhile :: Monad m => (a -> Bool) -> ListT m a -> ListT m a
+takeWhile pred l = ListT (do
+    n <- next l
+    case n of
+        Cons x l' | pred x -> return (Cons x (takeWhile pred l'))
+        _                  -> return Nil )
 
 -- | @unfold step seed@ generates a 'ListT' from a @step@ function and an
 -- initial @seed@.