diff --git a/changelog.md b/changelog.md
--- a/changelog.md
+++ b/changelog.md
@@ -1,3 +1,16 @@
+## 0.2.0.0 (2023-02-22)
+
+The "Examples" modules are no longer divided into "Interesting" and "Boring"
+modules in the public API, because this leads to too many breaking releases.
+
+`NonemptyFold` and `ShortcutNonemptyFold` now have their own `sum` and `product`
+definitions instead of being lifted variants of the `Fold` and `ShortcutFold`
+definitions. This makes it possible to use them with numeric types that do not
+include additive or multiplicative identity values. For example, we now have a
+test case which takes the sum over a non-empty list of positive integers. Since
+a "positive integer" type does not include zero, previously this would result in
+arithmetic underflow.
+
 ## 0.1.0.0 (2023-02-20)
 
 Adds `ShortcutFold` and `ShortcutNonemptyFold`.
diff --git a/gambler.cabal b/gambler.cabal
--- a/gambler.cabal
+++ b/gambler.cabal
@@ -1,7 +1,7 @@
 cabal-version: 3.0
 
 name: gambler
-version: 0.1.0.0
+version: 0.2.0.0
 
 category: Streaming
 synopsis: Composable, streaming, and efficient left folds
@@ -40,8 +40,6 @@
         Fold.Pure
         Fold.Pure.Conversion
         Fold.Pure.Examples
-        Fold.Pure.Examples.Interesting
-        Fold.Pure.Examples.Boring
         Fold.Pure.Run
         Fold.Pure.Type
         Fold.Pure.Utilities
@@ -49,8 +47,6 @@
         Fold.Effectful
         Fold.Effectful.Conversion
         Fold.Effectful.Examples
-        Fold.Effectful.Examples.Interesting
-        Fold.Effectful.Examples.Boring
         Fold.Effectful.Run
         Fold.Effectful.Type
         Fold.Effectful.Utilities
@@ -58,8 +54,6 @@
         Fold.Nonempty
         Fold.Nonempty.Conversion
         Fold.Nonempty.Examples
-        Fold.Nonempty.Examples.Interesting
-        Fold.Nonempty.Examples.Boring
         Fold.Nonempty.Run
         Fold.Nonempty.Type
         Fold.Nonempty.Utilities
@@ -68,8 +62,6 @@
         Fold.Shortcut.Run
         Fold.Shortcut.Type
         Fold.Shortcut.Examples
-        Fold.Shortcut.Examples.Interesting
-        Fold.Shortcut.Examples.Boring
         Fold.Shortcut.Conversion
         Fold.Shortcut.Utilities
 
@@ -77,14 +69,27 @@
         Fold.ShortcutNonempty.Run
         Fold.ShortcutNonempty.Type
         Fold.ShortcutNonempty.Examples
-        Fold.ShortcutNonempty.Examples.Interesting
-        Fold.ShortcutNonempty.Examples.Boring
         Fold.ShortcutNonempty.Conversion
         Fold.ShortcutNonempty.Utilities
 
     other-modules:
         Strict
 
+        Fold.Pure.Examples.Interesting
+        Fold.Pure.Examples.Boring
+
+        Fold.Effectful.Examples.Interesting
+        Fold.Effectful.Examples.Boring
+
+        Fold.Nonempty.Examples.Interesting
+        Fold.Nonempty.Examples.Boring
+
+        Fold.Shortcut.Examples.Interesting
+        Fold.Shortcut.Examples.Boring
+
+        Fold.ShortcutNonempty.Examples.Interesting
+        Fold.ShortcutNonempty.Examples.Boring
+
 test-suite test-gambler
     import: base
     hs-source-dirs: test
@@ -96,6 +101,7 @@
         Spec.Effectful
         Spec.Shortcut
         Spec.ShortcutNonempty
+        Positive
     ghc-options:
         -threaded
     default-extensions:
diff --git a/source/Fold.hs b/source/Fold.hs
--- a/source/Fold.hs
+++ b/source/Fold.hs
@@ -27,7 +27,7 @@
 import Fold.ShortcutNonempty.Type
 
 import Fold.Effectful.Examples.Interesting
