packages feed

functor-combinators 0.3.4.1 → 0.3.4.2

raw patch · 3 files changed

+16/−2 lines, 3 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

- Control.Applicative.Step: instance forall k1 k2 (a :: k2) (b :: k1). Data.Functor.Alt.Alt (Control.Applicative.Step.Void3 a b)
- Control.Applicative.Step: instance forall k1 k2 (a :: k2) (b :: k1). Data.Functor.Bind.Class.Apply (Control.Applicative.Step.Void3 a b)
- Control.Applicative.Step: instance forall k1 k2 (a :: k2) (b :: k1). Data.Functor.Bind.Class.Bind (Control.Applicative.Step.Void3 a b)
- Control.Applicative.Step: instance forall k1 k2 (a :: k2) (b :: k1). Data.Functor.Classes.Eq1 (Control.Applicative.Step.Void3 a b)
- Control.Applicative.Step: instance forall k1 k2 (a :: k2) (b :: k1). Data.Functor.Classes.Ord1 (Control.Applicative.Step.Void3 a b)
- Control.Applicative.Step: instance forall k1 k2 (a :: k2) (b :: k1). Data.Functor.Classes.Read1 (Control.Applicative.Step.Void3 a b)
- Control.Applicative.Step: instance forall k1 k2 (a :: k2) (b :: k1). Data.Functor.Classes.Show1 (Control.Applicative.Step.Void3 a b)
- Control.Applicative.Step: instance forall k1 k2 (a :: k2) (b :: k1). Data.Functor.Contravariant.Contravariant (Control.Applicative.Step.Void3 a b)
- Control.Applicative.Step: instance forall k1 k2 (a :: k2) (b :: k1). Data.Functor.Invariant.Invariant (Control.Applicative.Step.Void3 a b)
- Control.Applicative.Step: instance forall k1 k2 (a :: k2) (b :: k1). GHC.Base.Semigroup (Control.Applicative.Step.Void2 a b)
- Control.Applicative.Step: instance forall k1 k2 k3 (a :: k3) (b :: k2) (c :: k1). GHC.Base.Semigroup (Control.Applicative.Step.Void3 a b c)
- Data.Functor.Combinator: [Day] :: forall (f :: Type -> Type) (g :: Type -> Type) a b c. () => f b -> g c -> (b -> c -> a) -> Day f g a
- Data.Functor.Combinator: data V1 (p :: k) :: forall k. () => k -> Type
- Data.Functor.Combinator: newtype ReaderT r (m :: k -> Type) (a :: k) :: forall k. () => Type -> k -> Type -> k -> Type
- Data.Functor.Combinator: newtype IdentityT (f :: k -> Type) (a :: k) :: forall k. () => k -> Type -> k -> Type
- Data.HBifunctor: instance forall k1 (f :: k1 -> *) k2 (g :: k2) (a :: k1). (Data.Typeable.Internal.Typeable g, Data.Typeable.Internal.Typeable a, Data.Typeable.Internal.Typeable f, Data.Typeable.Internal.Typeable k2, Data.Typeable.Internal.Typeable k1, Data.Data.Data (f a)) => Data.Data.Data (Data.HBifunctor.LeftF f g a)
- Data.HBifunctor: instance forall k1 k2 (g :: k2) (f :: k1 -> *). Data.HFunctor.Interpret.Interpret (Data.HBifunctor.RightF g) f
- Data.HBifunctor: instance forall k1 k2 (g :: k2). Data.HFunctor.HBind (Data.HBifunctor.RightF g)
- Data.HBifunctor: instance forall k1 k2 (g :: k2). Data.HFunctor.Inject (Data.HBifunctor.RightF g)
- Data.HBifunctor: instance forall k1 k2 (g :: k2). Data.HFunctor.Internal.HFunctor (Data.HBifunctor.RightF g)
- Data.HFunctor.Route: instance (a Data.Type.Equality.~ Data.Void.Void) => Data.HFunctor.HBind (Data.HFunctor.Route.Pre a)
- Data.HFunctor.Route: instance (a Data.Type.Equality.~ Data.Void.Void) => Data.HFunctor.Inject (Data.HFunctor.Route.Pre a)
- Data.HFunctor.Route: instance (a Data.Type.Equality.~ Data.Void.Void) => Data.HFunctor.Interpret.Interpret (Data.HFunctor.Route.Pre a) f
+ Control.Applicative.Step: instance forall k1 k2 (a :: k1) (b :: k2). Data.Functor.Alt.Alt (Control.Applicative.Step.Void3 a b)
+ Control.Applicative.Step: instance forall k1 k2 (a :: k1) (b :: k2). Data.Functor.Bind.Class.Apply (Control.Applicative.Step.Void3 a b)
+ Control.Applicative.Step: instance forall k1 k2 (a :: k1) (b :: k2). Data.Functor.Bind.Class.Bind (Control.Applicative.Step.Void3 a b)
+ Control.Applicative.Step: instance forall k1 k2 (a :: k1) (b :: k2). Data.Functor.Classes.Eq1 (Control.Applicative.Step.Void3 a b)
+ Control.Applicative.Step: instance forall k1 k2 (a :: k1) (b :: k2). Data.Functor.Classes.Ord1 (Control.Applicative.Step.Void3 a b)
+ Control.Applicative.Step: instance forall k1 k2 (a :: k1) (b :: k2). Data.Functor.Classes.Read1 (Control.Applicative.Step.Void3 a b)
+ Control.Applicative.Step: instance forall k1 k2 (a :: k1) (b :: k2). Data.Functor.Classes.Show1 (Control.Applicative.Step.Void3 a b)
+ Control.Applicative.Step: instance forall k1 k2 (a :: k1) (b :: k2). Data.Functor.Contravariant.Contravariant (Control.Applicative.Step.Void3 a b)
+ Control.Applicative.Step: instance forall k1 k2 (a :: k1) (b :: k2). Data.Functor.Invariant.Invariant (Control.Applicative.Step.Void3 a b)
+ Control.Applicative.Step: instance forall k1 k2 (a :: k1) (b :: k2). GHC.Base.Semigroup (Control.Applicative.Step.Void2 a b)
+ Control.Applicative.Step: instance forall k1 k2 k3 (a :: k1) (b :: k2) (c :: k3). GHC.Base.Semigroup (Control.Applicative.Step.Void3 a b c)
+ Data.Functor.Combinator: Day :: f b -> g c -> (b -> c -> a) -> Day (f :: Type -> Type) (g :: Type -> Type) a
+ Data.Functor.Combinator: data ( (f :: k -> Type) :+: (g :: k -> Type) ) (p :: k)
+ Data.Functor.Combinator: data V1 (p :: k)
+ Data.Functor.Combinator: newtype IdentityT (f :: k -> Type) (a :: k)
+ Data.Functor.Combinator: newtype ReaderT r (m :: Type -> Type) a
+ Data.HBifunctor: instance forall k1 (f :: k1 -> *) k2 (g :: k2) (a :: k1). (Data.Typeable.Internal.Typeable g, Data.Typeable.Internal.Typeable a, Data.Typeable.Internal.Typeable f, Data.Typeable.Internal.Typeable k1, Data.Typeable.Internal.Typeable k2, Data.Data.Data (f a)) => Data.Data.Data (Data.HBifunctor.LeftF f g a)
+ Data.HBifunctor: instance forall k1 k2 (g :: k1) (f :: k2 -> *). Data.HFunctor.Interpret.Interpret (Data.HBifunctor.RightF g) f
+ Data.HBifunctor: instance forall k1 k2 (g :: k1). Data.HFunctor.HBind (Data.HBifunctor.RightF g)
+ Data.HBifunctor: instance forall k1 k2 (g :: k1). Data.HFunctor.Inject (Data.HBifunctor.RightF g)
+ Data.HBifunctor: instance forall k1 k2 (g :: k1). Data.HFunctor.Internal.HFunctor (Data.HBifunctor.RightF g)
+ Data.HFunctor.Route: instance (a GHC.Types.~ Data.Void.Void) => Data.HFunctor.HBind (Data.HFunctor.Route.Pre a)
+ Data.HFunctor.Route: instance (a GHC.Types.~ Data.Void.Void) => Data.HFunctor.Inject (Data.HFunctor.Route.Pre a)
+ Data.HFunctor.Route: instance (a GHC.Types.~ Data.Void.Void) => Data.HFunctor.Interpret.Interpret (Data.HFunctor.Route.Pre a) f
+ Data.HFunctor.Route: instance Data.HFunctor.Inject t => Data.HFunctor.Inject (Data.HFunctor.Route.PostT t)
+ Data.HFunctor.Route: instance Data.HFunctor.Internal.HFunctor t => Data.HFunctor.Internal.HFunctor (Data.HFunctor.Route.PostT t)
+ Data.HFunctor.Route: instance Data.HFunctor.Interpret.Interpret t f => Data.HFunctor.Interpret.Interpret (Data.HFunctor.Route.PostT t) f
- Control.Natural.IsoF: type (~>) (f :: k -> Type) (g :: k -> Type) = forall (x :: k). () => f x -> g x
+ Control.Natural.IsoF: type (f :: k -> Type) ~> (g :: k -> Type) = forall (x :: k). () => f x -> g x
- Data.Functor.Combinator: (:*:) :: f p -> g p -> (:*:)
+ Data.Functor.Combinator: (:*:) :: f p -> g p -> (:*:) (f :: k -> Type) (g :: k -> Type) (p :: k)
- Data.Functor.Combinator: ComposeT :: f (g m) a -> ComposeT a
+ Data.Functor.Combinator: ComposeT :: f (g m) a -> ComposeT (f :: (Type -> Type) -> Type -> Type) (g :: (Type -> Type) -> Type -> Type) (m :: Type -> Type) a
- Data.Functor.Combinator: EnvT :: e -> w a -> EnvT e a
+ Data.Functor.Combinator: EnvT :: e -> w a -> EnvT e (w :: Type -> Type) a
- Data.Functor.Combinator: IdentityT :: f a -> IdentityT
+ Data.Functor.Combinator: IdentityT :: f a -> IdentityT (f :: k -> Type) (a :: k)
- Data.Functor.Combinator: L1 :: f p -> (:+:)
+ Data.Functor.Combinator: L1 :: f p -> (:+:) (f :: k -> Type) (g :: k -> Type) (p :: k)
- Data.Functor.Combinator: R1 :: g p -> (:+:)
+ Data.Functor.Combinator: R1 :: g p -> (:+:) (f :: k -> Type) (g :: k -> Type) (p :: k)
- Data.Functor.Combinator: ReaderT :: (r -> m a) -> ReaderT r
+ Data.Functor.Combinator: ReaderT :: (r -> m a) -> ReaderT r (m :: Type -> Type) a
- Data.Functor.Combinator: That1 :: g a -> These1 a
+ Data.Functor.Combinator: That1 :: g a -> These1 (f :: Type -> Type) (g :: Type -> Type) a
- Data.Functor.Combinator: These1 :: f a -> g a -> These1 a
+ Data.Functor.Combinator: These1 :: f a -> g a -> These1 (f :: Type -> Type) (g :: Type -> Type) a
- Data.Functor.Combinator: This1 :: f a -> These1 a
+ Data.Functor.Combinator: This1 :: f a -> These1 (f :: Type -> Type) (g :: Type -> Type) a
- Data.Functor.Combinator: [Coyoneda] :: forall (f :: Type -> Type) a b. () => (b -> a) -> f b -> Coyoneda f a
+ Data.Functor.Combinator: [Coyoneda] :: forall b a (f :: Type -> Type). (b -> a) -> f b -> Coyoneda f a
- Data.Functor.Combinator: [getComposeT] :: ComposeT a -> f (g m) a
+ Data.Functor.Combinator: [getComposeT] :: ComposeT (f :: (Type -> Type) -> Type -> Type) (g :: (Type -> Type) -> Type -> Type) (m :: Type -> Type) a -> f (g m) a
- Data.Functor.Combinator: [runIdentityT] :: IdentityT -> f a
+ Data.Functor.Combinator: [runIdentityT] :: IdentityT (f :: k -> Type) (a :: k) -> f a
- Data.Functor.Combinator: [runReaderT] :: ReaderT r -> r -> m a
+ Data.Functor.Combinator: [runReaderT] :: ReaderT r (m :: Type -> Type) a -> r -> m a
- Data.Functor.Combinator: collectI :: forall m. Monoid m => Interpret t (AltConst m) => (forall x. f x -> b) -> t f a -> [b]
+ Data.Functor.Combinator: collectI :: (forall m. Monoid m => Interpret t (AltConst m)) => (forall x. f x -> b) -> t f a -> [b]
- Data.Functor.Combinator: icollect :: forall m. Monoid m => Interpret t (AltConst m) => (forall x. f x -> b) -> t f a -> [b]
+ Data.Functor.Combinator: icollect :: (forall m. Monoid m => Interpret t (AltConst m)) => (forall x. f x -> b) -> t f a -> [b]
- Data.Functor.Combinator: icollect1 :: forall m. Semigroup m => Interpret t (AltConst m) => (forall x. f x -> b) -> t f a -> NonEmpty b
+ Data.Functor.Combinator: icollect1 :: (forall m. Semigroup m => Interpret t (AltConst m)) => (forall x. f x -> b) -> t f a -> NonEmpty b
- Data.Functor.Combinator: ifanout :: forall m. Monoid m => Interpret t (Op m) => (forall x. f x -> x -> b) -> t f a -> a -> [b]
+ Data.Functor.Combinator: ifanout :: (forall m. Monoid m => Interpret t (Op m)) => (forall x. f x -> x -> b) -> t f a -> a -> [b]
- Data.Functor.Combinator: ifanout1 :: forall m. Semigroup m => Interpret t (Op m) => (forall x. f x -> x -> b) -> t f a -> a -> NonEmpty b
+ Data.Functor.Combinator: ifanout1 :: (forall m. Semigroup m => Interpret t (Op m)) => (forall x. f x -> x -> b) -> t f a -> a -> NonEmpty b
- Data.Functor.Combinator: type (~>) (f :: k -> Type) (g :: k -> Type) = forall (x :: k). () => f x -> g x
+ Data.Functor.Combinator: type (f :: k -> Type) ~> (g :: k -> Type) = forall (x :: k). () => f x -> g x
- Data.HBifunctor: WrapHBifunctor :: t f g a -> WrappedHBifunctor t
+ Data.HBifunctor: WrapHBifunctor :: t f g a -> WrappedHBifunctor t (f :: k -> Type) (g :: k -> Type) (a :: k)
- Data.HBifunctor: [unwrapHBifunctor] :: WrappedHBifunctor t -> t f g a
+ Data.HBifunctor: [unwrapHBifunctor] :: WrappedHBifunctor t (f :: k -> Type) (g :: k -> Type) (a :: k) -> t f g a
- Data.HFunctor.Interpret: collectI :: forall m. Monoid m => Interpret t (AltConst m) => (forall x. f x -> b) -> t f a -> [b]
+ Data.HFunctor.Interpret: collectI :: (forall m. Monoid m => Interpret t (AltConst m)) => (forall x. f x -> b) -> t f a -> [b]
- Data.HFunctor.Interpret: icollect :: forall m. Monoid m => Interpret t (AltConst m) => (forall x. f x -> b) -> t f a -> [b]
+ Data.HFunctor.Interpret: icollect :: (forall m. Monoid m => Interpret t (AltConst m)) => (forall x. f x -> b) -> t f a -> [b]
- Data.HFunctor.Interpret: icollect1 :: forall m. Semigroup m => Interpret t (AltConst m) => (forall x. f x -> b) -> t f a -> NonEmpty b
+ Data.HFunctor.Interpret: icollect1 :: (forall m. Semigroup m => Interpret t (AltConst m)) => (forall x. f x -> b) -> t f a -> NonEmpty b
- Data.HFunctor.Interpret: ifanout :: forall m. Monoid m => Interpret t (Op m) => (forall x. f x -> x -> b) -> t f a -> a -> [b]
+ Data.HFunctor.Interpret: ifanout :: (forall m. Monoid m => Interpret t (Op m)) => (forall x. f x -> x -> b) -> t f a -> a -> [b]
- Data.HFunctor.Interpret: ifanout1 :: forall m. Semigroup m => Interpret t (Op m) => (forall x. f x -> x -> b) -> t f a -> a -> NonEmpty b
+ Data.HFunctor.Interpret: ifanout1 :: (forall m. Semigroup m => Interpret t (Op m)) => (forall x. f x -> x -> b) -> t f a -> a -> NonEmpty b

