diff --git a/ChangeLog.md b/ChangeLog.md
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -1,5 +1,11 @@
 # Revision history for vessel
 
+## 0.3.0.0
+
+* Fix singleV: absent query /= present query for deleted item
+* Use Commutative instead of the deprecated Additive
+* Update for constraints-extras 0.4
+
 ## 0.2.1.0
 
 * Allow `Vessel` and `DMapV` types to be more liberally kinded in their indexes.
diff --git a/src/Data/Vessel/Class.hs b/src/Data/Vessel/Class.hs
--- a/src/Data/Vessel/Class.hs
+++ b/src/Data/Vessel/Class.hs
@@ -24,21 +24,21 @@
 import Control.Arrow ((***))
 import Control.Monad.Writer.Strict (Writer, execWriter, tell)
 import Data.Align
+import qualified Data.Dependent.Map as DMap'
+import Data.Dependent.Map.Monoidal (MonoidalDMap(..))
+import qualified Data.Dependent.Map.Monoidal as DMap
 import Data.Foldable
 import Data.Functor.Compose
-import Data.Witherable
-import GHC.Generics
+import Data.Functor.Identity
+import Data.GADT.Compare
+import Data.Map.Monoidal (MonoidalMap(..))
+import Data.Maybe (fromMaybe)
+import Data.Proxy
 import Data.Semigroup
 import Data.These
-import Data.Maybe (fromMaybe)
-import Data.Functor.Identity
+import GHC.Generics
 import Reflex.Query.Class
-import Data.Proxy
-import Data.Map.Monoidal (MonoidalMap (..))
-import Data.Dependent.Map.Monoidal (MonoidalDMap (..))
-import Data.GADT.Compare
-import qualified Data.Dependent.Map.Monoidal as DMap
-import qualified Data.Dependent.Map as DMap'
+import Witherable
 
 import Data.Vessel.Internal
 
@@ -370,4 +370,3 @@
 
 -- | a completely empty view.
 instance View Proxy
-
diff --git a/src/Data/Vessel/DependentMap.hs b/src/Data/Vessel/DependentMap.hs
--- a/src/Data/Vessel/DependentMap.hs
+++ b/src/Data/Vessel/DependentMap.hs
@@ -25,24 +25,25 @@
 import Data.Bifunctor
 import Data.Constraint.Extras
 import Data.Constraint.Forall
+import qualified Data.Dependent.Map as DMap'
 import Data.Dependent.Map.Monoidal (MonoidalDMap(..))
 import qualified Data.Dependent.Map.Monoidal as MonoidalDMap
-import Data.Functor.Compose
-import Data.GADT.Compare
-import Data.Some (Some(Some))
-import GHC.Generics
-import Data.Functor.Identity
+import qualified Data.Dependent.Map.Monoidal as DMap
 import Data.Dependent.Sum
 import Data.Dependent.Sum.Orphans ()
+import Data.Functor.Compose
+import Data.Functor.Identity
+import Data.GADT.Compare
+import Data.Patch (Group(..))
+import Data.Semigroup.Commutative
 import Data.Set (Set)
 import qualified Data.Set as Set
-import Data.Patch (Group(..), Additive)
-import qualified Data.Dependent.Map as DMap'
-import qualified Data.Dependent.Map.Monoidal as DMap
+import Data.Some (Some(Some))
+import GHC.Generics
 
 import Data.Vessel.Class
-import Data.Vessel.Selectable
 import Data.Vessel.Internal
+import Data.Vessel.Selectable
 
 -- | A functor-indexed container corrresponding to DMap k v.
 newtype DMapV (k :: x -> *) (v :: x -> *) g = DMapV { unDMapV :: MonoidalDMap k (g :.: v) }
