diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,15 @@ Changelog ========= +Version 0.4.1.3 +--------------- + +*January 9, 2024* + + + +* Compatibility with transformers 0.6, and therefore ghc 9.6 (#7) + Version 0.4.1.2 --------------- diff --git a/functor-combinators.cabal b/functor-combinators.cabal --- a/functor-combinators.cabal +++ b/functor-combinators.cabal @@ -7,7 +7,7 @@ -- hash: c98f05061d45352f630dd964c7671a2a414e5708a12f8f4f8a39d61b986f6f5d name: functor-combinators -version: 0.4.1.2 +version: 0.4.1.3 synopsis: Tools for functor combinator-based program design description: Tools for working with /functor combinators/: types that take functors (or other indexed types) and returns a new functor that "enhances" or "mixes" @@ -79,7 +79,7 @@ Data.HBifunctor.Tensor.Internal hs-source-dirs: src - default-extensions: AllowAmbiguousTypes ConstraintKinds DataKinds DefaultSignatures DeriveDataTypeable DeriveFoldable DeriveFunctor DeriveGeneric DeriveTraversable DerivingStrategies EmptyCase ExistentialQuantification ExplicitNamespaces FlexibleContexts FlexibleInstances FunctionalDependencies GADTs GeneralizedNewtypeDeriving InstanceSigs KindSignatures LambdaCase MultiParamTypeClasses OverloadedStrings PatternSynonyms QuantifiedConstraints RankNTypes ScopedTypeVariables StandaloneDeriving TemplateHaskell TupleSections TypeApplications TypeFamilies TypeInType TypeOperators UndecidableInstances UndecidableSuperClasses ViewPatterns + default-extensions: AllowAmbiguousTypes ConstraintKinds DataKinds DefaultSignatures DeriveDataTypeable DeriveFoldable DeriveFunctor DeriveGeneric DeriveTraversable DerivingStrategies EmptyCase ExistentialQuantification ExplicitNamespaces FlexibleContexts FlexibleInstances FunctionalDependencies GADTs GeneralizedNewtypeDeriving InstanceSigs KindSignatures LambdaCase MultiParamTypeClasses OverloadedStrings PatternSynonyms QuantifiedConstraints RankNTypes ScopedTypeVariables StandaloneDeriving TemplateHaskell TupleSections TypeApplications TypeFamilies PolyKinds TypeOperators UndecidableInstances UndecidableSuperClasses ViewPatterns ghc-options: -Wall -Wcompat -Wredundant-constraints -Werror=incomplete-patterns build-depends: StateVar @@ -121,7 +121,7 @@ Paths_functor_combinators hs-source-dirs: test - default-extensions: AllowAmbiguousTypes ConstraintKinds DataKinds DefaultSignatures DeriveDataTypeable DeriveFoldable DeriveFunctor DeriveGeneric DeriveTraversable DerivingStrategies EmptyCase ExistentialQuantification ExplicitNamespaces FlexibleContexts FlexibleInstances FunctionalDependencies GADTs GeneralizedNewtypeDeriving InstanceSigs KindSignatures LambdaCase MultiParamTypeClasses OverloadedStrings PatternSynonyms QuantifiedConstraints RankNTypes ScopedTypeVariables StandaloneDeriving TemplateHaskell TupleSections TypeApplications TypeFamilies TypeInType TypeOperators UndecidableInstances UndecidableSuperClasses ViewPatterns + default-extensions: AllowAmbiguousTypes ConstraintKinds DataKinds DefaultSignatures DeriveDataTypeable DeriveFoldable DeriveFunctor DeriveGeneric DeriveTraversable DerivingStrategies EmptyCase ExistentialQuantification ExplicitNamespaces FlexibleContexts FlexibleInstances FunctionalDependencies GADTs GeneralizedNewtypeDeriving InstanceSigs KindSignatures LambdaCase MultiParamTypeClasses OverloadedStrings PatternSynonyms QuantifiedConstraints RankNTypes ScopedTypeVariables StandaloneDeriving TemplateHaskell TupleSections TypeApplications TypeFamilies PolyKinds TypeOperators UndecidableInstances UndecidableSuperClasses ViewPatterns ghc-options: -Wall -Wcompat -Wredundant-constraints -Werror=incomplete-patterns -threaded -rtsopts -with-rtsopts=-N build-depends: base >=4.12 && <5 diff --git a/src/Data/Functor/Contravariant/Conclude.hs b/src/Data/Functor/Contravariant/Conclude.hs --- a/src/Data/Functor/Contravariant/Conclude.hs +++ b/src/Data/Functor/Contravariant/Conclude.hs @@ -24,7 +24,6 @@ import Control.Applicative.Backwards import Control.Monad.Trans.Identity -import Control.Monad.Trans.List import Control.Monad.Trans.Maybe import qualified Control.Monad.Trans.RWS.Lazy as Lazy import qualified Control.Monad.Trans.RWS.Strict as Strict @@ -67,6 +66,10 @@ import GHC.Generics #endif +#if !MIN_VERSION_transformers(0,6,0) +import Control.Monad.Trans.List +#endif + -- | The contravariant analogue of 'Data.Functor.Plus.Plus'. Adds on to -- 'Decide' the ability to express a combinator that rejects all input, to -- act as the dead-end. Essentially 'Decidable' without a superclass @@ -160,8 +163,10 @@ instance Conclude m => Conclude (Strict.RWST r w s m) where conclude f = Strict.RWST $ \_ _ -> contramap (\(a, _, _) -> a) (conclude f) +#if !MIN_VERSION_transformers(0,6,0) instance (Divisible m, Divise m) => Conclude (ListT m) where conclude _ = ListT conquer +#endif instance (Divisible m, Divise m) => Conclude (MaybeT m) where conclude _ = MaybeT conquer diff --git a/src/Data/Functor/Contravariant/Decide.hs b/src/Data/Functor/Contravariant/Decide.hs --- a/src/Data/Functor/Contravariant/Decide.hs +++ b/src/Data/Functor/Contravariant/Decide.hs @@ -23,12 +23,9 @@ ) where import Control.Applicative.Backwards -import Control.Arrow import Control.Monad.Trans.Identity -import Control.Monad.Trans.List import Control.Monad.Trans.Maybe import Control.Monad.Trans.Reader -import Data.Either import Data.Functor.Apply import Data.Functor.Compose import Data.Functor.Contravariant @@ -62,6 +59,12 @@ import GHC.Generics #endif +#if !MIN_VERSION_transformers(0,6,0) +import Control.Monad.Trans.List +import Control.Arrow +import Data.Either +#endif + -- | The contravariant analogue of 'Alt'. -- -- If one thinks of @f a@ as a consumer of @a@s, then 'decide' allows one @@ -144,8 +147,10 @@ (abc a)) (rsmb r s) (rsmc r s) +#if !MIN_VERSION_transformers(0,6,0) instance Divise m => Decide (ListT m) where decide f (ListT l) (ListT r) = ListT $ divise ((lefts &&& rights) . map f) l r +#endif instance Divise m => Decide (MaybeT m) where decide f (MaybeT l) (MaybeT r) = MaybeT $ diff --git a/src/Data/Functor/Contravariant/Divise.hs b/src/Data/Functor/Contravariant/Divise.hs --- a/src/Data/Functor/Contravariant/Divise.hs +++ b/src/Data/Functor/Contravariant/Divise.hs @@ -26,10 +26,8 @@ import Control.Applicative import Control.Applicative.Backwards import Control.Arrow -import Control.Monad.Trans.Error import Control.Monad.Trans.Except import Control.Monad.Trans.Identity -import Control.Monad.Trans.List import Control.Monad.Trans.Maybe import Control.Monad.Trans.Reader import Data.Deriving @@ -72,6 +70,11 @@ import GHC.Generics #endif +#if !MIN_VERSION_transformers(0,6,0) +import Control.Monad.Trans.Error +import Control.Monad.Trans.List +#endif + -- | The contravariant analogue of 'Apply'; it is -- 'Divisible' without 'conquer'. -- @@ -198,17 +201,19 @@ instance Divise f => Divise (Backwards f) where divise f (Backwards l) (Backwards r) = Backwards $ divise f l r -instance Divise m => Divise (ErrorT e m) where - divise f (ErrorT l) (ErrorT r) = ErrorT $ divise (funzip . fmap f) l r - instance Divise m => Divise (ExceptT e m) where divise f (ExceptT l) (ExceptT r) = ExceptT $ divise (funzip . fmap f) l r instance Divise f => Divise (IdentityT f) where divise f (IdentityT l) (IdentityT r) = IdentityT $ divise f l r +#if !MIN_VERSION_transformers(0,6,0) +instance Divise m => Divise (ErrorT e m) where + divise f (ErrorT l) (ErrorT r) = ErrorT $ divise (funzip . fmap f) l r + instance Divise m => Divise (ListT m) where divise f (ListT l) (ListT r) = ListT $ divise (funzip . map f) l r +#endif instance Divise m => Divise (MaybeT m) where divise f (MaybeT l) (MaybeT r) = MaybeT $ divise (funzip . fmap f) l r diff --git a/src/Data/Functor/Invariant/Inplicative.hs b/src/Data/Functor/Invariant/Inplicative.hs --- a/src/Data/Functor/Invariant/Inplicative.hs +++ b/src/Data/Functor/Invariant/Inplicative.hs @@ -45,10 +45,8 @@ import Control.Applicative.Lift (Lift(Pure, Other)) import Control.Arrow (Arrow) import Control.Monad.Trans.Cont (ContT) -import Control.Monad.Trans.Error (ErrorT(..)) import Control.Monad.Trans.Except (ExceptT(..)) import Control.Monad.Trans.Identity (IdentityT(..)) -import Control.Monad.Trans.List (ListT(..)) import Control.Monad.Trans.Maybe (MaybeT(..)) import Control.Monad.Trans.RWS (RWST(..)) import Control.Monad.Trans.Reader (ReaderT(..)) @@ -91,6 +89,11 @@ import qualified Data.Vinyl.Functor as V import qualified GHC.Generics as Generics +#if !MIN_VERSION_transformers(0,6,0) +import Control.Monad.Trans.Error +import Control.Monad.Trans.List +#endif + -- | The invariant counterpart of 'Apply' and 'Divise'. -- -- Conceptually you can think of 'Apply' as, given a way to "combine" @a@ and @@ -302,6 +305,7 @@ instance Inplicative f => Inplicative (ExceptT e f) where knot x = ExceptT (knot (Right x)) +#if !MIN_VERSION_transformers(0,6,0) -- | @since 0.4.1.0 instance Inply f => Inply (ErrorT e f) where gather f g (ErrorT x) (ErrorT y) = ErrorT $ @@ -317,6 +321,7 @@ -- | @since 0.4.1.0 instance Inplicative f => Inplicative (ListT f) where knot x = ListT (knot [x]) +#endif -- | @since 0.4.1.0 deriving via WrappedFunctor (RWST r w s m) instance (Bind m, Invariant m, Semigroup w) => Inply (RWST r w s m)