diff --git a/ChangeLog.md b/ChangeLog.md
new file mode 100644
--- /dev/null
+++ b/ChangeLog.md
@@ -0,0 +1,4 @@
+__0.10.2__
+
+* Provide `foldMap` and `fold` as synonyms for `concatMap` and `concat`.
+* Switch to more general `Traversable`-based functions (`sequence_` in particular).
diff --git a/ClassyPrelude.hs b/ClassyPrelude.hs
--- a/ClassyPrelude.hs
+++ b/ClassyPrelude.hs
@@ -77,15 +77,16 @@
     , map
     , concat
     , concatMap
+    , foldMap
+    , fold
     , length
     , null
     , pack
     , unpack
     , repack
     , toList
-    , Traversable.mapM
     , mapM_
-    , Traversable.forM
+    , sequence_
     , forM_
     , any
     , all
@@ -161,15 +162,14 @@
 import qualified Prelude
 import Control.Exception (assert)
 import Control.Exception.Enclosed
-import Control.Monad (when, unless, void, liftM, ap, forever, join, sequence, sequence_, replicateM_, guard, MonadPlus (..), (=<<), (>=>), (<=<), liftM2, liftM3, liftM4, liftM5)
+import Control.Monad (when, unless, void, liftM, ap, forever, join, replicateM_, guard, MonadPlus (..), (=<<), (>=>), (<=<), liftM2, liftM3, liftM4, liftM5)
 import Control.Concurrent.MVar.Lifted
 import Control.Concurrent.Chan.Lifted
 import Control.Concurrent.STM hiding (atomically, always, alwaysSucceeds, retry, orElse, check)
 import qualified Control.Concurrent.STM as STM
 import Data.IORef.Lifted
 import qualified Data.Monoid as Monoid
-import qualified Data.Traversable as Traversable
-import Data.Traversable (Traversable)
+import Data.Traversable (Traversable (..), for, forM)
 import Data.Foldable (Foldable)
 import Data.IOData (IOData (..))
 import Control.Monad.Catch (MonadThrow (throwM), MonadCatch, MonadMask)
@@ -291,7 +291,16 @@
 
 concatMap :: (Monoid m, MonoFoldable c) => (Element c -> m) -> c -> m
 concatMap = ofoldMap
+{-# INLINE concatMap #-}
 
+foldMap :: (Monoid m, MonoFoldable c) => (Element c -> m) -> c -> m
+foldMap = ofoldMap
+{-# INLINE foldMap #-}
+
+fold :: (Monoid (Element c), MonoFoldable c) => c -> Element c
+fold = ofoldMap id
+{-# INLINE fold #-}
+
 foldr :: MonoFoldable c => (Element c -> b -> b) -> b -> c -> b
 foldr = ofoldr
 
@@ -560,3 +569,7 @@
 -- Since 0.9.2
 unlessM :: Monad m => m Bool -> m () -> m ()
 unlessM mbool action = mbool >>= flip unless action
+
+sequence_ :: (Monad m, MonoFoldable mono, Element mono ~ (m a)) => mono -> m ()
+sequence_ = mapM_ (>> return ())
+{-# INLINE sequence_ #-}
diff --git a/classy-prelude.cabal b/classy-prelude.cabal
--- a/classy-prelude.cabal
+++ b/classy-prelude.cabal
@@ -1,5 +1,5 @@
 name:                classy-prelude
-version:             0.10.1
+version:             0.10.2
 synopsis:            A typeclass-based Prelude.
 description:         Focuses on using common typeclasses when possible, and creating new ones to avoid name clashing. Exposes many recommended datastructures (Map, ByteString, etc) directly without requiring long import lists and qualified modules.
 homepage:            https://github.com/snoyberg/classy-prelude
@@ -10,6 +10,7 @@
 category:            Control, Prelude
 build-type:          Simple
 cabal-version:       >=1.8
+extra-source-files:  ChangeLog.md
 
 library
   exposed-modules:     ClassyPrelude