@@ -53,7 +54,7 @@
 deriving instance (GCompare k, Has' Semigroup k (g :.: v)) => Semigroup (DMapV k v g)
 deriving instance (GCompare k, Has' Semigroup k (g :.: v), Has' Monoid k (g :.: v)) => Monoid (DMapV k v g)
 deriving instance (GCompare k, Has' Semigroup k (g :.: v), Has' Monoid k (g :.: v), Has' Group k (g :.: v)) => Group (DMapV k v g)
-deriving instance (GCompare k, Has' Semigroup k (g :.: v), Has' Monoid k (g :.: v), Has' Group k (g :.: v), Has' Additive k (g :.: v)) => Additive (DMapV k v g)
+deriving instance (GCompare k, Has' Semigroup k (g :.: v), Has' Monoid k (g :.: v), Has' Group k (g :.: v), Has' Commutative k (g :.: v)) => Commutative (DMapV k v g)
 
 instance (Has' ToJSON k (g :.: v), ForallF ToJSON k) => ToJSON (DMapV k v g)
 
diff --git a/src/Data/Vessel/Disperse.hs b/src/Data/Vessel/Disperse.hs
--- a/src/Data/Vessel/Disperse.hs
+++ b/src/Data/Vessel/Disperse.hs
@@ -20,12 +20,12 @@
 module Data.Vessel.Disperse where
 
 import Control.Arrow ((***))
-import Data.Witherable
 import Data.Align
-import Data.Map.Monoidal (MonoidalMap (..))
+import Data.Foldable hiding (null)
+import Data.Map.Monoidal (MonoidalMap(..))
 import qualified Data.Map.Monoidal as Map
 import Data.These
-import Data.Foldable hiding (null)
+import Witherable
 
 import Data.Vessel.Internal
 
@@ -73,4 +73,3 @@
     None -> nil
     One k v -> fmap (Map.singleton k) v
     Split pivot _l _r -> uncurry (alignWith (mergeThese unionDistinctAsc)) $ condense *** condense $ splitLT pivot row
-
diff --git a/src/Data/Vessel/Identity.hs b/src/Data/Vessel/Identity.hs
--- a/src/Data/Vessel/Identity.hs
+++ b/src/Data/Vessel/Identity.hs
@@ -20,12 +20,13 @@
 module Data.Vessel.Identity where
 
 import Data.Aeson
-import Data.Patch (Group(..), Additive)
-import GHC.Generics
 import Data.Functor.Compose
 import Data.Functor.Const
 import Data.Functor.Identity
+import Data.Patch (Group(..))
+import Data.Semigroup.Commutative
 import Data.These
+import GHC.Generics
 
 import Data.Vessel.Class
 import Data.Vessel.Selectable
@@ -33,7 +34,7 @@
 
 -- | A functor-indexed container corresponding to Identity. (i.e. a single non-deletable item)
 newtype IdentityV (a :: *) (g :: * -> *) = IdentityV { unIdentityV :: g a }
-  deriving (Eq, Ord, Show, Read, Semigroup, Monoid, Group, Additive, Generic, ToJSON, FromJSON)
+  deriving (Eq, Ord, Show, Read, Semigroup, Monoid, Group, Commutative, Generic, ToJSON, FromJSON)
 
 instance View (IdentityV a) where
   cropV f (IdentityV s) (IdentityV x) = Just $ IdentityV $ f s x
@@ -82,5 +83,3 @@
 -- | Non-existentialized map; since the contained value is known
 mapIdentityV :: (f a -> g a) -> IdentityV a f -> IdentityV a g
 mapIdentityV f (IdentityV xs) = IdentityV (f xs)
-
-
diff --git a/src/Data/Vessel/Internal.hs b/src/Data/Vessel/Internal.hs
--- a/src/Data/Vessel/Internal.hs
+++ b/src/Data/Vessel/Internal.hs
@@ -25,25 +25,26 @@
 
 import Control.Arrow ((***))
 import Data.Aeson
+import Data.Coerce
 import Data.Constraint.Extras
 import Data.Constraint.Forall
-import Data.Dependent.Map.Internal (DMap (..))
 import qualified Data.Dependent.Map as DMap'
+import Data.Dependent.Map.Internal (DMap(..))
 import Data.Dependent.Map.Monoidal (MonoidalDMap(..))
 import Data.Functor.Compose
 import Data.Functor.Const
 import Data.GADT.Compare
-import Data.Some (Some(Some))
-import Data.Map.Monoidal (MonoidalMap (..))
-import qualified Data.Map.Monoidal as Map
-import Data.These
-import Data.Patch (Group(..), Additive)
-import Data.Coerce
-import Data.Set (Set)
-import Data.Witherable
 import qualified Data.Map as Map'
 import qualified Data.Map.Merge.Strict as Map'
+import Data.Map.Monoidal (MonoidalMap(..))
+import qualified Data.Map.Monoidal as Map
+import Data.Patch (Group(..))
+import Data.Semigroup.Commutative
+import Data.Set (Set)
+import Data.Some (Some(Some))
+import Data.These
 import GHC.Generics
+import Witherable
 
 import qualified Data.Dependent.Map.Monoidal as DMap
 -- import qualified Data.Dependent.Map as DMap'
@@ -63,7 +64,7 @@
 instance Group (v g) => Group (FlipAp g v) where
   negateG (FlipAp x) = FlipAp (negateG x)
 
-instance Additive (v g) => Additive (FlipAp g v)
+instance Commutative (v g) => Commutative (FlipAp g v)
 
 
 -- A single Vessel key/value pair, essentially a choice of container type, together with a corresponding container.
@@ -88,9 +89,9 @@
 instance (Has' Group f g, Has' Semigroup f g, GCompare f) => Group (MonoidalDMap f g) where
   negateG (MonoidalDMap m) = MonoidalDMap (DMap'.mapWithKey (\k v -> has' @Group @g k (negateG v)) m)
 
-instance (Has' Group f g, Has' Semigroup f g, GCompare f) => Additive (MonoidalDMap f g)
+instance (Has' Group f g, Has' Semigroup f g, GCompare f) => Commutative (MonoidalDMap f g)
 
-instance (Additive (f (g a))) => Additive (Compose f g a)
+instance (Commutative (f (g a))) => Commutative (Compose f g a)
 
 ------- Miscellaneous stuff to be moved elsewhere -------
 
diff --git a/src/Data/Vessel/Map.hs b/src/Data/Vessel/Map.hs
--- a/src/Data/Vessel/Map.hs
+++ b/src/Data/Vessel/Map.hs
@@ -23,19 +23,20 @@
 import Data.Aeson
 import Data.Align
 import Data.Foldable
-import Data.Functor.Identity
 import Data.Functor.Compose
-import Data.Map.Monoidal (MonoidalMap (..))
-import Data.Patch (Group(..), Additive)
-import GHC.Generics
-import qualified Data.Map.Monoidal as Map
+import Data.Functor.Identity
 import qualified Data.Map as Map'
 import qualified Data.Map.Merge.Strict as Map'
+import Data.Map.Monoidal (MonoidalMap(..))
+import qualified Data.Map.Monoidal as Map
+import Data.Patch (Group(..))
+import Data.Semigroup.Commutative
 import Data.Set (Set)
+import GHC.Generics
 
 import Data.Vessel.Class hiding (empty)
-import Data.Vessel.Selectable
 import Data.Vessel.Disperse
+import Data.Vessel.Selectable
 import Data.Vessel.ViewMorphism
 
 -- | A functor-indexed container corresponding to Map k v.
@@ -60,7 +61,7 @@
 
 instance (Ord k, Eq g, Group g) => Group (MapV k v (Const g)) where
   negateG (MapV (MonoidalMap xs)) = MapV $ MonoidalMap $ fmap negateG xs
-instance (Ord k, Eq g, Group g, Additive g) => Additive (MapV k v (Const g))
+instance (Ord k, Eq g, Group g, Commutative g) => Commutative (MapV k v (Const g))
 
 instance (Ord k1, Ord k2, Monoid g, Eq g) => Semigroup (MapV k1 v (Compose (MonoidalMap k2) (Const g))) where
   MapV (MonoidalMap xs) <> MapV (MonoidalMap ys) = MapV $ MonoidalMap $ Map'.merge Map'.preserveMissing Map'.preserveMissing (Map'.zipWithMaybeMatched $ \_ (Compose (MonoidalMap x)) (Compose (MonoidalMap y)) -> fmap Compose $ nothingOnNull $ MonoidalMap $ mergeMapSemigroup x y) xs ys
@@ -82,7 +83,7 @@
 
 instance (Ord k1, Ord k2, Group g, Eq g) => Group (MapV k1 v (Compose (MonoidalMap k2) (Const g))) where
   negateG (MapV xs) = MapV $ fmap negateG xs
-instance (Ord k1, Ord k2, Additive g, Group g, Eq g) => Additive (MapV k1 v (Compose (MonoidalMap k2) (Const g)))
+instance (Ord k1, Ord k2, Commutative g, Group g, Eq g) => Commutative (MapV k1 v (Compose (MonoidalMap k2) (Const g)))
 
 instance (Ord k) => View (MapV k v) where
   cropV f (MapV s) (MapV i) = collapseNullV $ MapV (Map.intersectionWithKey (\_ x y -> f x y) s i)
diff --git a/src/Data/Vessel/Path.hs b/src/Data/Vessel/Path.hs
--- a/src/Data/Vessel/Path.hs
+++ b/src/Data/Vessel/Path.hs
@@ -152,10 +152,10 @@
 -- | This is a @Path@ which wraps/unwraps @SingleV@. Always produces a @SingleV@ containing @Just@ of
 -- the input value on the input side, but unwrapping will result in @Just@ or @Nothing@ according to
 -- whether the response contains a @Just@ or @Nothing@.
-singleV :: (Traversable g', Functor g) => Path (g a) (SingleV a g) (SingleV a g') (g' a)
+singleV :: (Functor g', Functor g) => Path (g a) (SingleV a g) (SingleV a g') (g' (Maybe a))
 singleV = Path
   { _path_to = SingleV . fmap (First . Just)
-  , _path_from = sequenceA . fmap getFirst . unSingleV
+  , _path_from = Just . fmap getFirst . unSingleV
   }
 
 -- | Combines two @Path@s whose full query type is a @Semigroup@, effectively, asking for two things at once,
diff --git a/src/Data/Vessel/Selectable.hs b/src/Data/Vessel/Selectable.hs
--- a/src/Data/Vessel/Selectable.hs
+++ b/src/Data/Vessel/Selectable.hs
@@ -31,4 +31,3 @@
   selector :: (forall a. p a) -> k -> v p
   -- | From a view, extract a more convenient type of value to use.
   selection :: k -> v Identity -> Selection v k
-
diff --git a/src/Data/Vessel/Single.hs b/src/Data/Vessel/Single.hs
--- a/src/Data/Vessel/Single.hs
+++ b/src/Data/Vessel/Single.hs
@@ -20,16 +20,17 @@
 
 module Data.Vessel.Single where
 
-import Data.These
-import Data.Patch (Group(..), Additive)
-import Data.Semigroup
-import Data.Functor.Identity
-import Data.Witherable
+import Data.Aeson
+import Data.Align
 import Data.Functor.Compose
 import Data.Functor.Const
-import Data.Align
-import Data.Aeson
+import Data.Functor.Identity
+import Data.Patch (Group(..))
+import Data.Semigroup
+import Data.Semigroup.Commutative
+import Data.These
 import GHC.Generics (Generic)
+import Witherable
 
 import Data.Vessel.Class
 import Data.Vessel.Selectable
@@ -56,7 +57,7 @@
 instance (Group (g (First (Maybe a)))) => Group (SingleV a g) where
   negateG (SingleV x) = SingleV (negateG x)
 
-instance (Additive (g (First (Maybe a)))) => Additive (SingleV a g)
+instance (Commutative (g (First (Maybe a)))) => Commutative (SingleV a g)
 
 instance View (SingleV a) where
   cropV f (SingleV s) (SingleV i) = Just $ SingleV $ f s i
diff --git a/src/Data/Vessel/SubVessel.hs b/src/Data/Vessel/SubVessel.hs
--- a/src/Data/Vessel/SubVessel.hs
+++ b/src/Data/Vessel/SubVessel.hs
@@ -24,7 +24,9 @@
 import Data.Aeson
 import Data.Constraint
 import Data.Constraint.Extras
+import qualified Data.Dependent.Map as DMap'
 import Data.Dependent.Map.Monoidal (MonoidalDMap(..))
+import qualified Data.Dependent.Map.Monoidal as DMap
 import Data.Dependent.Sum (DSum(..))
 import Data.Foldable
 import Data.Functor.Compose
@@ -32,20 +34,20 @@
 import Data.GADT.Compare
 import Data.GADT.Show
 import Data.Map.Monoidal (MonoidalMap(..))
+import qualified Data.Map.Monoidal as Map
+import Data.Orphans ()
+import Data.Patch (Group(..))
 import Data.Proxy
+import Data.Semigroup.Commutative
 import Data.Set (Set)
 import Data.Some (Some(Some))
 import Data.Type.Equality
 import GHC.Generics
-import Data.Patch (Group(..), Additive)
 import Reflex.Query.Class
-import qualified Data.Dependent.Map as DMap'
-import qualified Data.Dependent.Map.Monoidal as DMap
-import qualified Data.Map.Monoidal as Map
 
 import Data.Vessel.Class hiding (empty)
-import Data.Vessel.Vessel
 import Data.Vessel.Internal
+import Data.Vessel.Vessel
 import Data.Vessel.ViewMorphism
 
 data SubVesselKey k (f :: (* -> *) -> *) (g :: (* -> *) -> *) where
@@ -56,8 +58,7 @@
 instance FromJSON k => FromJSON (Some (SubVesselKey k v)) where parseJSON v = Some . SubVesselKey <$> parseJSON v
 instance ToJSON k => ToJSON (SubVesselKey k f g) where toJSON (SubVesselKey k) = toJSON k
 
-instance ArgDict c (SubVesselKey k f) where
-  type ConstraintsFor (SubVesselKey k f) c = c f
+instance (c f) => Has c (SubVesselKey k f) where
   argDict (SubVesselKey _) = Dict
 
 instance Eq k => GEq (SubVesselKey k v) where
@@ -76,7 +77,7 @@
 -- TODO: this representation has the advantage that all of it's instances come "free", but the mostly "right" representation is probably
 -- ... Vessel v (Compose (MonoidalMap k) f)
 newtype SubVessel (k :: *)  (v :: (* -> *) -> *) (f :: * -> *) = SubVessel { unSubVessel :: Vessel (SubVesselKey k v) f }
-  deriving (FromJSON, ToJSON, Semigroup, Monoid, Generic, Group, Additive, Eq)
+  deriving (FromJSON, ToJSON, Semigroup, Monoid, Generic, Group, Commutative, Eq)
 
 deriving instance (Show k, Show (v f)) => Show (SubVessel k v f)
 
@@ -244,4 +245,3 @@
 
 instance (Ord k, View v) => EmptyView (SubVessel k v) where
   emptyV = SubVessel emptyV
-
diff --git a/src/Data/Vessel/Vessel.hs b/src/Data/Vessel/Vessel.hs
--- a/src/Data/Vessel/Vessel.hs
+++ b/src/Data/Vessel/Vessel.hs
@@ -24,29 +24,30 @@
 import Control.Arrow ((***))
 import Control.Monad
 import Data.Aeson
-import Data.Some (Some)
+import Data.Align
 import Data.Constraint.Extras
-import Data.Functor.Identity
-import Data.Proxy
-import Data.Dependent.Sum
-import Data.Dependent.Sum.Orphans ()
 import Data.Constraint.Forall
+import qualified Data.Dependent.Map as DMap'
+import Data.Dependent.Map.Internal (DMap(..))
 import Data.Dependent.Map.Monoidal (MonoidalDMap(..))
-import Data.Dependent.Map.Internal (DMap (..))
-import Data.Foldable hiding (null)
 import qualified Data.Dependent.Map.Monoidal as DMap
+import Data.Dependent.Sum
+import Data.Dependent.Sum.Orphans ()
+import Data.Foldable hiding (null)
+import Data.Functor.Compose
+import Data.Functor.Identity
 import Data.GADT.Compare
 import Data.GADT.Show
-import Data.Witherable
+import Data.Maybe (fromMaybe)
+import Data.Patch (Group(..))
+import Data.Proxy
+import Data.Semigroup.Commutative
+import Data.Some (Some)
+import Data.These
 import Data.Vessel.Internal
+import Witherable
 import GHC.Generics
 import Reflex.Query.Class
-import Data.Patch (Group(..), Additive)
-import Data.Functor.Compose
-import Data.Align
-import qualified Data.Dependent.Map as DMap'
-import Data.Maybe (fromMaybe)
-import Data.These
 
 import Data.Vessel.Class hiding (empty)
 import Data.Vessel.DependentMap
@@ -117,7 +118,7 @@
 instance (Has' Semigroup k (FlipAp g), Has' Group k (FlipAp g), GCompare k, Has View k) => Group (Vessel k g) where
   negateG (Vessel m) = Vessel (negateG m) --TODO: Do we know that nullV can't be the result of negateG?
 
-instance (Has' Additive k (FlipAp g), Has' Semigroup k (FlipAp g), GCompare k, Has View k) => Additive (Vessel k g)
+instance (Has' Commutative k (FlipAp g), Has' Semigroup k (FlipAp g), GCompare k, Has View k) => Commutative (Vessel k g)
 
 ------- The View instance for Vessel itself --------
 
diff --git a/src/Data/Vessel/ViewMorphism.hs b/src/Data/Vessel/ViewMorphism.hs
--- a/src/Data/Vessel/ViewMorphism.hs
+++ b/src/Data/Vessel/ViewMorphism.hs
@@ -24,17 +24,17 @@
 module Data.Vessel.ViewMorphism where
 ------- Selectable convenience class -------
 
-import Prelude hiding (id, (.))
-import Control.Monad
 import Control.Applicative
 import Control.Category
+import Control.Monad
+import Data.Align
 import Data.Bifunctor
 import Data.Functor.Identity
 import Data.These
-import Reflex.Query.Class
-import Reflex.Class
-import Data.Align
 import Data.Vessel.Internal ()
+import Prelude hiding ((.), id)
+import Reflex.Class
+import Reflex.Query.Class
 
 type family ViewQueryResult (v :: k) :: k
 
@@ -119,4 +119,3 @@
 queryViewMorphism x q = do
   v :: Dynamic t (QueryResult q) <- queryDyn $ (\(ViewMorphism (ViewHalfMorphism f _) _) -> runIdentity $ f x) <$> q
   return $ (\v' (ViewMorphism  (ViewHalfMorphism _ g) _) -> g v') <$> v <*> q
-
diff --git a/tutorial/Tutorial.lhs b/tutorial/Tutorial.lhs
--- a/tutorial/Tutorial.lhs
+++ b/tutorial/Tutorial.lhs
@@ -15,7 +15,6 @@
 import Control.Monad
 import Control.Monad.IO.Class
 import Control.Monad.Fix
-import Data.Aeson (FromJSON(..), ToJSON(..))
 import Data.Aeson.GADT.TH (deriveJSONGADT)
 import Data.Align
 import Data.Proxy
@@ -28,6 +27,7 @@
 import Reflex.Network
 import qualified Data.Map as Map
 import qualified Data.Map.Merge.Strict as Map
+import Data.Semigroup.Commutative
 
 import Data.Vessel
 import Data.Vessel.ViewMorphism
@@ -77,7 +77,7 @@
 instance (Eq g, Monoid g) => Semigroup (Qsimple g) where Qsimple x y <> Qsimple x' y' = Qsimple (x <> x') (y <> y')
 instance (Eq g, Monoid g) => Monoid (Qsimple g) where mempty = Qsimple mempty mempty
 instance (Eq g, Group g) => Group (Qsimple g) where negateG (Qsimple x y) = Qsimple (negateG x) (negateG y)
-instance (Eq g, Monoid g, Additive g) => Additive (Qsimple g)
+instance (Eq g, Monoid g, Commutative g) => Commutative (Qsimple g)
 instance GrpFunctor Qsimple where mapG f (Qsimple x y) = Qsimple (mapG f x) (mapG f y)
 
 ```
@@ -275,7 +275,7 @@
 
 
 dischargeMonadQuery :: forall v t m a.
-  ( Additive (v SelectedCount), Group (v SelectedCount), PerformEvent t m, GrpFunctor v, Eq (v SelectedCount)
+  ( Commutative (v SelectedCount), Group (v SelectedCount), PerformEvent t m, GrpFunctor v, Eq (v SelectedCount)
   , Monoid (QueryResult (v SelectedCount)), PostBuild t m, MonadHold t m, MonadFix m, Widget t m
   , Query (v SelectedCount)
   )
diff --git a/tutorial/Tutorial.md b/tutorial/Tutorial.md
--- a/tutorial/Tutorial.md
+++ b/tutorial/Tutorial.md
@@ -15,7 +15,6 @@
 import Control.Monad
 import Control.Monad.IO.Class
 import Control.Monad.Fix
-import Data.Aeson (FromJSON(..), ToJSON(..))
 import Data.Aeson.GADT.TH (deriveJSONGADT)
 import Data.Align
 import Data.Proxy
@@ -28,6 +27,7 @@
 import Reflex.Network
 import qualified Data.Map as Map
 import qualified Data.Map.Merge.Strict as Map
+import Data.Semigroup.Commutative
 
 import Data.Vessel
 import Data.Vessel.ViewMorphism
@@ -77,7 +77,7 @@
 instance (Eq g, Monoid g) => Semigroup (Qsimple g) where Qsimple x y <> Qsimple x' y' = Qsimple (x <> x') (y <> y')
 instance (Eq g, Monoid g) => Monoid (Qsimple g) where mempty = Qsimple mempty mempty
 instance (Eq g, Group g) => Group (Qsimple g) where negateG (Qsimple x y) = Qsimple (negateG x) (negateG y)
-instance (Eq g, Monoid g, Additive g) => Additive (Qsimple g)
+instance (Eq g, Monoid g, Commutative g) => Commutative (Qsimple g)
 instance GrpFunctor Qsimple where mapG f (Qsimple x y) = Qsimple (mapG f x) (mapG f y)
 
 ```
@@ -275,7 +275,7 @@
 
 
 dischargeMonadQuery :: forall v t m a.
-  ( Additive (v SelectedCount), Group (v SelectedCount), PerformEvent t m, GrpFunctor v, Eq (v SelectedCount)
+  ( Commutative (v SelectedCount), Group (v SelectedCount), PerformEvent t m, GrpFunctor v, Eq (v SelectedCount)
   , Monoid (QueryResult (v SelectedCount)), PostBuild t m, MonadHold t m, MonadFix m, Widget t m
   , Query (v SelectedCount)
   )
diff --git a/vessel.cabal b/vessel.cabal
--- a/vessel.cabal
+++ b/vessel.cabal
@@ -1,5 +1,5 @@
 name:               vessel
-version:            0.2.1.0
+version:            0.3.0.0
 description:
   A dependently-typed key-value data structure that allows for storage of both "queries", (wherein keys are stored along with reasons for selecting the items or counts of the number of times something has been selected), as well as the responses to those queries, in which the type of the key additionally determines the type of the response
 
@@ -18,7 +18,7 @@
 cabal-version:      2.0
 category:           Data
 synopsis:           Functor-parametric containers
-tested-with:        GHC ==8.6.5 || ==8.8.4 || ==8.10.2
+tested-with:        GHC ==8.6.5 || ==8.8.4 || ==8.10.7
 
 library
   exposed-modules:
@@ -46,12 +46,13 @@
     UndecidableInstances
 
   build-depends:
-      aeson                        >=1.4     && <1.6
-    , base                         >=4.9     && <4.15
+      aeson                        >=1.4     && <2.2
+    , base                         >=4.9     && <4.17
     , base-orphans                 ^>=0.8.5
     , bifunctors                   ^>=5.5
+    , commutative-semigroups       ^>=0.1
     , constraints                  >=0.10    && <0.15
-    , constraints-extras           ^>=0.3
+    , constraints-extras           ^>=0.4
     , containers                   ^>=0.6
     , dependent-map                ^>=0.4
     , dependent-monoidal-map       ^>=0.1.1.0
@@ -59,7 +60,7 @@
     , dependent-sum-aeson-orphans  ^>=0.3.1
     , monoidal-containers          ^>=0.6
     , mtl                          ^>=2.2
-    , patch                        ^>=0.0.4.0
+    , patch                        ^>=0.0.7.0
     , reflex                       >=0.6.4   && <0.9
     , semialign                    >=1
     , these                        >=1 && <1.2
@@ -100,6 +101,7 @@
       aeson
     , aeson-gadt-th
     , base
+    , commutative-semigroups
     , constraints
     , constraints-extras
     , containers