Merge branch 'develop' into use-commutative-semigroups

Author: Ericson2314

.github/workflows/haskell.yml

@@ -1,12 +1,12 @@
 name: github-action
 
-on: [push, pull_request] 
+on: [push, pull_request]
 
 jobs:
   build:
     strategy:
       matrix:
-        ghc: ['8.0.2', '8.2.2', '8.4.4', '8.6.5', '8.8.4', '8.10.2']
+        ghc: ['8.0.2', '8.2.2', '8.4.4', '8.6.5', '8.8.4', '8.10.7', '9.0.1', '9.2.2']
         os: ['ubuntu-latest', 'macos-latest']
         exclude:
           # There are some linker warnings in 802 on darwin that
@@ -19,7 +19,7 @@ jobs:
     name: GHC ${{ matrix.ghc }} on ${{ matrix.os }}
     steps:
     - uses: actions/checkout@v2
-    - uses: actions/setup-haskell@v1
+    - uses: haskell/actions/setup@v1
       with:
         ghc-version: ${{ matrix.ghc }}
     - name: Cache

ChangeLog.md

@@ -5,6 +5,8 @@
  * Use `commutative-semigroups` for `Commutative`, making `Additive` a
    deprecated alias.
 
+* Support GHC 9.2
+
 ## 0.0.5.2 - 2022-01-09
 
 * Correct field order of `PatchMapWithMove.NodeInfo`.

patch.cabal

@@ -22,7 +22,7 @@ extra-source-files:
   ChangeLog.md
 
 tested-with:
-  GHC ==8.0.2 || ==8.2.2 || ==8.4.4 || ==8.6.5 || ==8.8.1
+  GHC ==8.0.2 || ==8.2.2 || ==8.4.4 || ==8.6.5 || ==8.8.4 || ==8.10.7 || ==9.0.1 || ==9.2.2
   GHCJS ==8.4
 
 flag split-these
@@ -33,15 +33,16 @@ flag split-these
 library
   hs-source-dirs: src
   default-language: Haskell2010
-  build-depends: base >= 4.9 && < 4.15
+  build-depends: base >= 4.9 && < 4.17
                , constraints-extras >= 0.3 && < 0.4
                , commutative-semigroups >= 0.0 && < 0.1
                , containers >= 0.6 && < 0.7
                , dependent-map >= 0.3 && < 0.5
                , dependent-sum >= 0.6 && < 0.8
-               , lens >= 4.7 && < 5
+               , lens >= 4.7 && < 5.2
+               , indexed-traversable >= 0.1 && < 0.2
                , semigroupoids >= 4.0 && < 6
-               , transformers >= 0.5.6.0 && < 0.6
+               , transformers >= 0.5.6.0 && < 0.7
                , witherable >= 0.3 && < 0.5
 
   if impl(ghc < 8.6) -- really, if base < 8.12
@@ -64,7 +65,7 @@ library
 
   if flag(split-these)
     build-depends: these >= 1 && <1.2
-                 , semialign >=1 && <1.2
+                 , semialign >=1 && <1.3
                  , monoidal-containers >= 0.6 && < 0.7
   else
     build-depends: these >= 0.4 && <0.9
@@ -92,7 +93,7 @@ test-suite hlint
                , directory
                , filepath
                , filemanip
-               , hlint (< 2.1 || >= 2.2.2) && < 3.3
+               , hlint (< 2.1 || >= 2.2.2) && < 3.5
   if impl(ghcjs)
     buildable: False
 

src/Data/Functor/Misc.hs

@@ -50,6 +50,7 @@ import Data.GADT.Compare
 import Data.GADT.Show
 import Data.IntMap (IntMap)
 import qualified Data.IntMap as IntMap
+import Data.Kind (Type)
 import Data.Map (Map)
 import qualified Data.Map as Map
 import Data.Some (Some, mkSome)
@@ -63,7 +64,7 @@ import Data.Typeable hiding (Refl)
 
 -- | 'Const2' stores a value of a given type 'k' and ensures that a particular
 -- type 'v' is always given for the last type parameter
-data Const2 :: * -> x -> x -> * where
+data Const2 :: Type -> x -> x -> Type where
   Const2 :: k -> Const2 k v v
   deriving (Typeable)
 
