equivalence 0.4.1 → 0.4.1.1
raw patch · 4 files changed
+39/−39 lines, 4 filesdep −faildep −template-haskelldep −transformers-compatdep ~QuickCheckdep ~basedep ~containersPVP: major bump suggested
API removals or changes: PVP suggests a major version bump
Dependencies removed: fail, template-haskell, transformers-compat
Dependency ranges changed: QuickCheck, base, containers, transformers
API changes (from Hackage documentation)
+ Data.Equivalence.Monad: ($dm===) :: forall (n :: Type -> Type) (t :: (Type -> Type) -> Type -> Type). (MonadEquiv c v d m, MonadEquiv c v d n, MonadTrans t, t n ~ m) => c -> c -> m Bool
+ Data.Equivalence.Monad: ($dmclassDesc) :: forall (n :: Type -> Type) (t :: (Type -> Type) -> Type -> Type). (MonadEquiv c v d m, MonadEquiv c v d n, MonadTrans t, t n ~ m) => v -> m d
+ Data.Equivalence.Monad: ($dmclasses) :: forall (n :: Type -> Type) (t :: (Type -> Type) -> Type -> Type). (MonadEquiv c v d m, MonadEquiv c v d n, MonadTrans t, t n ~ m) => m [c]
+ Data.Equivalence.Monad: ($dmcombineAll) :: forall (n :: Type -> Type) (t :: (Type -> Type) -> Type -> Type). (MonadEquiv c v d m, MonadEquiv c v d n, MonadTrans t, t n ~ m) => [c] -> m ()
+ Data.Equivalence.Monad: ($dmdesc) :: forall (n :: Type -> Type) (t :: (Type -> Type) -> Type -> Type). (MonadEquiv c v d m, MonadEquiv c v d n, MonadTrans t, t n ~ m) => c -> m d
+ Data.Equivalence.Monad: ($dmequateAll) :: forall (n :: Type -> Type) (t :: (Type -> Type) -> Type -> Type). (MonadEquiv c v d m, MonadEquiv c v d n, MonadTrans t, t n ~ m) => [v] -> m ()
+ Data.Equivalence.Monad: ($dmequivalent) :: forall (n :: Type -> Type) (t :: (Type -> Type) -> Type -> Type). (MonadEquiv c v d m, MonadEquiv c v d n, MonadTrans t, t n ~ m) => v -> v -> m Bool
+ Data.Equivalence.Monad: ($dmgetClass) :: forall (n :: Type -> Type) (t :: (Type -> Type) -> Type -> Type). (MonadEquiv c v d m, MonadEquiv c v d n, MonadTrans t, t n ~ m) => v -> m c
+ Data.Equivalence.Monad: ($dmremove) :: forall (n :: Type -> Type) (t :: (Type -> Type) -> Type -> Type). (MonadEquiv c v d m, MonadEquiv c v d n, MonadTrans t, t n ~ m) => c -> m Bool
+ Data.Equivalence.Monad: ($dmremoveClass) :: forall (n :: Type -> Type) (t :: (Type -> Type) -> Type -> Type). (MonadEquiv c v d m, MonadEquiv c v d n, MonadTrans t, t n ~ m) => v -> m Bool
+ Data.Equivalence.Monad: ($dmvalues) :: forall (n :: Type -> Type) (t :: (Type -> Type) -> Type -> Type). (MonadEquiv c v d m, MonadEquiv c v d n, MonadTrans t, t n ~ m) => m [v]
- Data.Equivalence.Monad: (===) :: (MonadEquiv c v d m, MonadEquiv c v d n, MonadTrans t, t n ~ m) => c -> c -> m Bool
+ Data.Equivalence.Monad: (===) :: MonadEquiv c v d m => c -> c -> m Bool
- Data.Equivalence.Monad: EquivT :: ReaderT (Equiv s c v) (STT s m) a -> EquivT s c v m a
+ Data.Equivalence.Monad: EquivT :: ReaderT (Equiv s c v) (STT s m) a -> EquivT s c v (m :: Type -> Type) a
- Data.Equivalence.Monad: [unEquivT] :: EquivT s c v m a -> ReaderT (Equiv s c v) (STT s m) a
+ Data.Equivalence.Monad: [unEquivT] :: EquivT s c v (m :: Type -> Type) a -> ReaderT (Equiv s c v) (STT s m) a
- Data.Equivalence.Monad: class (Monad m, Applicative m, Ord v) => MonadEquiv c v d m | m -> v, m -> c, m -> d
+ Data.Equivalence.Monad: class (Monad m, Applicative m, Ord v) => MonadEquiv c v d (m :: Type -> Type) | m -> v, m -> c, m -> d
- Data.Equivalence.Monad: classDesc :: (MonadEquiv c v d m, MonadEquiv c v d n, MonadTrans t, t n ~ m) => v -> m d
+ Data.Equivalence.Monad: classDesc :: MonadEquiv c v d m => v -> m d
- Data.Equivalence.Monad: classes :: (MonadEquiv c v d m, MonadEquiv c v d n, MonadTrans t, t n ~ m) => m [c]
+ Data.Equivalence.Monad: classes :: MonadEquiv c v d m => m [c]
- Data.Equivalence.Monad: combineAll :: (MonadEquiv c v d m, MonadEquiv c v d n, MonadTrans t, t n ~ m) => [c] -> m ()
+ Data.Equivalence.Monad: combineAll :: MonadEquiv c v d m => [c] -> m ()
- Data.Equivalence.Monad: desc :: (MonadEquiv c v d m, MonadEquiv c v d n, MonadTrans t, t n ~ m) => c -> m d
+ Data.Equivalence.Monad: desc :: MonadEquiv c v d m => c -> m d
- Data.Equivalence.Monad: equateAll :: (MonadEquiv c v d m, MonadEquiv c v d n, MonadTrans t, t n ~ m) => [v] -> m ()
+ Data.Equivalence.Monad: equateAll :: MonadEquiv c v d m => [v] -> m ()
- Data.Equivalence.Monad: equivalent :: (MonadEquiv c v d m, MonadEquiv c v d n, MonadTrans t, t n ~ m) => v -> v -> m Bool
+ Data.Equivalence.Monad: equivalent :: MonadEquiv c v d m => v -> v -> m Bool
- Data.Equivalence.Monad: getClass :: (MonadEquiv c v d m, MonadEquiv c v d n, MonadTrans t, t n ~ m) => v -> m c
+ Data.Equivalence.Monad: getClass :: MonadEquiv c v d m => v -> m c
- Data.Equivalence.Monad: newtype EquivT s c v m a
+ Data.Equivalence.Monad: newtype EquivT s c v (m :: Type -> Type) a
- Data.Equivalence.Monad: remove :: (MonadEquiv c v d m, MonadEquiv c v d n, MonadTrans t, t n ~ m) => c -> m Bool
+ Data.Equivalence.Monad: remove :: MonadEquiv c v d m => c -> m Bool
- Data.Equivalence.Monad: removeClass :: (MonadEquiv c v d m, MonadEquiv c v d n, MonadTrans t, t n ~ m) => v -> m Bool
+ Data.Equivalence.Monad: removeClass :: MonadEquiv c v d m => v -> m Bool
- Data.Equivalence.Monad: runEquivM :: (v -> c) -> (c -> c -> c) -> (forall s. EquivM s c v a) -> a
+ Data.Equivalence.Monad: runEquivM :: (v -> c) -> (c -> c -> c) -> (forall s. () => EquivM s c v a) -> a
- Data.Equivalence.Monad: runEquivM' :: (forall s. EquivM' s v a) -> a
+ Data.Equivalence.Monad: runEquivM' :: (forall s. () => EquivM' s v a) -> a
- Data.Equivalence.Monad: runEquivT :: (Monad m, Applicative m) => (v -> c) -> (c -> c -> c) -> (forall s. EquivT s c v m a) -> m a
+ Data.Equivalence.Monad: runEquivT :: (Monad m, Applicative m) => (v -> c) -> (c -> c -> c) -> (forall s. () => EquivT s c v m a) -> m a
- Data.Equivalence.Monad: runEquivT' :: (Monad m, Applicative m) => (forall s. EquivT' s v m a) -> m a
+ Data.Equivalence.Monad: runEquivT' :: (Monad m, Applicative m) => (forall s. () => EquivT' s v m a) -> m a
- Data.Equivalence.Monad: values :: (MonadEquiv c v d m, MonadEquiv c v d n, MonadTrans t, t n ~ m) => m [v]
+ Data.Equivalence.Monad: values :: MonadEquiv c v d m => m [v]
- Data.Equivalence.STT: classDesc :: (Monad m, Applicative m, Ord a) => Equiv s c a -> a -> STT s m c
+ Data.Equivalence.STT: classDesc :: forall (m :: Type -> Type) a s c. (Monad m, Applicative m, Ord a) => Equiv s c a -> a -> STT s m c
- Data.Equivalence.STT: classes :: (Monad m, Applicative m, Ord a) => Equiv s c a -> STT s m [Class s c a]
+ Data.Equivalence.STT: classes :: forall (m :: Type -> Type) a s c. (Monad m, Applicative m, Ord a) => Equiv s c a -> STT s m [Class s c a]
- Data.Equivalence.STT: combine :: (Monad m, Applicative m, Ord a) => Equiv s c a -> Class s c a -> Class s c a -> STT s m (Class s c a)
+ Data.Equivalence.STT: combine :: forall (m :: Type -> Type) a s c. (Monad m, Applicative m, Ord a) => Equiv s c a -> Class s c a -> Class s c a -> STT s m (Class s c a)
- Data.Equivalence.STT: combineAll :: (Monad m, Applicative m, Ord a) => Equiv s c a -> [Class s c a] -> STT s m ()
+ Data.Equivalence.STT: combineAll :: forall (m :: Type -> Type) a s c. (Monad m, Applicative m, Ord a) => Equiv s c a -> [Class s c a] -> STT s m ()
- Data.Equivalence.STT: desc :: (Monad m, Applicative m, Ord a) => Equiv s c a -> Class s c a -> STT s m c
+ Data.Equivalence.STT: desc :: forall (m :: Type -> Type) a s c. (Monad m, Applicative m, Ord a) => Equiv s c a -> Class s c a -> STT s m c
- Data.Equivalence.STT: equate :: (Monad m, Applicative m, Ord a) => Equiv s c a -> a -> a -> STT s m ()
+ Data.Equivalence.STT: equate :: forall (m :: Type -> Type) a s c. (Monad m, Applicative m, Ord a) => Equiv s c a -> a -> a -> STT s m ()
- Data.Equivalence.STT: equateAll :: (Monad m, Applicative m, Ord a) => Equiv s c a -> [a] -> STT s m ()
+ Data.Equivalence.STT: equateAll :: forall (m :: Type -> Type) a s c. (Monad m, Applicative m, Ord a) => Equiv s c a -> [a] -> STT s m ()
- Data.Equivalence.STT: equivalent :: (Monad m, Applicative m, Ord a) => Equiv s c a -> a -> a -> STT s m Bool
+ Data.Equivalence.STT: equivalent :: forall (m :: Type -> Type) a s c. (Monad m, Applicative m, Ord a) => Equiv s c a -> a -> a -> STT s m Bool
- Data.Equivalence.STT: getClass :: (Monad m, Applicative m, Ord a) => Equiv s c a -> a -> STT s m (Class s c a)
+ Data.Equivalence.STT: getClass :: forall (m :: Type -> Type) a s c. (Monad m, Applicative m, Ord a) => Equiv s c a -> a -> STT s m (Class s c a)
- Data.Equivalence.STT: leastEquiv :: (Monad m, Applicative m) => (a -> c) -> (c -> c -> c) -> STT s m (Equiv s c a)
+ Data.Equivalence.STT: leastEquiv :: forall (m :: Type -> Type) a c s. (Monad m, Applicative m) => (a -> c) -> (c -> c -> c) -> STT s m (Equiv s c a)
- Data.Equivalence.STT: remove :: (Monad m, Applicative m, Ord a) => Equiv s c a -> Class s c a -> STT s m Bool
+ Data.Equivalence.STT: remove :: forall (m :: Type -> Type) a s c. (Monad m, Applicative m, Ord a) => Equiv s c a -> Class s c a -> STT s m Bool
- Data.Equivalence.STT: removeClass :: (Monad m, Applicative m, Ord a) => Equiv s c a -> a -> STT s m Bool
+ Data.Equivalence.STT: removeClass :: forall (m :: Type -> Type) a s c. (Monad m, Applicative m, Ord a) => Equiv s c a -> a -> STT s m Bool
- Data.Equivalence.STT: same :: (Monad m, Applicative m, Ord a) => Equiv s c a -> Class s c a -> Class s c a -> STT s m Bool
+ Data.Equivalence.STT: same :: forall (m :: Type -> Type) a s c. (Monad m, Applicative m, Ord a) => Equiv s c a -> Class s c a -> Class s c a -> STT s m Bool
- Data.Equivalence.STT: values :: (Monad m, Applicative m, Ord a) => Equiv s c a -> STT s m [a]
+ Data.Equivalence.STT: values :: forall (m :: Type -> Type) a s c. (Monad m, Applicative m, Ord a) => Equiv s c a -> STT s m [a]
Files
- CHANGES.md +10/−0
- equivalence.cabal +22/−29
- src/Data/Equivalence/STT.hs +5/−9
- testsuite/tests/Data/Equivalence/Monad_Test.hs +2/−1
CHANGES.md view
@@ -1,3 +1,13 @@+0.4.1.1+-------++_Andreas Abel, 2025-08-27_++- bump cabal-version to 1.18+- remove unused dependencies++Tested with GHC 8.0 - 9.14 alpha1+ 0.4.1 -----
equivalence.cabal view
@@ -1,6 +1,6 @@-Cabal-Version: >= 1.10+Cabal-Version: 1.18 Name: equivalence-Version: 0.4.1+Version: 0.4.1.1 License: BSD3 License-File: LICENSE Author: Patrick Bahr@@ -21,8 +21,13 @@ Build-Type: Simple tested-with:- GHC == 9.4.1- GHC == 9.2.3+ GHC == 9.14.1+ GHC == 9.12.2+ GHC == 9.10.2+ GHC == 9.8.4+ GHC == 9.6.7+ GHC == 9.4.8+ GHC == 9.2.8 GHC == 9.0.2 GHC == 8.10.7 GHC == 8.8.4@@ -30,9 +35,8 @@ GHC == 8.4.4 GHC == 8.2.2 GHC == 8.0.2- GHC == 7.10.3 -Extra-Source-Files: CHANGES.md+Extra-Doc-Files: CHANGES.md source-repository head type: git@@ -46,22 +50,17 @@ Hs-Source-Dirs: src default-language: Haskell2010 Build-Depends:- base >= 4.8 && < 5- , containers+ base >= 4.9 && < 5+ -- Lower bounds at least from Stackage LTS 7.0 (GHC 8.0)+ , containers >= 0.5.7.1 , mtl >= 2.2.1 , STMonadTrans >= 0.4.3- , transformers >= 0.2- , transformers-compat >= 0.3- if impl(ghc < 8.0)- Build-Depends:- fail+ , transformers >= 0.5.2.0 ghc-options: -Wall- -fno-warn-name-shadowing- -fno-warn-incomplete-record-updates- if impl(ghc >= 8.0)- ghc-options:+ -Wno-name-shadowing+ -Wno-incomplete-record-updates -Wcompat Test-Suite test@@ -81,20 +80,14 @@ , mtl , STMonadTrans , transformers- , transformers-compat -- Additional dependencies for testsuite- , QuickCheck >= 2- , template-haskell- if impl(ghc < 8.0)- Build-Depends:- fail+ -- Lower bounds at least from Stackage LTS 7.0 (GHC 8.0)+ , QuickCheck >= 2.8.2 ghc-options: -Wall- -fno-warn-name-shadowing- -fno-warn-incomplete-record-updates- -fno-warn-missing-signatures- -fno-warn-unused-do-bind- if impl(ghc >= 8.0)- ghc-options:+ -Wno-name-shadowing+ -Wno-incomplete-record-updates+ -Wno-missing-signatures+ -Wno-unused-do-bind -Wcompat
src/Data/Equivalence/STT.hs view
@@ -86,11 +86,12 @@ indexed by @s@, contains equivalence class descriptors of type @c@ and has elements of type @a@. -} -data EntryData s c a = Node {+data EntryData s c a+ = Node { entryParent :: Entry s c a, entryValue :: a }- | Root {+ | Root { entryDesc :: c, entryWeight :: Int, entryValue :: a,@@ -236,13 +237,8 @@ yet. -} getEntry :: (Monad m, Applicative m, Ord a) => Equiv s c a -> a -> STT s m (Maybe (Entry s c a))-getEntry Equiv { entries = mref} val = do- m <- readSTRef mref- case Map.lookup val m of- Nothing -> return Nothing- Just entry -> return $ Just entry--+getEntry Equiv{ entries = mref } val = do+ Map.lookup val <$> readSTRef mref {-| This function equates the two given (representative) elements. That is, it unions the equivalence classes of the two elements and combines
testsuite/tests/Data/Equivalence/Monad_Test.hs view
@@ -1,6 +1,7 @@ {-# LANGUAGE FlexibleContexts #-}-{-# LANGUAGE RankNTypes, TemplateHaskell #-}+{-# LANGUAGE RankNTypes #-} {-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TemplateHaskell #-} module Data.Equivalence.Monad_Test where