-import Fold.Nonempty.Examples.Interesting hiding (list, reverseList)
+import Fold.Nonempty.Examples.Interesting hiding (list, reverseList, sum, product)
 import Fold.Pure.Examples.Interesting
 import Fold.Shortcut.Examples.Interesting
 import Fold.ShortcutNonempty.Examples.Interesting
diff --git a/source/Fold/Nonempty/Examples/Boring.hs b/source/Fold/Nonempty/Examples/Boring.hs
--- a/source/Fold/Nonempty/Examples/Boring.hs
+++ b/source/Fold/Nonempty/Examples/Boring.hs
@@ -5,7 +5,7 @@
     {- * Monoid -} monoid,
     {- * Length -} length,
     {- * Boolean -} and, or, all, any,
-    {- * Numeric -} sum, product, mean, variance, standardDeviation,
+    {- * Numeric -} mean, variance, standardDeviation,
     {- * Search -} element, notElement, find, lookup,
     {- * Index -} index, findIndex, elementIndex,
     {- * List -} list, reverseList,
@@ -18,7 +18,7 @@
 import Data.Monoid (Monoid)
 import Fold.Nonempty.Type (NonemptyFold)
 import Numeric.Natural (Natural)
-import Prelude (Floating, Fractional, Num)
+import Prelude (Floating, Fractional)
 
 import qualified Fold.Nonempty.Conversion as Convert
 import qualified Fold.Pure.Examples.Interesting as Pure
@@ -52,14 +52,6 @@
 {-| 'True' if any input satisfies the predicate -}
 any :: (a -> Bool) -> NonemptyFold a Bool
 any predicate = Convert.shortcutFold (Shortcut.any predicate)
-
-{-| Adds the inputs -}
-sum :: Num a => NonemptyFold a a
-sum = Convert.fold Pure.sum
-
-{-| Multiplies the inputs -}
-product :: Num a => NonemptyFold a a
-product = Convert.fold Pure.product
 
 {-| Numerically stable arithmetic mean of the inputs -}
 mean :: Fractional a => NonemptyFold a a
diff --git a/source/Fold/Nonempty/Examples/Interesting.hs b/source/Fold/Nonempty/Examples/Interesting.hs
--- a/source/Fold/Nonempty/Examples/Interesting.hs
+++ b/source/Fold/Nonempty/Examples/Interesting.hs
@@ -3,6 +3,7 @@
     {- * General -} magma, semigroup,
     {- * Endpoints -} last,
     {- * Extrema -} maximum, minimum, maximumBy, minimumBy,
+    {- * Numeric -} sum, product,
     {- * List -} list, reverseList,
   )
   where
@@ -13,6 +14,7 @@
 import Data.List.NonEmpty (NonEmpty ((:|)))
 import Data.Ord (Ord, Ordering (GT), max, min)
 import Data.Semigroup (Semigroup, (<>))
+import Prelude (Num, (+), (*))
 
 import qualified Strict
 
@@ -44,6 +46,14 @@
 {-| The least input with respect to the given comparison function -}
 minimumBy :: (a -> a -> Ordering) -> NonemptyFold a a
 minimumBy cmp = magma (\x y -> case cmp x y of { GT -> y; _ -> x })
+
+{-| Adds the inputs -}
+sum :: Num a => NonemptyFold a a
+sum = magma (+)
+
+{-| Multiplies the inputs -}
+product :: Num a => NonemptyFold a a
+product = magma (*)
 
 {-| All the inputs -}
 list :: NonemptyFold a (NonEmpty a)
diff --git a/source/Fold/ShortcutNonempty/Examples/Boring.hs b/source/Fold/ShortcutNonempty/Examples/Boring.hs
--- a/source/Fold/ShortcutNonempty/Examples/Boring.hs
+++ b/source/Fold/ShortcutNonempty/Examples/Boring.hs
@@ -55,11 +55,11 @@
 
 {-| Adds the inputs (ambivalent) -}
 sum :: Num a => ShortcutNonemptyFold a a
-sum = Convert.fold Pure.sum
+sum = Convert.nonemptyFold Nonempty.sum
 
 {-| Multiplies the inputs (ambivalent) -}
 product :: Num a => ShortcutNonemptyFold a a
