diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Revision history for `control-block`
 
+## 0.0.2
+
+Includes support for `witherable-0.5` and adds new consistently-
+named versions of `foldl` and `foldr` for the matching `reduce`,
+as well as monadic `fold` and `reduce` leftwards and rightwards.
+
 ## 0.0.1
 
 Higher-order functions with their function arguments at the end,
diff --git a/control-block.cabal b/control-block.cabal
--- a/control-block.cabal
+++ b/control-block.cabal
@@ -1,6 +1,6 @@
 cabal-version:   3.0
 name:            control-block
-version:         0.0.1
+version:         0.0.2
 license:         BSD-2-Clause
 license-file:    LICENSE
 author:          Melanie Phoenix
@@ -28,6 +28,6 @@
   build-depends:
     , base                 >=4.14 && <5
     , indexed-traversable  >=0.1.3 && <0.2
-    , witherable           >=0.4.2 && <0.5
+    , witherable           >=0.4.2 && <0.6
 
   exposed-modules:    Control.Block
diff --git a/lib/Control/Block.hs b/lib/Control/Block.hs
--- a/lib/Control/Block.hs
+++ b/lib/Control/Block.hs
@@ -11,6 +11,7 @@
   , ichange
 
     -- * Applicative
+  , (<*>)
   , (<**>)
   , apply
   , through
@@ -36,10 +37,18 @@
   , ireduceA
 
     -- ** Without monoids
+  , foldL
   , reduceL
+  , foldL1
   , reduceL1
+  , foldR
   , reduceR
+  , foldR1
   , reduceR1
+  , foldLM
+  , reduceLM
+  , foldRM
+  , reduceRM
 
     -- * Traversable
   , traverse
@@ -83,6 +92,7 @@
 import Data.Foldable qualified as Fold
 import Data.Foldable.WithIndex
 import Data.Foldable1 (Foldable1, foldMap1, foldl1', toNonEmpty)
+import Data.Foldable1 qualified as Fold1
 import Data.Function
 import Data.Functor
 import Data.Functor.WithIndex
@@ -111,7 +121,7 @@
 through :: (Applicative f) => f x -> f (x -> y) -> f y
 through = (<**>)
 
--- | 'foldMap' through an 'Applicative' functor.
+-- | 'Fold.foldMap' through an 'Applicative' functor.
 foldMapA :: (Foldable t, Applicative f, Monoid m) => (x -> f m) -> t x -> f m
 foldMapA f = Fold.foldl' (\ !fm x -> liftA2 (<>) fm (f x)) (pure mempty)
 
@@ -132,7 +142,7 @@
 reduce1 :: (Foldable1 t, Semigroup s) => t x -> (x -> s) -> s
 reduce1 = flip foldMap1
 
--- | Flipped version of 'foldMap'.
+-- | Flipped version of 'Fold.foldMap'.
 reduce :: (Foldable t, Monoid m) => t x -> (x -> m) -> m
 reduce = flip Fold.foldMap
 
@@ -140,22 +150,60 @@
 ireduce :: (FoldableWithIndex i t, Monoid m) => t x -> (i -> x -> m) -> m
 ireduce = flip ifoldMap
 
--- | A version of 'foldl'' taking the accumulator first, then the @Foldable@.
+-- | Consistent name of 'Fold.foldl''.
+foldL :: (Foldable t) => (y -> x -> y) -> y -> t x -> y
+foldL = Fold.foldl'
+
+-- | A version of 'Fold.foldl'' taking the accumulator first, then the @Foldable@.
 reduceL :: (Foldable t) => y -> t x -> (y -> x -> y) -> y
 reduceL = flip . flip Fold.foldl'
 
--- | A version of 'foldl1'' taking the accumulator first, then the @Foldable1@.
+-- | Consistent name of 'Fold1.foldl1''.
+foldL1 :: (Foldable1 t) => (x -> x -> x) -> t x -> x
+foldL1 = Fold1.foldl1'
+
+-- | A version of 'Fold1.foldl1'' taking the accumulator first, then the @Foldable1@.
 reduceL1 :: (Foldable1 t) => t x -> (x -> x -> x) -> x
 reduceL1 = flip foldl1'
 
--- | A version of 'foldr' taking the accumulator first, then the @Foldable@.
+-- | Consistent name of 'foldM'.
+foldLM :: (Foldable t, Monad m) => (y -> x -> m y) -> y -> t x -> m y
+foldLM f z0 xs = Fold.foldr c pure xs z0
+ where
+  {-# INLINE c #-}
+  c x k z = f z x >>= k
+
+-- | A version of 'foldM' taking the accumulator first, then the @Foldable@,
+reduceLM :: (Foldable t, Monad m) => y -> t x -> (y -> x -> m y) -> m y
+reduceLM z0 xs f = foldLM f z0 xs
+
+-- | Consistent name of 'Fold.foldr'.
+foldR :: (Foldable t) => (x -> y -> y) -> y -> t x -> y
+foldR = Fold.foldr
+
+-- | A version of 'Fold.foldr' taking the accumulator first, then the @Foldable@.
 reduceR :: (Foldable t) => y -> t x -> (x -> y -> y) -> y
 reduceR = flip . flip Fold.foldr
 
--- | A version of 'foldr1' taking the accumulator first, then the @Foldable@.
+-- | Consistent name of 'Fold1.foldr1'.
+foldR1 :: (Foldable1 t) => (x -> x -> x) -> t x -> x
+foldR1 = Fold1.foldr1
+
+-- | A version of 'Fold.foldr1' taking the accumulator first, then the @Foldable@.
 reduceR1 :: (Foldable1 t) => t x -> (x -> x -> x) -> x
 reduceR1 = flip Fold.foldr1
 
+-- | Consistent name of 'Fold.foldrM'.
+foldRM :: (Foldable t, Monad m) => (x -> y -> m y) -> y -> t x -> m y
+foldRM f z0 xs = Fold.foldl c pure xs z0
+ where
+  {-# INLINE c #-}
+  c k x z = f x z >>= k
+
+-- | A version of 'foldRM' taking the accumulator first, then the @Foldable@.
+reduceRM :: (Foldable t, Monad m) => y -> t x -> (x -> y -> m y) -> m y
+reduceRM z0 xs f = foldRM f z0 xs
+
 -- | Flipped version of 'foldMapA'.
 reduceA :: (Foldable t, Applicative f, Monoid m) => t x -> (x -> f m) -> f m
 reduceA = flip foldMapA
@@ -197,7 +245,7 @@
 isift :: (FilterableWithIndex i t) => t x -> (i -> x -> Bool) -> t x
 isift = flip ifilter
 
--- | Flipped version of 'mapMaybe'.
+-- | Flipped version of 'Witherable.mapMaybe'.
 changeMaybe :: (Filterable t) => t x -> (x -> Maybe y) -> t y
 changeMaybe = flip Witherable.mapMaybe