diff --git a/deferred-folds.cabal b/deferred-folds.cabal
--- a/deferred-folds.cabal
+++ b/deferred-folds.cabal
@@ -1,7 +1,7 @@
 name:
   deferred-folds
 version:
-  0.2.3
+  0.3
 category:
   Folding
 synopsis:
diff --git a/library/DeferredFolds/FoldlMView.hs b/library/DeferredFolds/FoldlMView.hs
--- a/library/DeferredFolds/FoldlMView.hs
+++ b/library/DeferredFolds/FoldlMView.hs
@@ -8,24 +8,24 @@
 {-|
 A monadic variation of "DeferredFolds.FoldView"
 -}
-newtype FoldlMView input =
-  FoldlMView (forall m output. Monad m => (output -> input -> m output) -> output -> m output)
+newtype FoldlMView m input =
+  FoldlMView (forall output. (output -> input -> m output) -> output -> m output)
 
-deriving instance Functor FoldlMView
+deriving instance Functor m => Functor (FoldlMView m)
 
-instance Applicative FoldlMView where
+instance Monad m => Applicative (FoldlMView m) where
   pure x =
     FoldlMView (\ step init -> step init x)
   (<*>) = ap
 
-instance Alternative FoldlMView where
+instance Monad m => Alternative (FoldlMView m) where
   empty =
     FoldlMView (const return)
   {-# INLINE (<|>) #-}
   (<|>) (FoldlMView left) (FoldlMView right) =
     FoldlMView (\ step init -> left step init >>= right step)
 
-instance Monad FoldlMView where
+instance Monad m => Monad (FoldlMView m) where
   return = pure
   (>>=) (FoldlMView left) rightK =
     FoldlMView $ \ step init ->
@@ -36,20 +36,20 @@
             right step output
       in left newStep init
 
-instance MonadPlus FoldlMView where
+instance Monad m => MonadPlus (FoldlMView m) where
   mzero = empty
   mplus = (<|>)
 
-instance Semigroup (FoldlMView a) where
+instance Monad m => Semigroup (FoldlMView m a) where
   (<>) = (<|>)
 
-instance Monoid (FoldlMView a) where
+instance Monad m => Monoid (FoldlMView m a) where
   mempty = empty
   mappend = (<>)
 
 {-| Perform a strict left fold -}
 {-# INLINE foldl' #-}
-foldl' :: (output -> input -> output) -> output -> FoldlMView input -> output
+foldl' :: (output -> input -> output) -> output -> FoldlMView Identity input -> output
 foldl' step init (FoldlMView run) =
   runIdentity (run identityStep init)
   where
@@ -57,18 +57,18 @@
 
 {-| Perform a monadic strict left fold -}
 {-# INLINE foldlM' #-}
-foldlM' :: Monad m => (output -> input -> m output) -> output -> FoldlMView input -> m output
+foldlM' :: Monad m => (output -> input -> m output) -> output -> FoldlMView m input -> m output
 foldlM' step init (FoldlMView run) =
   run step init
 
 {-| Apply a Gonzalez fold -}
 {-# INLINE fold #-}
-fold :: Fold input output -> FoldlMView input -> output
+fold :: Fold input output -> FoldlMView Identity input -> output
 fold (Fold step init extract) = extract . foldl' step init
 
 {-| Apply a monadic Gonzalez fold -}
 {-# INLINE foldM #-}
-foldM :: Monad m => FoldM m input output -> FoldlMView input -> m output
+foldM :: Monad m => FoldM m input output -> FoldlMView m input -> m output
 foldM (FoldM step init extract) view =
   do
     initialState <- init
@@ -77,11 +77,11 @@
 
 {-| Construct from any foldable -}
 {-# INLINE foldable #-}
-foldable :: Foldable foldable => foldable a -> FoldlMView a
+foldable :: (Monad m, Foldable foldable) => foldable a -> FoldlMView m a
 foldable foldable = FoldlMView (\ step init -> A.foldlM step init foldable)
 
 {-| Ints in the specified inclusive range -}
-intsInRange :: Int -> Int -> FoldlMView Int
+intsInRange :: Monad m => Int -> Int -> FoldlMView m Int
 intsInRange from to =
   FoldlMView $ \ step init ->
   let