Files

CHANGELOG.md view
@@ -20,6 +20,8 @@  *   **v0.3.4.1**: Add in missing `Functor` and `Invariant` instances for     `ProPre` and `ProPost`, as well as a bunch of instances for `ProPre`.+*   **v0.3.4.2**: Add in missing `HFunctor`, `Inject`, `Interpret` instances+    for `PostT`.  Version 0.3.3.0 ---------------
functor-combinators.cabal view
@@ -4,10 +4,10 @@ -- -- see: https://github.com/sol/hpack ----- hash: 6600494526f505f4af6a0fd9727f0cea1be40aae42b1d8c0071419840e46406f+-- hash: 30f4ef1eb5a260098c2bb6ed5f7db568e418a2254181c3d14ad09dea45de2798  name:           functor-combinators-version:        0.3.4.1+version:        0.3.4.2 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"
src/Data/HFunctor/Route.hs view
@@ -185,6 +185,18 @@                . contramap g                . unPostT +-- | @since 0.3.4.2+instance HFunctor t => HFunctor (PostT t) where+    hmap f = PostT . hmap (hmap f) . unPostT++-- | @since 0.3.4.2+instance Inject t => Inject (PostT t) where+    inject = PostT . inject . (id :<$>:)++-- | @since 0.3.4.2+instance Interpret t f => Interpret (PostT t) f where+    interpret f = interpret f . hmap getPost . unPostT+ -- | Run a @'PreT' t@ into a contravariant 'Divisible' context.  To run it -- in @t@s normal covariant context, use 'interpret'. --