@@ -130,7 +131,7 @@ weakenDMapWith f = Map.fromDistinctAscList . map (\(k :=> v) -> (mkSome k, f v))
 -- | 'WrapArg' can be used to tag a value in one functor with a type
 -- representing another functor.  This was primarily used with dependent-map <
 -- 0.2, in which the value type was not wrapped in a separate functor.
-data WrapArg :: (k -> *) -> (k -> *) -> * -> * where
+data WrapArg :: (k -> Type) -> (k -> Type) -> Type -> Type where
   WrapArg :: f a -> WrapArg g f (g a)
 
 deriving instance Eq (f a) => Eq (WrapArg g f (g' a))

src/Data/Monoid/DecidablyEmpty.hs

@@ -69,8 +69,10 @@ instance DecidablyEmpty (First a) where
 instance DecidablyEmpty (Last a) where
   isEmpty (Last a) = isNothing a
 deriving instance DecidablyEmpty a => DecidablyEmpty (Identity a)
+#if !MIN_VERSION_base(4,16,0)
 instance Semigroup a => DecidablyEmpty (Option a) where
   isEmpty (Option a) = isNothing a
+#endif
 deriving instance DecidablyEmpty m => DecidablyEmpty (WrappedMonoid m)
 instance (Ord a, Bounded a) => DecidablyEmpty (Max a)
 instance (Ord a, Bounded a) => DecidablyEmpty (Min a)

src/Data/Patch/DMapWithMove.hs

@@ -33,6 +33,7 @@ import Data.Functor.Misc
 import Data.Functor.Product
 import Data.GADT.Compare (GEq (..), GCompare (..))
 import Data.GADT.Show (GShow, gshow)
+import Data.Kind (Type)
 import qualified Data.Map as Map
 import Data.Maybe
 import Data.Monoid.DecidablyEmpty
@@ -67,7 +68,7 @@ data NodeInfo k v a = NodeInfo
 
 -- |Structure describing a particular change to a key, be it inserting a new key (@From_Insert@), updating an existing key (@From_Insert@ again), deleting a
 -- key (@From_Delete@), or moving a key (@From_Move@).
-data From (k :: a -> *) (v :: a -> *) :: a -> * where
+data From (k :: a -> Type) (v :: a -> Type) :: a -> Type where
   -- |Insert a new or update an existing key with the given value @v a@
   From_Insert :: v a -> From k v a
   -- |Delete the existing key

src/Data/Patch/IntMap.hs

@@ -14,7 +14,8 @@ Patches of this sort allow for insert/update or delete of associations.
 -}
 module Data.Patch.IntMap where
 
-import Control.Lens
+import Control.Lens hiding  (FunctorWithIndex, FoldableWithIndex, TraversableWithIndex)
+import qualified Control.Lens as L
 import Data.IntMap.Strict (IntMap)
 import qualified Data.IntMap.Strict as IntMap
 import Data.Maybe
@@ -23,6 +24,9 @@ import Data.Monoid.DecidablyEmpty
 import Data.Semigroup (Semigroup (..))
 #endif
 import Data.Patch.Class
+import Data.Functor.WithIndex
+import Data.Foldable.WithIndex
+import Data.Traversable.WithIndex
 
 -- | 'Patch' for 'IntMap' which represents insertion or deletion of keys in the mapping.
 -- Internally represented by 'IntMap (Maybe a)', where @Just@ means insert/update
@@ -51,8 +55,13 @@ instance Patch (PatchIntMap a) where
 instance FunctorWithIndex Int PatchIntMap
 instance FoldableWithIndex Int PatchIntMap
 instance TraversableWithIndex Int PatchIntMap where
-  itraverse = itraversed . Indexed
-  itraversed = _Wrapped .> itraversed <. traversed
+  itraverse = (_Wrapped .> itraversed <. traversed) . Indexed
+
+#if !MIN_VERSION_lens(5,0,0)
+instance L.FunctorWithIndex     Int PatchIntMap where imap = Data.Functor.WithIndex.imap
+instance L.FoldableWithIndex    Int PatchIntMap where ifoldMap = Data.Foldable.WithIndex.ifoldMap
+instance L.TraversableWithIndex Int PatchIntMap where itraverse = Data.Traversable.WithIndex.itraverse
+#endif
 
 -- | Map a function @Int -> a -> b@ over all @a@s in the given @'PatchIntMap' a@
 -- (that is, all inserts/updates), producing a @PatchIntMap b@.

src/Data/Patch/Map.hs

@@ -18,12 +18,16 @@ module Data.Patch.Map where
 
 import Data.Patch.Class
 
-import Control.Lens
+import Control.Lens hiding  (FunctorWithIndex, FoldableWithIndex, TraversableWithIndex)
+import qualified Control.Lens as L
 import Data.Map (Map)
 import qualified Data.Map as Map
 import Data.Maybe
 import Data.Monoid.DecidablyEmpty
 import Data.Semigroup (Semigroup (..), stimesIdempotentMonoid)
+import Data.Functor.WithIndex
+import Data.Foldable.WithIndex
+import Data.Traversable.WithIndex
 
 -- | A set of changes to a 'Map'.  Any element may be inserted/updated or
 -- deleted.  Insertions are represented as values wrapped in 'Just', while
@@ -59,11 +63,18 @@ instance Ord k => Patch (PatchMap k v) where
             Nothing -> Just ()
             Just _ -> Nothing
 
+makeWrapped ''PatchMap
+
 instance FunctorWithIndex k (PatchMap k)
 instance FoldableWithIndex k (PatchMap k)
 instance TraversableWithIndex k (PatchMap k) where
-  itraverse = itraversed . Indexed
-  itraversed = _Wrapped .> itraversed <. traversed
+  itraverse = (_Wrapped .> itraversed <. traversed) . Indexed
+
+#if !MIN_VERSION_lens(5,0,0)
+instance L.FunctorWithIndex k    (PatchMap k) where imap = Data.Functor.WithIndex.imap
+instance L.FoldableWithIndex k   (PatchMap k) where ifoldMap = Data.Foldable.WithIndex.ifoldMap
+instance L.TraversableWithIndex k (PatchMap k) where itraverse = Data.Traversable.WithIndex.itraverse
+#endif
 
 -- | Returns all the new elements that will be added to the 'Map'
 patchMapNewElements :: PatchMap k v -> [v]
@@ -72,5 +83,3 @@ 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/MapWithMove.hs

@@ -70,7 +70,8 @@ import Data.Patch.Class
 import Data.Patch.MapWithPatchingMove (PatchMapWithPatchingMove(..), To)
 import qualified Data.Patch.MapWithPatchingMove as PM -- already a transparent synonym
 
-import Control.Lens
+import Control.Lens hiding  (FunctorWithIndex, FoldableWithIndex, TraversableWithIndex)
+import qualified Control.Lens as L
 import Data.List
 import Data.Map (Map)
 import qualified Data.Map as Map
@@ -79,6 +80,9 @@ import Data.Proxy
 import Data.Semigroup (Semigroup (..))
 #endif
 import Data.Traversable (foldMapDefault)
+import Data.Functor.WithIndex
+import Data.Foldable.WithIndex
+import Data.Traversable.WithIndex
 
 -- | Patch a Map with additions, deletions, and moves.  Invariant: If key @k1@
 -- is coming from @From_Move k2@, then key @k2@ should be going to @Just k1@,
@@ -133,11 +137,13 @@ instance Traversable (PatchMapWithMove k) where
 instance FunctorWithIndex k (PatchMapWithMove k)
 instance FoldableWithIndex k (PatchMapWithMove k)
 instance TraversableWithIndex k (PatchMapWithMove k) where
-  itraverse = itraversed . Indexed
-  itraversed =
-    _PatchMapWithMove .>
-    itraversed <.
-    traverse
+  itraverse = (_PatchMapWithMove .> itraversed <. traverse) . Indexed
+
+#if !MIN_VERSION_lens(5,0,0)
+instance L.FunctorWithIndex k    (PatchMapWithMove k) where imap = Data.Functor.WithIndex.imap
+instance L.FoldableWithIndex k   (PatchMapWithMove k) where ifoldMap = Data.Foldable.WithIndex.ifoldMap
+instance L.TraversableWithIndex k (PatchMapWithMove k) where itraverse = Data.Traversable.WithIndex.itraverse
+#endif
 
 -- | Create a 'PatchMapWithMove', validating it
 patchMapWithMove :: Ord k => Map k (NodeInfo k v) -> Maybe (PatchMapWithMove k v)