diff --git a/src/main/scala/just/fp/Monoid.scala b/src/main/scala/just/fp/Monoid.scala
index 71426b2..47fb9c8 100644
--- a/src/main/scala/just/fp/Monoid.scala
+++ b/src/main/scala/just/fp/Monoid.scala
@@ -11,6 +11,8 @@ trait Monoid[A] extends SemiGroup[A] {
 
   def isZero(a: A)(implicit E: Equal[A]): Boolean = Equal[A].equal(a, zero)
 
+  def nonZero(a: A)(implicit E: Equal[A]): Boolean = !isZero(a)
+
   @SuppressWarnings(Array("org.wartremover.warts.ImplicitParameter"))
   trait MonoidLaw {
     /*
diff --git a/src/test/scala/just/fp/MonoidSpec.scala b/src/test/scala/just/fp/MonoidSpec.scala
index 65df4d6..b853e5c 100644
--- a/src/test/scala/just/fp/MonoidSpec.scala
+++ b/src/test/scala/just/fp/MonoidSpec.scala
@@ -21,6 +21,15 @@ object MonoidSpec extends Properties {
       "test OptionMonoid.isZero non-zero case"
     , propertyTestMonoidFunction("isZero", Gens.genIntFromMinToMax.map(_.some))(!_.isZero(_))
     )
+  , example(
+      "test OptionMonoid.nonZero zero case"
+    , testMonoidFunction("nonZero", none[Int])(!_.nonZero(_))
+    )
+  , property(
+      "test OptionMonoid.nonZero non-zero case"
+    , propertyTestMonoidFunction("nonZero", Gens.genIntFromMinToMax.map(_.some))(_.nonZero(_))
+    )
+
   , property("testListMonoidLaw", ListMonoidLaws.laws)
   , example(
       "test ListMonoid.isZero zero case"
@@ -30,6 +39,15 @@ object MonoidSpec extends Properties {
       "test ListMonoid.isZero non-zero case"
     , propertyTestMonoidFunction("isZero", Gens.genList(Gens.genIntFromMinToMax, 1, 10))(!_.isZero(_))
     )
+  , example(
+      "test ListMonoid.nonZero zero case"
+    , testMonoidFunction("nonZero", List.empty[Int])(!_.nonZero(_))
+    )
+  , property(
+      "test ListMonoid.nonZero non-zero case"
+    , propertyTestMonoidFunction("nonZero", Gens.genList(Gens.genIntFromMinToMax, 1, 10))(_.nonZero(_))
+    )
+
   , property("testVectorMonoidLaw", VectorMonoidLaws.laws)
   , example(
       "test VectorMonoid.isZero zero case"
@@ -39,6 +57,15 @@ object MonoidSpec extends Properties {
       "test VectorMonoid.isZero non-zero case"
     , propertyTestMonoidFunction("isZero", Gens.genVector(Gens.genIntFromMinToMax, 1, 10))(!_.isZero(_))
     )
+  , example(
+      "test VectorMonoid.nonZero zero case"
+    , testMonoidFunction("nonZero", Vector.empty[Int])(!_.nonZero(_))
+    )
+  , property(
+      "test VectorMonoid.nonZero non-zero case"
+    , propertyTestMonoidFunction("nonZero", Gens.genVector(Gens.genIntFromMinToMax, 1, 10))(_.nonZero(_))
+    )
+
   , property("testStringMonoidLaw", StringMonoidLaws.laws)
   , example(
       "test StringMonoid.isZero zero case"
@@ -48,6 +75,15 @@ object MonoidSpec extends Properties {
       "test StringMonoid.isZero non-zero case"
     , propertyTestMonoidFunction("isZero", Gen.constant("a").flatMap(c => Gens.genUnicodeString.map(c + _)))(!_.isZero(_))
     )
+  , example(
+      "test StringMonoid.nonZero zero case"
+    , testMonoidFunction("nonZero", "")(!_.nonZero(_))
+    )
+  , property(
+      "test StringMonoid.nonZero non-zero case"
+    , propertyTestMonoidFunction("nonZero", Gen.constant("a").flatMap(c => Gens.genUnicodeString.map(c + _)))(_.nonZero(_))
+    )
+
   , property("testByteMonoidLaw", ByteMonoidLaws.laws)
   , example(
       "test ByteMonoid.isZero zero case"
@@ -57,6 +93,15 @@ object MonoidSpec extends Properties {
       "test ByteMonoid.isZero non-zero case"
     , propertyTestMonoidFunction("isZero", Gens.genByte(1, Byte.MaxValue))(!_.isZero(_))
     )
+  , example(
+      "test ByteMonoid.nonZero zero case"
+    , testMonoidFunction("nonZero", 0.toByte)(!_.nonZero(_))
+    )
+  , property(
+      "test ByteMonoid.nonZero non-zero case"
+    , propertyTestMonoidFunction("nonZero", Gens.genByte(1, Byte.MaxValue))(_.nonZero(_))
+    )
+
   , property("testShortMonoidLaw", ShortMonoidLaws.laws)
   , example(
       "test ShortMonoid.isZero zero case"
@@ -66,6 +111,15 @@ object MonoidSpec extends Properties {
       "test ShortMonoid.isZero non-zero case"
     , propertyTestMonoidFunction("isZero", Gens.genShort(1, Short.MaxValue))(!_.isZero(_))
     )
+  , example(
+      "test ShortMonoid.nonZero zero case"
+    , testMonoidFunction("nonZero", 0.toShort)(!_.nonZero(_))
+    )
+  , property(
+      "test ShortMonoid.nonZero non-zero case"
+    , propertyTestMonoidFunction("nonZero", Gens.genShort(1, Short.MaxValue))(_.nonZero(_))
+    )
+
   , property("testCharMonoidLaw", CharMonoidLaws.laws)
   , example(
       "test CharMonoid.isZero zero case"
@@ -75,6 +129,15 @@ object MonoidSpec extends Properties {
       "test CharMonoid.isZero non-zero case"
     , propertyTestMonoidFunction("isZero", Gens.genChar(1, Char.MaxValue))(!_.isZero(_))
     )
+  , example(
+      "test CharMonoid.nonZero zero case"
+    , testMonoidFunction("nonZero", 0.toChar)(!_.nonZero(_))
+    )
+  , property(
+      "test CharMonoid.nonZero non-zero case"
+    , propertyTestMonoidFunction("nonZero", Gens.genChar(1, Char.MaxValue))(_.nonZero(_))
+    )
+
   , property("testIntMonoidLaw", IntMonoidLaws.laws)
   , example(
       "test IntMonoid.isZero zero case"
@@ -84,6 +147,15 @@ object MonoidSpec extends Properties {
       "test IntMonoid.isZero non-zero case"
     , propertyTestMonoidFunction("isZero", Gens.genInt(1, Int.MaxValue))(!_.isZero(_))
     )
+  , example(
+      "test IntMonoid.nonZero zero case"
+    , testMonoidFunction("nonZero", 0)(!_.nonZero(_))
+    )
+  , property(
+      "test IntMonoid.nonZero non-zero case"
+    , propertyTestMonoidFunction("nonZero", Gens.genInt(1, Int.MaxValue))(_.nonZero(_))
+    )
+
   , property("testLongMonoidLaw", LongMonoidLaws.laws)
   , example(
       "test LongMonoid.isZero zero case"
@@ -93,6 +165,15 @@ object MonoidSpec extends Properties {
       "test LongMonoid.isZero non-zero case"
     , propertyTestMonoidFunction("isZero", Gens.genLong(1L, Long.MaxValue))(!_.isZero(_))
     )
+  , example(
+      "test LongMonoid.nonZero zero case"
+    , testMonoidFunction("nonZero", 0L)(!_.nonZero(_))
+    )
+  , property(
+      "test LongMonoid.nonZero non-zero case"
+    , propertyTestMonoidFunction("nonZero", Gens.genLong(1L, Long.MaxValue))(_.nonZero(_))
+    )
+
   , property("testBigIntMonoidLaw", BigIntMonoidLaws.laws)
   , example(
       "test BigIntMonoid.isZero zero case"
@@ -102,6 +183,15 @@ object MonoidSpec extends Properties {
       "test BigIntMonoid.isZero non-zero case"
     , propertyTestMonoidFunction("isZero", Gens.genBigInt(1L, Long.MaxValue))(!_.isZero(_))
     )
+  , example(
+      "test BigIntMonoid.nonZero zero case"
+    , testMonoidFunction("nonZero", BigInt(0))(!_.nonZero(_))
+    )
+  , property(
+      "test BigIntMonoid.nonZero non-zero case"
+    , propertyTestMonoidFunction("nonZero", Gens.genBigInt(1L, Long.MaxValue))(_.nonZero(_))
+    )
+
   , property("testBigDecimalMonoidLaw", BigDecimalMonoidLaws.laws)
   , example(
       "test BigDecimalMonoid.isZero zero case"
@@ -111,6 +201,14 @@ object MonoidSpec extends Properties {
       "test BigDecimalMonoid.isZero non-zero case"
     , propertyTestMonoidFunction("isZero", Gens.genBigDecimal(1F, Float.MaxValue, 1L, Long.MaxValue))(!_.isZero(_))
     )
+  , example(
+      "test BigDecimalMonoid.nonZero zero case"
+    , testMonoidFunction("nonZero", BigDecimal(0))(!_.nonZero(_))
+    )
+  , property(
+      "test BigDecimalMonoid.nonZero non-zero case"
+    , propertyTestMonoidFunction("nonZero", Gens.genBigDecimal(1F, Float.MaxValue, 1L, Long.MaxValue))(_.nonZero(_))
+    )
   )
 
   def testMonoidFunction[A : Monoid : Equal](name: String, monoid: A)(f: (Monoid[A], A) => Boolean): Result = {