adjunctions 4.4.3 → 4.4.4
raw patch · 2 files changed
+13/−10 lines, 2 filesdep −arraydep −semigroupsdep −transformers-compatdep ~contravariantPVP: major bump suggested
API removals or changes: PVP suggests a major version bump
Dependencies removed: array, semigroups, transformers-compat, void
Dependency ranges changed: contravariant
API changes (from Hackage documentation)
+ Data.Functor.Rep: ($dmindex) :: (Representable f, Generic1 f, GRep f ~ Rep f, GIndex (Rep1 f)) => f a -> Rep f -> a
+ Data.Functor.Rep: ($dmtabulate) :: (Representable f, Generic1 f, GRep f ~ Rep f, GTabulate (Rep1 f)) => (Rep f -> a) -> f a
- Control.Comonad.Representable.Store: StoreT :: w (g a) -> Rep g -> StoreT g w a
+ Control.Comonad.Representable.Store: StoreT :: w (g a) -> Rep g -> StoreT (g :: Type -> Type) (w :: Type -> Type) a
- Control.Comonad.Representable.Store: data StoreT g w a
+ Control.Comonad.Representable.Store: data StoreT (g :: Type -> Type) (w :: Type -> Type) a
- Control.Comonad.Representable.Store: runStore :: Representable g => Store g a -> (Rep g -> a, Rep g)
+ Control.Comonad.Representable.Store: runStore :: forall (g :: Type -> Type) a. Representable g => Store g a -> (Rep g -> a, Rep g)
- Control.Comonad.Representable.Store: runStoreT :: (Functor w, Representable g) => StoreT g w a -> (w (Rep g -> a), Rep g)
+ Control.Comonad.Representable.Store: runStoreT :: forall w (g :: Type -> Type) a. (Functor w, Representable g) => StoreT g w a -> (w (Rep g -> a), Rep g)
- Control.Comonad.Representable.Store: store :: Representable g => (Rep g -> a) -> Rep g -> Store g a
+ Control.Comonad.Representable.Store: store :: forall (g :: Type -> Type) a. Representable g => (Rep g -> a) -> Rep g -> Store g a
- Control.Comonad.Representable.Store: storeT :: (Functor w, Representable g) => w (Rep g -> a) -> Rep g -> StoreT g w a
+ Control.Comonad.Representable.Store: storeT :: forall w (g :: Type -> Type) a. (Functor w, Representable g) => w (Rep g -> a) -> Rep g -> StoreT g w a
- Control.Comonad.Representable.Store: type Store g = StoreT g Identity
+ Control.Comonad.Representable.Store: type Store (g :: Type -> Type) = StoreT g Identity
- Control.Comonad.Trans.Adjoint: AdjointT :: f (w (g a)) -> AdjointT f g w a
+ Control.Comonad.Trans.Adjoint: AdjointT :: f (w (g a)) -> AdjointT (f :: Type -> Type) (g :: Type -> Type) (w :: Type -> Type) a
- Control.Comonad.Trans.Adjoint: [runAdjointT] :: AdjointT f g w a -> f (w (g a))
+ Control.Comonad.Trans.Adjoint: [runAdjointT] :: AdjointT (f :: Type -> Type) (g :: Type -> Type) (w :: Type -> Type) a -> f (w (g a))
- Control.Comonad.Trans.Adjoint: newtype AdjointT f g w a
+ Control.Comonad.Trans.Adjoint: newtype AdjointT (f :: Type -> Type) (g :: Type -> Type) (w :: Type -> Type) a
- Control.Comonad.Trans.Adjoint: type Adjoint f g = AdjointT f g Identity
+ Control.Comonad.Trans.Adjoint: type Adjoint (f :: Type -> Type) (g :: Type -> Type) = AdjointT f g Identity
- Control.Monad.Representable.Reader: ReaderT :: f (m b) -> ReaderT f m b
+ Control.Monad.Representable.Reader: ReaderT :: f (m b) -> ReaderT (f :: Type -> Type) (m :: Type -> Type) b
- Control.Monad.Representable.Reader: [getReaderT] :: ReaderT f m b -> f (m b)
+ Control.Monad.Representable.Reader: [getReaderT] :: ReaderT (f :: Type -> Type) (m :: Type -> Type) b -> f (m b)
- Control.Monad.Representable.Reader: newtype ReaderT f m b
+ Control.Monad.Representable.Reader: newtype ReaderT (f :: Type -> Type) (m :: Type -> Type) b
- Control.Monad.Representable.Reader: readerT :: Representable f => (Rep f -> m b) -> ReaderT f m b
+ Control.Monad.Representable.Reader: readerT :: forall (f :: Type -> Type) m b. Representable f => (Rep f -> m b) -> ReaderT f m b
- Control.Monad.Representable.Reader: runReader :: Representable f => Reader f b -> Rep f -> b
+ Control.Monad.Representable.Reader: runReader :: forall (f :: Type -> Type) b. Representable f => Reader f b -> Rep f -> b
- Control.Monad.Representable.Reader: runReaderT :: Representable f => ReaderT f m b -> Rep f -> m b
+ Control.Monad.Representable.Reader: runReaderT :: forall (f :: Type -> Type) m b. Representable f => ReaderT f m b -> Rep f -> m b
- Control.Monad.Representable.Reader: type Reader f = ReaderT f Identity
+ Control.Monad.Representable.Reader: type Reader (f :: Type -> Type) = ReaderT f Identity
- Control.Monad.Representable.State: StateT :: g (m (a, Rep g)) -> StateT g m a
+ Control.Monad.Representable.State: StateT :: g (m (a, Rep g)) -> StateT (g :: Type -> Type) (m :: Type -> Type) a
- Control.Monad.Representable.State: [getStateT] :: StateT g m a -> g (m (a, Rep g))
+ Control.Monad.Representable.State: [getStateT] :: StateT (g :: Type -> Type) (m :: Type -> Type) a -> g (m (a, Rep g))
- Control.Monad.Representable.State: evalState :: Representable g => State g a -> Rep g -> a
+ Control.Monad.Representable.State: evalState :: forall (g :: Type -> Type) a. Representable g => State g a -> Rep g -> a
- Control.Monad.Representable.State: evalStateT :: (Representable g, Monad m) => StateT g m a -> Rep g -> m a
+ Control.Monad.Representable.State: evalStateT :: forall (g :: Type -> Type) m a. (Representable g, Monad m) => StateT g m a -> Rep g -> m a
- Control.Monad.Representable.State: execState :: Representable g => State g a -> Rep g -> Rep g
+ Control.Monad.Representable.State: execState :: forall (g :: Type -> Type) a. Representable g => State g a -> Rep g -> Rep g
- Control.Monad.Representable.State: execStateT :: (Representable g, Monad m) => StateT g m a -> Rep g -> m (Rep g)
+ Control.Monad.Representable.State: execStateT :: forall (g :: Type -> Type) m a. (Representable g, Monad m) => StateT g m a -> Rep g -> m (Rep g)
- Control.Monad.Representable.State: liftCallCC :: Representable g => ((((a, Rep g) -> m (b, Rep g)) -> m (a, Rep g)) -> m (a, Rep g)) -> ((a -> StateT g m b) -> StateT g m a) -> StateT g m a
+ Control.Monad.Representable.State: liftCallCC :: forall (g :: Type -> Type) a m b. Representable g => ((((a, Rep g) -> m (b, Rep g)) -> m (a, Rep g)) -> m (a, Rep g)) -> ((a -> StateT g m b) -> StateT g m a) -> StateT g m a
- Control.Monad.Representable.State: liftCallCC' :: Representable g => ((((a, Rep g) -> m (b, Rep g)) -> m (a, Rep g)) -> m (a, Rep g)) -> ((a -> StateT g m b) -> StateT g m a) -> StateT g m a
+ Control.Monad.Representable.State: liftCallCC' :: forall (g :: Type -> Type) a m b. Representable g => ((((a, Rep g) -> m (b, Rep g)) -> m (a, Rep g)) -> m (a, Rep g)) -> ((a -> StateT g m b) -> StateT g m a) -> StateT g m a
- Control.Monad.Representable.State: mapState :: Functor g => ((a, Rep g) -> (b, Rep g)) -> State g a -> State g b
+ Control.Monad.Representable.State: mapState :: forall (g :: Type -> Type) a b. Functor g => ((a, Rep g) -> (b, Rep g)) -> State g a -> State g b
- Control.Monad.Representable.State: mapStateT :: Functor g => (m (a, Rep g) -> n (b, Rep g)) -> StateT g m a -> StateT g n b
+ Control.Monad.Representable.State: mapStateT :: forall (g :: Type -> Type) m a n b. Functor g => (m (a, Rep g) -> n (b, Rep g)) -> StateT g m a -> StateT g n b
- Control.Monad.Representable.State: newtype StateT g m a
+ Control.Monad.Representable.State: newtype StateT (g :: Type -> Type) (m :: Type -> Type) a
- Control.Monad.Representable.State: runState :: Representable g => State g a -> Rep g -> (a, Rep g)
+ Control.Monad.Representable.State: runState :: forall (g :: Type -> Type) a. Representable g => State g a -> Rep g -> (a, Rep g)
- Control.Monad.Representable.State: runStateT :: Representable g => StateT g m a -> Rep g -> m (a, Rep g)
+ Control.Monad.Representable.State: runStateT :: forall (g :: Type -> Type) m a. Representable g => StateT g m a -> Rep g -> m (a, Rep g)
- Control.Monad.Representable.State: stateT :: Representable g => (Rep g -> m (a, Rep g)) -> StateT g m a
+ Control.Monad.Representable.State: stateT :: forall (g :: Type -> Type) m a. Representable g => (Rep g -> m (a, Rep g)) -> StateT g m a
- Control.Monad.Representable.State: type State g = StateT g Identity
+ Control.Monad.Representable.State: type State (g :: Type -> Type) = StateT g Identity
- Control.Monad.Trans.Adjoint: AdjointT :: g (m (f a)) -> AdjointT f g m a
+ Control.Monad.Trans.Adjoint: AdjointT :: g (m (f a)) -> AdjointT (f :: Type -> Type) (g :: Type -> Type) (m :: Type -> Type) a
- Control.Monad.Trans.Adjoint: [runAdjointT] :: AdjointT f g m a -> g (m (f a))
+ Control.Monad.Trans.Adjoint: [runAdjointT] :: AdjointT (f :: Type -> Type) (g :: Type -> Type) (m :: Type -> Type) a -> g (m (f a))
- Control.Monad.Trans.Adjoint: newtype AdjointT f g m a
+ Control.Monad.Trans.Adjoint: newtype AdjointT (f :: Type -> Type) (g :: Type -> Type) (m :: Type -> Type) a
- Control.Monad.Trans.Adjoint: type Adjoint f g = AdjointT f g Identity
+ Control.Monad.Trans.Adjoint: type Adjoint (f :: Type -> Type) (g :: Type -> Type) = AdjointT f g Identity
- Control.Monad.Trans.Contravariant.Adjoint: AdjointT :: g (w (f a)) -> AdjointT f g w a
+ Control.Monad.Trans.Contravariant.Adjoint: AdjointT :: g (w (f a)) -> AdjointT (f :: Type -> Type) (g :: Type -> Type) (w :: Type -> Type) a
- Control.Monad.Trans.Contravariant.Adjoint: [runAdjointT] :: AdjointT f g w a -> g (w (f a))
+ Control.Monad.Trans.Contravariant.Adjoint: [runAdjointT] :: AdjointT (f :: Type -> Type) (g :: Type -> Type) (w :: Type -> Type) a -> g (w (f a))
- Control.Monad.Trans.Contravariant.Adjoint: newtype AdjointT f g w a
+ Control.Monad.Trans.Contravariant.Adjoint: newtype AdjointT (f :: Type -> Type) (g :: Type -> Type) (w :: Type -> Type) a
- Control.Monad.Trans.Contravariant.Adjoint: type Adjoint f g = AdjointT f g Identity
+ Control.Monad.Trans.Contravariant.Adjoint: type Adjoint (f :: Type -> Type) (g :: Type -> Type) = AdjointT f g Identity
- Control.Monad.Trans.Conts: ContsT :: (w (a -> m r) -> m r) -> ContsT r w m a
+ Control.Monad.Trans.Conts: ContsT :: (w (a -> m r) -> m r) -> ContsT r (w :: Type -> Type) (m :: Type -> Type) a
- Control.Monad.Trans.Conts: [runContsT] :: ContsT r w m a -> w (a -> m r) -> m r
+ Control.Monad.Trans.Conts: [runContsT] :: ContsT r (w :: Type -> Type) (m :: Type -> Type) a -> w (a -> m r) -> m r
- Control.Monad.Trans.Conts: callCC :: Comonad w => ((a -> ContsT r w m b) -> ContsT r w m a) -> ContsT r w m a
+ Control.Monad.Trans.Conts: callCC :: forall (w :: Type -> Type) a r (m :: Type -> Type) b. Comonad w => ((a -> ContsT r w m b) -> ContsT r w m a) -> ContsT r w m a
- Control.Monad.Trans.Conts: newtype ContsT r w m a
+ Control.Monad.Trans.Conts: newtype ContsT r (w :: Type -> Type) (m :: Type -> Type) a
- Control.Monad.Trans.Conts: type Conts r w = ContsT r w Identity
+ Control.Monad.Trans.Conts: type Conts r (w :: Type -> Type) = ContsT r w Identity
- Data.Functor.Adjunction: class (Functor f, Representable u) => Adjunction f u | f -> u, u -> f
+ Data.Functor.Adjunction: class (Functor f, Representable u) => Adjunction (f :: Type -> Type) (u :: Type -> Type) | f -> u, u -> f
- Data.Functor.Adjunction: cozipL :: Adjunction f u => f (Either a b) -> Either (f a) (f b)
+ Data.Functor.Adjunction: cozipL :: forall f (u :: Type -> Type) a b. Adjunction f u => f (Either a b) -> Either (f a) (f b)
- Data.Functor.Adjunction: duplicateL :: Adjunction f u => f a -> f (f a)
+ Data.Functor.Adjunction: duplicateL :: forall f (u :: Type -> Type) a. Adjunction f u => f a -> f (f a)
- Data.Functor.Adjunction: extractL :: Adjunction f u => f a -> a
+ Data.Functor.Adjunction: extractL :: forall f (u :: Type -> Type) a. Adjunction f u => f a -> a
- Data.Functor.Adjunction: splitL :: Adjunction f u => f a -> (a, f ())
+ Data.Functor.Adjunction: splitL :: forall f (u :: Type -> Type) a. Adjunction f u => f a -> (a, f ())
- Data.Functor.Adjunction: unabsurdL :: Adjunction f u => f Void -> Void
+ Data.Functor.Adjunction: unabsurdL :: forall f (u :: Type -> Type). Adjunction f u => f Void -> Void
- Data.Functor.Adjunction: zipR :: Adjunction f u => (u a, u b) -> u (a, b)
+ Data.Functor.Adjunction: zipR :: forall (f :: Type -> Type) u a b. Adjunction f u => (u a, u b) -> u (a, b)
- Data.Functor.Contravariant.Adjunction: class (Contravariant f, Representable g) => Adjunction f g | f -> g, g -> f
+ Data.Functor.Contravariant.Adjunction: class (Contravariant f, Representable g) => Adjunction (f :: Type -> Type) (g :: Type -> Type) | f -> g, g -> f
- Data.Functor.Contravariant.Rep: class Contravariant f => Representable f where {
+ Data.Functor.Contravariant.Rep: class Contravariant f => Representable (f :: Type -> Type) where {
- Data.Functor.Contravariant.Rep: type Rep f :: *;
+ Data.Functor.Contravariant.Rep: type Rep (f :: Type -> Type);
- Data.Functor.Rep: Co :: f a -> Co f a
+ Data.Functor.Rep: Co :: f a -> Co (f :: Type -> Type) a
- Data.Functor.Rep: WrapRep :: Rep f -> WrappedRep f
+ Data.Functor.Rep: WrapRep :: Rep f -> WrappedRep (f :: Type -> Type)
- Data.Functor.Rep: [unCo] :: Co f a -> f a
+ Data.Functor.Rep: [unCo] :: Co (f :: Type -> Type) a -> f a
- Data.Functor.Rep: [unwrapRep] :: WrappedRep f -> Rep f
+ Data.Functor.Rep: [unwrapRep] :: WrappedRep (f :: Type -> Type) -> Rep f
- Data.Functor.Rep: class Distributive f => Representable f where {
+ Data.Functor.Rep: class Distributive f => Representable (f :: Type -> Type) where {
- Data.Functor.Rep: ifoldMapRep :: forall r m a. (Representable r, Foldable r, Monoid m) => (Rep r -> a -> m) -> r a -> m
+ Data.Functor.Rep: ifoldMapRep :: (Representable r, Foldable r, Monoid m) => (Rep r -> a -> m) -> r a -> m
- Data.Functor.Rep: index :: (Representable f, Generic1 f, GRep f ~ Rep f, GIndex (Rep1 f)) => f a -> Rep f -> a
+ Data.Functor.Rep: index :: Representable f => f a -> Rep f -> a
- Data.Functor.Rep: itraverseRep :: forall r f a a'. (Representable r, Traversable r, Applicative f) => (Rep r -> a -> f a') -> r a -> f (r a')
+ Data.Functor.Rep: itraverseRep :: (Representable r, Traversable r, Applicative f) => (Rep r -> a -> f a') -> r a -> f (r a')
- Data.Functor.Rep: newtype Co f a
+ Data.Functor.Rep: newtype Co (f :: Type -> Type) a
- Data.Functor.Rep: newtype WrappedRep f
+ Data.Functor.Rep: newtype WrappedRep (f :: Type -> Type)
- Data.Functor.Rep: tabulate :: (Representable f, Generic1 f, GRep f ~ Rep f, GTabulate (Rep1 f)) => (Rep f -> a) -> f a
+ Data.Functor.Rep: tabulate :: Representable f => (Rep f -> a) -> f a
- Data.Functor.Rep: type GRep f = GRep' (Rep1 f)
+ Data.Functor.Rep: type GRep (f :: Type -> Type) = GRep' Rep1 f
- Data.Functor.Rep: type Rep f = GRep f;
+ Data.Functor.Rep: type Rep f :: Type -> Type = GRep f;
Files
- CHANGELOG.markdown +4/−0
- adjunctions.cabal +9/−10
CHANGELOG.markdown view
@@ -1,3 +1,7 @@+4.4.4 [2026.01.10]+------------------+* Remove unused dependencies.+ 4.4.3 [2025.03.03] ------------------ * Drop support for pre-8.0 versions of GHC.
adjunctions.cabal view
@@ -1,6 +1,6 @@ name: adjunctions category: Data Structures, Adjunctions-version: 4.4.3+version: 4.4.4 license: BSD2 cabal-version: >= 1.10 license-file: LICENSE@@ -28,10 +28,11 @@ , GHC == 9.0.2 , GHC == 9.2.8 , GHC == 9.4.8- , GHC == 9.6.6+ , GHC == 9.6.7 , GHC == 9.8.4- , GHC == 9.10.1- , GHC == 9.12.1+ , GHC == 9.10.3+ , GHC == 9.12.2+ , GHC == 9.14.1 source-repository head type: git@@ -49,21 +50,19 @@ UndecidableInstances build-depends:- array >= 0.3.0.2 && < 0.7, base >= 4.9 && < 5, comonad >= 4 && < 6, containers >= 0.3 && < 0.9,- contravariant >= 1 && < 2, distributive >= 0.5.1 && < 1, free >= 4 && < 6, mtl >= 2.0.1 && < 2.4, profunctors >= 4 && < 6, tagged >= 0.7 && < 1, semigroupoids >= 4 && < 7,- semigroups >= 0.11 && < 1,- transformers >= 0.5.2 && < 0.7,- transformers-compat >= 0.3 && < 1,- void >= 0.5.5.1 && < 1+ transformers >= 0.5.2 && < 0.7++ if !impl(ghc>=8.6)+ build-depends: contravariant (>=1.5 && <2) exposed-modules: Control.Comonad.Representable.Store