-product = Convert.fold Pure.product
+product = Convert.nonemptyFold Nonempty.product
 
 {-| Numerically stable arithmetic mean of the inputs (ambivalent) -}
 mean :: Fractional a => ShortcutNonemptyFold a a
diff --git a/source/Fold/ShortcutNonempty/Examples/Interesting.hs b/source/Fold/ShortcutNonempty/Examples/Interesting.hs
--- a/source/Fold/ShortcutNonempty/Examples/Interesting.hs
+++ b/source/Fold/ShortcutNonempty/Examples/Interesting.hs
@@ -1,4 +1,8 @@
-module Fold.ShortcutNonempty.Examples.Interesting where
+module Fold.ShortcutNonempty.Examples.Interesting
+  (
+    {- * First/last -} first,
+  )
+  where
 
 import Fold.ShortcutNonempty.Type
 
diff --git a/test/Positive.hs b/test/Positive.hs
new file mode 100644
--- /dev/null
+++ b/test/Positive.hs
@@ -0,0 +1,127 @@
+module Positive (Positive) where
+
+import Prelude (($), Enum, Eq, Ord, Show, (.), id)
+
+import Numeric.Natural (Natural)
+import Prelude (Int, Integer, Integral, Num, Real)
+
+import qualified Control.Exception as Exception
+import qualified Data.Bits as Bits
+import qualified Data.List as List
+import qualified Data.Maybe as Maybe
+import qualified Data.Ord as Ord
+import qualified Prelude as Enum (Enum (..))
+import qualified Prelude as Num (Integral (..), Num (..), Real (..), fromIntegral)
+import qualified Text.Show as Show
+
+newtype Positive = FromNatural{ toNatural :: Natural } deriving (Eq, Ord)
+
+fromNatural :: Natural -> Positive
+fromNatural = FromNatural
+
+fromNaturalChecked :: Natural -> Positive
+fromNaturalChecked x = case x of 0 -> Exception.throw Exception.Underflow; _ -> fromNatural x
+
+toInteger :: Positive -> Integer
+toInteger = Num.toInteger . toNatural
+
+fromInteger :: Integer -> Positive
+fromInteger = fromNatural . Num.fromInteger
+
+fromIntegerChecked :: Integer -> Positive
+fromIntegerChecked x = if x Ord.>= 1 then fromInteger x else Exception.throw Exception.Underflow
+
+add :: Positive -> Positive -> Positive
+add a b = fromNatural (toNatural a Num.+ toNatural b)
+
+subtract :: Positive -> Positive -> Positive
+subtract a b = fromNatural (toNatural a Num.- toNatural b)
+
+subtractChecked :: Positive -> Positive -> Positive
+subtractChecked a b = if a Ord.> b then subtract a b else Exception.throw Exception.Underflow
+
+multiply :: Positive -> Positive -> Positive
+multiply a b = fromNatural (toNatural a Num.* toNatural b)
+
+addOne :: Positive -> Positive
+addOne = fromNatural . (Num.+ 1) . toNatural
+
+subtractOne :: Positive -> Positive
+subtractOne = fromNatural . (Num.- 1) . toNatural
+
+subtractOneChecked :: Positive -> Positive
+subtractOneChecked x = case x of { 1 -> Exception.throw Exception.Underflow; _ -> subtractOne x }
+
+toIntChecked :: Positive -> Int
+toIntChecked = Maybe.fromMaybe (Exception.throw Exception.Overflow) . Bits.toIntegralSized . toNatural
+
+fromInt :: Int -> Positive
+fromInt = fromNatural . Num.fromIntegral
+
+fromIntChecked :: Int -> Positive
+fromIntChecked x = case Num.signum x of { 1 -> fromInt x; _ -> Exception.throw Exception.Underflow }
+
+enumFrom :: Positive -> [Positive]
+enumFrom = List.map fromNatural . Enum.enumFrom . toNatural
+
+enumFromTo :: Positive -> Positive -> [Positive]
+enumFromTo a b = List.map fromNatural $ Enum.enumFromTo (toNatural a) (toNatural b)
+
+enumFromThen :: Positive -> Positive -> [Positive]
+enumFromThen a b = if a Ord.< b then ascending else descending
+  where
+    ascending = List.map fromNatural $ Enum.enumFromThen (toNatural a) (toNatural b)
+    descending = List.map fromInteger $ List.takeWhile (Ord.>= 1) $
+        Enum.enumFromThen (toInteger a) (toInteger b)
+
+enumFromThenTo :: Positive -> Positive -> Positive -> [Positive]
+enumFromThenTo a b c = if a Ord.< b then ascending else descending
+  where
+    ascending = List.map fromNatural $ Enum.enumFromThenTo (toNatural a) (toNatural b) (toNatural c)
+    descending = List.map fromInteger $ List.takeWhile (Ord.>= 1) $
+        Enum.enumFromThenTo (toInteger a) (toInteger b) (toInteger c)
+
+type Div a = a -> a -> (a, a)
+
+divisionOp :: Div Natural -> Div Positive
+divisionOp o a b =
+    let (q, r) = o (toNatural a) (toNatural b)
+    in (fromNaturalChecked q, fromNaturalChecked r)
+
+instance Num Positive
+  where
+    abs = id
+    negate = \_ -> Exception.throw Exception.Underflow
+    signum = \_ -> fromNatural 1
+    fromInteger = fromIntegerChecked
+    (+) = add
+    (*) = multiply
+    (-) = subtractChecked
+
+instance Enum Positive
+  where
+    succ = addOne
+    pred = subtractOneChecked
+
+    fromEnum = toIntChecked
+    toEnum = fromIntChecked
+
+    enumFrom = enumFrom
+    enumFromTo = enumFromTo
+    enumFromThen = enumFromThen
+    enumFromThenTo = enumFromThenTo
+
+instance Real Positive
+  where
+    toRational = Num.toRational . toInteger
+
+instance Integral Positive
+  where
+    toInteger = toInteger
+    quotRem = divisionOp Num.quotRem
+    divMod = divisionOp Num.divMod
+
+instance Show Positive
+  where
+    show = Show.show . toNatural
+    showsPrec i = Show.showsPrec i . toNatural
diff --git a/test/Spec/Nonempty.hs b/test/Spec/Nonempty.hs
--- a/test/Spec/Nonempty.hs
+++ b/test/Spec/Nonempty.hs
@@ -5,6 +5,7 @@
 import Test.Hspec
 
 import Data.List.NonEmpty (NonEmpty ((:|)))
