diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,9 @@
 # Revision history for javelin
 
+## Release 0.1.3.1
+
+* Improved performance for the `Foldable` methods that use `Data.Foldable.foldMap'` under the hood.
+
 ## Release 0.1.3.0
 
 * Improved performance for the `aggregateWith` function.
diff --git a/javelin.cabal b/javelin.cabal
--- a/javelin.cabal
+++ b/javelin.cabal
@@ -1,6 +1,6 @@
 cabal-version:      3.0
 name:               javelin
-version:            0.1.3.0
+version:            0.1.3.1
 synopsis:           Labeled one-dimensional arrays
 license:            MIT
 license-file:       LICENSE
@@ -77,7 +77,7 @@
                       Test.Data.Series.Generic.Definition
                       Test.Data.Series.Generic.View
                       Test.Data.Series.Generic.Zip
-    build-depends:    base,
+    build-depends:    base>=4.15.0.0 && <4.20,
                       containers,
                       foldl,
                       hedgehog,
@@ -99,7 +99,7 @@
     ghc-options:      -rtsopts
     hs-source-dirs:   benchmarks
     main-is:          Comparison.hs
-    build-depends:    base >=4.15.0.0 && <4.20,
+    build-depends:    base>=4.15.0.0 && <4.20,
                       containers,
                       foldl,
                       mono-traversable,
diff --git a/src/Data/Series/Generic/Definition.hs b/src/Data/Series/Generic/Definition.hs
--- a/src/Data/Series/Generic/Definition.hs
+++ b/src/Data/Series/Generic/Definition.hs
@@ -516,71 +516,71 @@
 -- Series to have performance characteristics
 -- be as close as possible to boxed vectors 
 instance (Foldable v) => Foldable (Series v k) where
-    {-# INLINABLE fold #-}
+    {-# INLINE fold #-}
     fold :: Monoid m => Series v k m -> m
     fold = Foldable.fold . values
 
-    {-# INLINABLE foldMap #-}
+    {-# INLINE foldMap #-}
     foldMap :: (Monoid m) => (a -> m) -> Series v k a -> m
     foldMap f = Foldable.foldMap f . values
 
-    {-# INLINABLE foldMap' #-}
+    {-# INLINE foldMap' #-}
     foldMap' :: (Monoid m) => (a -> m) -> Series v k a -> m
-    foldMap' f = Foldable.foldMap f . values
+    foldMap' f = Foldable.foldMap' f . values
 
-    {-# INLINABLE foldr #-}
+    {-# INLINE foldr #-}
     foldr :: (a -> b -> b) -> b -> Series v k a -> b
     foldr f i = Foldable.foldr f i . values
 
-    {-# INLINABLE foldr' #-}
+    {-# INLINE foldr' #-}
     foldr' :: (a -> b -> b) -> b -> Series v k a -> b
     foldr' f i = Foldable.foldr' f i . values
 
-    {-# INLINABLE foldl #-}
+    {-# INLINE foldl #-}
     foldl :: (b -> a -> b) -> b -> Series v k a -> b
     foldl f i = Foldable.foldl f i . values
 
-    {-# INLINABLE foldl' #-}
+    {-# INLINE foldl' #-}
     foldl' :: (b -> a -> b) -> b -> Series v k a -> b
     foldl' f i = Foldable.foldl' f i . values
 
-    {-# INLINABLE foldr1 #-}
+    {-# INLINE foldr1 #-}
     foldr1 :: (a -> a -> a) -> Series v k a -> a
     foldr1 f = Foldable.foldr1 f . values
 
-    {-# INLINABLE foldl1 #-}
+    {-# INLINE foldl1 #-}
     foldl1 :: (a -> a -> a) -> Series v k a -> a
     foldl1 f = Foldable.foldl1 f . values
 
-    {-# INLINABLE toList #-}
+    {-# INLINE toList #-}
     toList :: Series v k a -> [a]
     toList = Foldable.toList . values
 
-    {-# INLINABLE null #-}
+    {-# INLINE null #-}
     null :: Series v k a -> Bool
     null = Foldable.null . values
 
-    {-# INLINABLE length #-}
+    {-# INLINE length #-}
     length :: Series v k a -> Int
     length = Foldable.length . values
 
-    {-# INLINABLE elem #-}
+    {-# INLINE elem #-}
     elem :: Eq a => a -> Series v k a -> Bool
     elem e = Foldable.elem e . values
 
-    {-# INLINABLE maximum #-}
+    {-# INLINE maximum #-}
     maximum :: Ord a => Series v k a -> a
     maximum = Foldable.maximum . values
 
-    {-# INLINABLE minimum #-}
+    {-# INLINE minimum #-}
     minimum :: Ord a => Series v k a -> a
     minimum = Foldable.minimum . values
 
-    {-# INLINABLE sum #-}
+    {-# INLINE sum #-}
     sum :: Num a => Series v k a -> a
     sum = Foldable.sum . values
 
-    {-# INLINABLE product #-}
+    {-# INLINE product #-}
     product :: Num a => Series v k a -> a
     product = Foldable.product . values