Document DecidablyEmpty and add missing instances

Author: Ericson2314

ChangeLog.md

@@ -4,6 +4,8 @@
 
 * Create `PatchMapWithPatchingMove` variant which supports moves with a patch.
 
+* Create `DecidablyEmpty` subclass of `Monoid`.
+
 ## 0.0.2.0
 
 * Consistently provide:

src/Data/Monoid/DecidablyEmpty.hs

@@ -1,14 +1,103 @@
+{-# LANGUAGE CPP #-}
 {-# LANGUAGE DefaultSignatures #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE StandaloneDeriving #-}
+{-# LANGUAGE TypeOperators #-}
 
 -- TODO upstream somwhere else?
 module Data.Monoid.DecidablyEmpty where
 
+import Data.Functor.Identity
+import Data.Functor.Const
+import Data.Monoid
+import Data.Maybe (isNothing)
+import Data.Ord
 import Data.Proxy
+import Data.Semigroup hiding (First, Last)
+import GHC.Generics
 
+import qualified Data.IntSet as IntSet
+import qualified Data.IntMap as IntMap
+import qualified Data.Map as Map
+import qualified Data.Sequence as Seq
+import qualified Data.Set as Set
+
+import Data.GADT.Compare
+import qualified Data.Dependent.Map as DMap
+
+-- | A 'DecidablyEmpty' is one where it can be computed whether or not an
+-- arbitrary value is 'mempty'.
+--
+-- By using this class rather than 'Eq', we avoid unnecessary constraining the
+-- contents of 'Functor's. This makes it possible to efficiently combine and/or
+-- nest patch maps with 'Eq'-lacking values (e.g. functions) at the leaves.
 class Monoid a => DecidablyEmpty a where
   isEmpty :: a -> Bool
   default isEmpty :: Eq a => a -> Bool
   isEmpty = (==) mempty
 
-instance DecidablyEmpty (Proxy a) where
-  isEmpty ~Proxy = True
+-- base
+
+instance DecidablyEmpty Ordering
+instance DecidablyEmpty ()
+instance DecidablyEmpty Any
+instance DecidablyEmpty All
+-- instance DecidablyEmpty Lifetime
+-- instance DecidablyEmpty Event
+instance DecidablyEmpty [a] where
+  isEmpty = null
+instance Semigroup a => DecidablyEmpty (Maybe a) where
+  isEmpty = isNothing
+#if MIN_VERSION_base(4,11,0)
+deriving instance DecidablyEmpty a => DecidablyEmpty (Down a)
+#endif
+deriving instance (Num a, DecidablyEmpty a) => DecidablyEmpty (Product a)
+deriving instance (DecidablyEmpty a, Num a) => DecidablyEmpty (Sum a)
+deriving instance DecidablyEmpty a => DecidablyEmpty (Dual a)
+deriving instance Semigroup a => DecidablyEmpty (First a)
+deriving instance Semigroup a => DecidablyEmpty (Last a)
+deriving instance DecidablyEmpty a => DecidablyEmpty (Identity a)
+deriving instance Semigroup a => DecidablyEmpty (Option a)
+deriving instance DecidablyEmpty m => DecidablyEmpty (WrappedMonoid m)
+instance (Ord a, Bounded a) => DecidablyEmpty (Max a)
+instance (Ord a, Bounded a) => DecidablyEmpty (Min a)
+instance DecidablyEmpty (U1 p)
+instance DecidablyEmpty (Proxy s)
+#if MIN_VERSION_base(4,12,0)
+deriving instance DecidablyEmpty (f p) => DecidablyEmpty (Rec1 f p)
+#endif
+deriving instance DecidablyEmpty a => DecidablyEmpty (Const a b)
+deriving instance DecidablyEmpty c => DecidablyEmpty (K1 i c p)
+instance (DecidablyEmpty (f p), DecidablyEmpty (g p)) => DecidablyEmpty ((f :*: g) p) where
+  isEmpty (x :*: y) = isEmpty x && isEmpty y
+#if MIN_VERSION_base(4,12,0)
+deriving instance DecidablyEmpty (f p) => DecidablyEmpty (M1 i c f p)
+deriving instance DecidablyEmpty (f (g p)) => DecidablyEmpty ((f :.: g) p)
+#endif
+
+instance (DecidablyEmpty a, DecidablyEmpty b) => DecidablyEmpty (a, b) where
+  isEmpty (a, b) = isEmpty a && isEmpty b
+instance (DecidablyEmpty a, DecidablyEmpty b, DecidablyEmpty c) => DecidablyEmpty (a, b, c) where
+  isEmpty (a, b, c) = isEmpty a && isEmpty b && isEmpty c
+instance (DecidablyEmpty a, DecidablyEmpty b, DecidablyEmpty c, DecidablyEmpty d) => DecidablyEmpty (a, b, c, d) where
+  isEmpty (a, b, c, d) = isEmpty a && isEmpty b && isEmpty c && isEmpty d
+instance (DecidablyEmpty a, DecidablyEmpty b, DecidablyEmpty c, DecidablyEmpty d, DecidablyEmpty e) => DecidablyEmpty (a, b, c, d, e) where
+  isEmpty (a, b, c, d, e) = isEmpty a && isEmpty b && isEmpty c && isEmpty d && isEmpty e
+
+-- containers
+
+instance DecidablyEmpty IntSet.IntSet where
+  isEmpty = IntSet.null
+instance DecidablyEmpty (IntMap.IntMap v) where
+  isEmpty = IntMap.null
+instance Ord k => DecidablyEmpty (Map.Map k v) where
+  isEmpty = Map.null
+instance DecidablyEmpty (Seq.Seq v) where
+  isEmpty = Seq.null
+instance Ord k => DecidablyEmpty (Set.Set k) where
+  isEmpty = Set.null
+
+-- dependent-map
+
+instance GCompare k => DecidablyEmpty (DMap.DMap k v) where
+  isEmpty = DMap.null

src/Data/Patch/DMap.hs

@@ -5,6 +5,7 @@
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE StandaloneDeriving #-}
 {-# LANGUAGE TypeFamilies #-}
+
 -- | 'Patch'es on 'DMap' that consist only of insertions (or overwrites) and deletions.
 module Data.Patch.DMap where
 
@@ -18,6 +19,7 @@ import Data.Functor.Constant
 import Data.Functor.Misc
 import qualified Data.IntMap as IntMap
 import qualified Data.Map as Map
+import Data.Monoid.DecidablyEmpty
 import Data.Semigroup (Semigroup (..))
 import Data.Some (Some)
 
@@ -30,6 +32,10 @@ deriving instance GCompare k => Semigroup (PatchDMap k v)
 
 deriving instance GCompare k => Monoid (PatchDMap k v)
 
+-- It won't let me derive for some reason
+instance GCompare k => DecidablyEmpty (PatchDMap k v) where
+  isEmpty (PatchDMap m) = DMap.null m
+
 -- | Apply the insertions or deletions to a given 'DMap'.
 instance GCompare k => Patch (PatchDMap k v) where
   type PatchTarget (PatchDMap k v) = DMap k v

src/Data/Patch/DMapWithMove.hs

@@ -29,6 +29,7 @@ import Data.GADT.Compare (GEq (..))
 import Data.GADT.Show (GShow, gshow)
 import qualified Data.Map as Map
 import Data.Maybe
+import Data.Monoid.DecidablyEmpty
 import Data.Semigroup (Semigroup (..), (<>))
 import Data.Some (Some(Some))
 import Data.These
@@ -42,6 +43,10 @@ import Data.These
 --     * A move should always be represented with both the destination key (as a 'From_Move') and the source key (as a @'ComposeMaybe' ('Just' destination)@)
 newtype PatchDMapWithMove k v = PatchDMapWithMove (DMap k (NodeInfo k v))
 
+-- It won't let me derive for some reason
+instance GCompare k => DecidablyEmpty (PatchDMapWithMove k v) where
+  isEmpty (PatchDMapWithMove m) = DMap.null m
+
 -- |Structure which represents what changes apply to a particular key. @_nodeInfo_from@ specifies what happens to this key, and in particular what other key
 -- the current key is moving from, while @_nodeInfo_to@ specifies what key the current key is moving to if involved in a move.
 data NodeInfo k v a = NodeInfo

src/Data/Patch/IntMap.hs

@@ -1,7 +1,9 @@
+{-# LANGUAGE CPP #-}
 {-# LANGUAGE DeriveTraversable #-}
 {-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE StandaloneDeriving #-}
 {-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE TypeFamilies #-}
 
@@ -13,24 +15,25 @@ import Control.Lens
 import Data.IntMap.Strict (IntMap)
 import qualified Data.IntMap.Strict as IntMap
 import Data.Maybe
-import Data.Semigroup
+import Data.Monoid.DecidablyEmpty
+#if !MIN_VERSION_base(4,10,0)
+import Data.Semigroup (Semigroup (..))
+#endif
 import Data.Patch.Class
 
 -- | 'Patch' for 'IntMap' which represents insertion or deletion of keys in the mapping.
 -- Internally represented by 'IntMap (Maybe a)', where @Just@ means insert/update
 -- and @Nothing@ means delete.
 newtype PatchIntMap a = PatchIntMap { unPatchIntMap :: IntMap (Maybe a) }
   deriving ( Show, Read, Eq, Ord
-           , Functor, Foldable, Traversable, Monoid
+           , Functor, Foldable, Traversable
+           , Monoid, DecidablyEmpty
            )
 
 -- | @a <> b@ will apply the changes of @b@ and then apply the changes of @a@.
 -- If the same key is modified by both patches, the one on the left will take
 -- precedence.
-instance Semigroup (PatchIntMap v) where
-  PatchIntMap a <> PatchIntMap b = PatchIntMap $ a `mappend` b --TODO: Add a semigroup instance for Map
-  -- PatchMap is idempotent, so stimes n is id for every n
-  stimes = stimesIdempotentMonoid
+deriving instance Semigroup (PatchIntMap v)
 
 makeWrapped ''PatchIntMap
 

src/Data/Patch/Map.hs

@@ -1,5 +1,6 @@
 {-# LANGUAGE DeriveTraversable #-}
 {-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
 {-# LANGUAGE LambdaCase #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE StandaloneDeriving #-}
@@ -16,6 +17,7 @@ import Control.Lens
 import Data.Map (Map)
 import qualified Data.Map as Map
 import Data.Maybe
+import Data.Monoid.DecidablyEmpty
 import Data.Semigroup
 
 -- | A set of changes to a 'Map'.  Any element may be inserted/updated or
@@ -24,11 +26,14 @@ import Data.Semigroup
 newtype PatchMap k v = PatchMap { unPatchMap :: Map k (Maybe v) }
   deriving ( Show, Read, Eq, Ord
            , Foldable, Traversable
+           , DecidablyEmpty
            )
 
 -- | 'fmap'ping a 'PatchMap' will alter all of the values it will insert.
 -- Deletions are unaffected.
 deriving instance Functor (PatchMap k)
+-- | The empty 'PatchMap' contains no insertions or deletions
+deriving instance Ord k => Monoid (PatchMap k v)
 
 -- | @a <> b@ will apply the changes of @b@ and then apply the changes of @a@.
 -- If the same key is modified by both patches, the one on the left will take
@@ -38,8 +43,6 @@ instance Ord k => Semigroup (PatchMap k v) where
   -- PatchMap is idempotent, so stimes n is id for every n
   stimes = stimesIdempotentMonoid
 
-makeWrapped ''PatchMap
-
 -- | Apply the insertions or deletions to a given 'Map'.
 instance Ord k => Patch (PatchMap k v) where
   type PatchTarget (PatchMap k v) = Map k v
@@ -57,15 +60,12 @@ instance TraversableWithIndex k (PatchMap k) where
   itraverse = itraversed . Indexed
   itraversed = _Wrapped .> itraversed <. traversed
 
--- | The empty 'PatchMap' contains no insertions or deletions
-instance Ord k => Monoid (PatchMap k v) where
-  mempty = PatchMap mempty
-  mappend = (<>)
-
 -- | Returns all the new elements that will be added to the 'Map'
 patchMapNewElements :: PatchMap k v -> [v]
 patchMapNewElements (PatchMap p) = catMaybes $ Map.elems p
 
 -- | Returns all the new elements that will be added to the 'Map'
 patchMapNewElementsMap :: PatchMap k v -> Map k v
 patchMapNewElementsMap (PatchMap p) = Map.mapMaybe id p
+
+makeWrapped ''PatchMap

src/Data/Patch/MapWithPatchingMove.hs

@@ -1,4 +1,5 @@
 {-# LANGUAGE CPP #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE LambdaCase #-}
@@ -45,6 +46,7 @@ deriving instance (Show k, Show p, Show (PatchTarget p)) => Show (PatchMapWithPa
 deriving instance (Ord k, Read k, Read p, Read (PatchTarget p)) => Read (PatchMapWithPatchingMove k p)
 deriving instance (Eq k, Eq p, Eq (PatchTarget p)) => Eq (PatchMapWithPatchingMove k p)
 deriving instance (Ord k, Ord p, Ord (PatchTarget p)) => Ord (PatchMapWithPatchingMove k p)
+deriving instance (Ord k, Monoid p, DecidablyEmpty p, Patch p) => DecidablyEmpty (PatchMapWithPatchingMove k p)
 
 -- | Holds the information about each key: where its new value should come from,
 -- and where its old value should go to