diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Revision history for monoid-map
 
+## v0.2.0.0
+
+* Add support for DecidablyEmpty
+* Get rid of invalid Functor, Traversable, and Filterable instances; create TypeError for Functor instance
+* Use Commutative from commutative-semigroups instead of now-deprecated Additive from patch
+
 ## v0.1.1.0
 
 * Remove dependency on `appendmap`
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -1,5 +1,5 @@
 # monoid-map
-[![Haskell](https://img.shields.io/badge/language-Haskell-orange.svg)](https://haskell.org) [![Hackage](https://img.shields.io/hackage/v/monoid-map.svg)](https://hackage.haskell.org/package/monoid-map) [![Hackage CI](https://matrix.hackage.haskell.org/api/v2/packages/monoid-map/badge)](https://matrix.hackage.haskell.org/#/package/monoid-map) [![Github CI](https://github.com/obsidiansystems/monoid-map/workflows/Haskell%20CI/badge.svg)](https://github.com/obsidiansystems/monoid-map/actions) [![BSD3 License](https://img.shields.io/badge/license-BSD3-blue.svg)](https://github.com/obsidiansystems/monoid-map/blob/master/LICENSE)
+[![Haskell](https://img.shields.io/badge/language-Haskell-orange.svg)](https://haskell.org) [![Hackage](https://img.shields.io/hackage/v/monoid-map.svg)](https://hackage.haskell.org/package/monoid-map) [![Hackage CI](https://matrix.hackage.haskell.org/api/v2/packages/monoid-map/badge)](https://matrix.hackage.haskell.org/#/package/monoid-map) [![Github CI](https://github.com/obsidiansystems/monoid-map/workflows/github-action/badge.svg)](https://github.com/obsidiansystems/monoid-map/actions) [![BSD3 License](https://img.shields.io/badge/license-BSD3-blue.svg)](https://github.com/obsidiansystems/monoid-map/blob/master/LICENSE)
 
 
 Newtype wrapper around 'Data.Map.Monoidal.MonoidalMap' that has a correct 'Group' instance.
diff --git a/monoid-map.cabal b/monoid-map.cabal
--- a/monoid-map.cabal
+++ b/monoid-map.cabal
@@ -1,6 +1,6 @@
 cabal-version:      2.4
 name:               monoid-map
-version:            0.1.1.0
+version:            0.2.0.0
 synopsis:           A monoidal map with the right group instance
 description:
   Newtype wrapper around 'Data.Map.Monoidal.MonoidalMap' that has a correct
@@ -30,9 +30,11 @@
 
   build-depends:
     , base                 >=4   && <5
+    , commutative-semigroups >= 0.1 && < 0.2
     , monoidal-containers  ^>=0.6
     , reflex               ^>=0.8
     , witherable           >=0.3 && <0.5
+    , patch                >=0.0.8.0 && < 0.1
 
   hs-source-dirs:   src
   default-language: Haskell2010
diff --git a/src/Data/MonoidMap.hs b/src/Data/MonoidMap.hs
--- a/src/Data/MonoidMap.hs
+++ b/src/Data/MonoidMap.hs
@@ -9,46 +9,63 @@
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
 {-# LANGUAGE DeriveTraversable #-}
-{-# LANGUAGE UndecidableInstances #-} -- For (Eq (QueryResult q), Ord k, Query q) => Query (MonoidMap k q)
+{-# LANGUAGE UndecidableInstances #-} -- For (DecidablyEmpty (QueryResult q), Ord k, Query q) => Query (MonoidMap k q)
 {-# LANGUAGE StandaloneDeriving #-}
+{-# LANGUAGE DataKinds #-}
 module Data.MonoidMap where
 
 import Data.Witherable
+import Data.Semigroup.Commutative
 import Data.Map.Monoidal (MonoidalMap)
-import Data.Map.Monoidal as Map
+import qualified Data.Map.Monoidal as Map
 import Data.Semigroup (Semigroup, (<>))
-import Reflex (Query, QueryResult, crop, Group(..), Additive)
+import Reflex (Query, QueryResult, crop, Group(..))
+import Data.Monoid.DecidablyEmpty
+import GHC.TypeLits
 
 -- | Newtype wrapper around Data.Map.Monoidal.MonoidalMap
 newtype MonoidMap k v = MonoidMap { unMonoidMap :: MonoidalMap k v }
-  deriving (Show, Eq, Ord, Foldable, Functor, Traversable)
+  deriving (Show, Eq, Ord, Foldable)
 
-deriving instance Filterable (MonoidalMap k) => Filterable (MonoidMap k)
+instance TypeError (Text "Use mapMonoidMap instead of fmap; MonoidMap is not a Functor because mempty values would need to be deleted, and Functors cannot change the shape of a datastructure") => Functor (MonoidMap k) where
+  fmap = error "Impossible"
 
+emptyToNothing :: DecidablyEmpty a => a -> Maybe a
+emptyToNothing a = if isEmpty a then Nothing else Just a
+
+mapMonoidMap :: DecidablyEmpty b => (a -> b) -> MonoidMap k a -> MonoidMap k b
+mapMonoidMap f (MonoidMap a) = MonoidMap $ mapMaybe (emptyToNothing . f) a
+
+traverseMonoidMap :: (Ord k, DecidablyEmpty b, Applicative f) => (a -> f b) -> MonoidMap k a -> f (MonoidMap k b)
+traverseMonoidMap f (MonoidMap a) = MonoidMap <$> wither (fmap emptyToNothing . f) a
+
+instance (Ord k, DecidablyEmpty v) => DecidablyEmpty (MonoidMap k v) where
+  isEmpty (MonoidMap m) = Map.null m
+
 -- | Convert a MonoidalMap into a MonoidMap
-monoidMap :: (Ord k, Eq v, Monoid v) => MonoidalMap k v -> MonoidMap k v
-monoidMap = MonoidMap . Map.filter (/= mempty)
+monoidMap :: (Ord k, DecidablyEmpty v) => MonoidalMap k v -> MonoidMap k v
+monoidMap = MonoidMap . Map.filter (not . isEmpty)
 
-instance (Eq (QueryResult q), Ord k, Query q) => Query (MonoidMap k q) where
+instance (DecidablyEmpty (QueryResult q), Ord k, Query q) => Query (MonoidMap k q) where
   type QueryResult (MonoidMap k q) = MonoidMap k (QueryResult q)
   crop (MonoidMap q) (MonoidMap qr) =
     -- This assumes that the query result of a null query should be null
     monoidMap $ Map.intersectionWith crop q qr
 
-instance (Monoid a, Eq a, Ord k) => Semigroup (MonoidMap k a) where
+instance (Monoid a, DecidablyEmpty a, Ord k) => Semigroup (MonoidMap k a) where
   MonoidMap a <> MonoidMap b =
     let combine _ a' b' =
           let c = a' `mappend` b'
-          in if c == mempty
+          in if isEmpty c
                then Nothing
                else Just c
     in MonoidMap $ Map.mergeWithKey combine id id a b
 
-instance (Ord k, Monoid a, Eq a) => Monoid (MonoidMap k a) where
+instance (Ord k, DecidablyEmpty a) => Monoid (MonoidMap k a) where
   mempty = MonoidMap Map.empty
   mappend = (<>)
 
-instance (Ord k, Monoid a, Eq a, Group a) => Group (MonoidMap k a) where
-  negateG = fmap negateG
+instance (Ord k, DecidablyEmpty a, Group a) => Group (MonoidMap k a) where
+  negateG (MonoidMap a) = MonoidMap $ fmap negateG a
 
-instance (Ord k, Monoid a, Eq a, Group a, Additive a) => Additive (MonoidMap k a)
+instance (Ord k, DecidablyEmpty a, Group a, Commutative a) => Commutative (MonoidMap k a)