+import Positive (Positive)
 import Prelude (String, Integer)
 
 spec :: SpecWith ()
@@ -34,3 +35,9 @@
         describe "reverseList" do
             it "gets all inputs in reverse" do
                 run reverseList xs `shouldBe` [4, 3, 2, 1]
+
+    describe "sum/product" do
+        it "sum works with Positive" do
+            run sum [1,2,5] `shouldBe` (8 :: Positive)
+        it "product works with Positive" do
+            run product [1,2,5] `shouldBe` (10 :: Positive)
diff --git a/test/Spec/ShortcutNonempty.hs b/test/Spec/ShortcutNonempty.hs
--- a/test/Spec/ShortcutNonempty.hs
+++ b/test/Spec/ShortcutNonempty.hs
@@ -4,12 +4,13 @@
 
 import Test.Hspec
 
-import Control.Applicative (pure, (<$>), (<*>))
-import Prelude (Integer, undefined)
-import Data.List.NonEmpty (NonEmpty ((:|)))
-import Data.Maybe (Maybe (Just))
+import Control.Applicative (pure, (<$>), (<*>), liftA2)
 import Data.Bool (Bool (..))
 import Data.List ((++))
+import Data.List.NonEmpty (NonEmpty ((:|)))
+import Data.Maybe (Maybe (Just))
+import Positive (Positive)
+import Prelude (Integer, undefined)
 
 import qualified Data.Char as Char
 
@@ -57,3 +58,9 @@
             run or [True,False] `shouldBe` True
         it "is lazy" do
             run or (True :| undefined) `shouldBe` True
+
+    describe "sum/product" do
+        it "sum works with Positive" do
+            run (liftA2 (,) (index 2) sum) [1,2,5,7] `shouldBe` (Just 5, 8 :: Positive)
+        it "product works with Positive" do
+            run (liftA2 (,) (index 2) product) [1,2,5,3] `shouldBe` (Just 5, 10 :: Positive)