diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,7 @@
+# 0.0.1.1
+
+- Updated version bounds for dependencies.
+
 # 0.0.1.0
 
 - Added support for GHC 9.8.
diff --git a/monoidmap.cabal b/monoidmap.cabal
--- a/monoidmap.cabal
+++ b/monoidmap.cabal
@@ -1,6 +1,6 @@
 cabal-version:  3.0
 name:           monoidmap
-version:        0.0.1.0
+version:        0.0.1.1
 bug-reports:    https://github.com/jonathanknowles/monoidmap/issues
 license:        Apache-2.0
 license-file:   LICENSE
@@ -31,9 +31,9 @@
 common dependency-nonempty-containers
     build-depends:nonempty-containers           >= 0.3.4.4    && < 0.4
 common dependency-nothunks
-    build-depends:nothunks                      >= 0.1.3      && < 0.2
+    build-depends:nothunks                      >= 0.1.3      && < 0.3
 common dependency-pretty-show
-    build-depends:pretty-show                   >= 1.10       && < 1.20
+    build-depends:pretty-show                   >= 1.10       && < 1.11
 common dependency-QuickCheck
     build-depends:QuickCheck                    >= 2.14.2     && < 2.15
 common dependency-quickcheck-classes
@@ -174,6 +174,7 @@
         Data.MonoidMap.ValiditySpec
         Examples.MultiMapSpec
         Examples.RecoveredMapSpec
+        Test.Combinators.NonZero
         Test.Common
         Test.QuickCheck.Classes.Hspec
         Test.Hspec.Unit
diff --git a/src/test/Data/MonoidMap/ClassSpec.hs b/src/test/Data/MonoidMap/ClassSpec.hs
--- a/src/test/Data/MonoidMap/ClassSpec.hs
+++ b/src/test/Data/MonoidMap/ClassSpec.hs
@@ -9,10 +9,6 @@
 
 import Prelude
 
-import Data.Group
-    ( Group )
-import Data.Maybe
-    ( mapMaybe )
 import Data.Monoid
     ( Product (..), Sum (..) )
 import Data.Monoid.Null
@@ -21,8 +17,6 @@
     ( MonoidMap )
 import Data.Proxy
     ( Proxy (..) )
-import Data.Semigroup.Cancellative
-    ( Commutative )
 import Data.Set
     ( Set )
 import Data.Typeable
@@ -33,8 +27,10 @@
     ( Natural )
 import Test.Hspec
     ( Spec, describe )
+import Test.Combinators.NonZero
+    ( NonZero, genNonZero, shrinkNonZero )
 import Test.QuickCheck
-    ( Arbitrary (..), listOf, scale, shrinkMapBy, suchThatMap )
+    ( Arbitrary (..), listOf, scale, shrinkMapBy )
 import Test.QuickCheck.Classes
     ( eqLaws
     , isListLaws
@@ -157,7 +153,10 @@
             , semigroupMonoidLaws
             , showReadLaws
             ]
-        testLawsMany @(MonoidMap k (Wrapped (Product Rational)))
+        -- Here we restrict the generator and shrinker so that they can never
+        -- produce zero values, to avoid running into cases of ArithException
+        -- caused by operations that may produce zero demoninators:
+        testLawsMany @(MonoidMap k (NonZero (Product Rational)))
             [ commutativeLaws
             , eqLaws
             , groupLaws
@@ -340,16 +339,9 @@
 -- Arbitrary instances
 --------------------------------------------------------------------------------
 
-newtype Wrapped a = Wrapped a
-    deriving newtype (Eq, Num, Read, Show, IsList)
-    deriving newtype (Semigroup, Commutative, Monoid, MonoidNull, Group)
-
-instance Arbitrary (Wrapped (Product Rational)) where
-    -- Here we restrict the generator and shrinker so that they can never
-    -- produce zero values, to avoid running into cases of ArithException
-    -- caused by operations that may produce zero demoninators:
-    arbitrary = Wrapped <$> suchThatMap arbitrary maybeNonZero
-    shrink = mapMaybe maybeNonZero . shrink
+instance (Arbitrary a, Eq a, Num a) => Arbitrary (NonZero a) where
+    arbitrary = genNonZero arbitrary
+    shrink = shrinkNonZero shrink
 
 instance (Arbitrary k, Ord k, Arbitrary v, MonoidNull v) =>
     Arbitrary (MonoidMap k v)
@@ -358,12 +350,3 @@
         fromList <$> scale (`mod` 16) (listOf ((,) <$> arbitrary <*> arbitrary))
     shrink =
         shrinkMapBy MonoidMap.fromMap MonoidMap.toMap shrink
-
---------------------------------------------------------------------------------
--- Utilities
---------------------------------------------------------------------------------
-
-maybeNonZero :: (Eq a, Num a) => a -> Maybe a
-maybeNonZero p
-    | p == 0 = Nothing
-    | otherwise = Just p
diff --git a/src/test/Test/Combinators/NonZero.hs b/src/test/Test/Combinators/NonZero.hs
new file mode 100644
--- /dev/null
+++ b/src/test/Test/Combinators/NonZero.hs
@@ -0,0 +1,44 @@
+-- |
+-- Copyright: © 2022–2024 Jonathan Knowles
+-- License: Apache-2.0
+--
+module Test.Combinators.NonZero
+    ( NonZero
+    , genNonZero
+    , getNonZero
+    , maybeNonZero
+    , shrinkNonZero
+    )
+    where
+
+import Prelude
+
+import Data.Group
+    ( Group )
+import Data.Maybe
+    ( mapMaybe )
+import Data.Monoid.Null
+    ( MonoidNull )
+import Data.Semigroup.Cancellative
+    ( Commutative )
+import Test.QuickCheck
+    ( Gen, suchThatMap )
+
+-- | A combinator for non-zero values.
+newtype NonZero a = NonZero a
+    deriving newtype (Eq, Num, Read, Show)
+    deriving newtype (Semigroup, Commutative, Monoid, MonoidNull, Group)
+
+genNonZero :: (Eq a, Num a) => Gen a -> Gen (NonZero a)
+genNonZero genA = suchThatMap genA maybeNonZero
+
+getNonZero :: NonZero a -> a
+getNonZero (NonZero a) = a
+
+maybeNonZero :: (Eq a, Num a) => a -> Maybe (NonZero a)
+maybeNonZero p
+    | p == 0 = Nothing
+    | otherwise = Just (NonZero p)
+
+shrinkNonZero :: (Eq a, Num a) => (a -> [a]) -> NonZero a -> [NonZero a]
+shrinkNonZero shrinkA = mapMaybe maybeNonZero . shrinkA . getNonZero