functor-combinators 0.3.0.0 → 0.3.1.0

raw patch · 12 files changed

+262/−77 lines, 12 filesdep +dlistdep ~transformersPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependencies added: dlist

Dependency ranges changed: transformers

API changes (from Hackage documentation)

Files

• CHANGELOG.md +20/−0
• functor-combinators.cabal +3/−2
• src/Data/Functor/Combinator.hs +23/−4
• src/Data/Functor/Contravariant/Conclude.hs +4/−3
• src/Data/Functor/Contravariant/Night.hs +12/−3
• src/Data/Functor/Invariant/Day.hs +9/−5
• src/Data/Functor/Invariant/Night.hs +15/−10
• src/Data/HBifunctor/Associative.hs +33/−9
• src/Data/HBifunctor/Tensor.hs +2/−4
• src/Data/HFunctor/Chain.hs +13/−11
• src/Data/HFunctor/Interpret.hs +127/−23
• test/Tests/Util.hs +1/−3

@@ -1,6 +1,26 @@ Changelog ========= +Version 0.3.1.0+---------------++*August 7, 2020*++<https://github.com/mstksg/functor-combinators/releases/tag/v0.3.1.0>++*   *Data.HFunctor.Interpret*: `getI` and `collectI` made more efficient, and+    renamed to `iget` and `icollect`, respectively, to mirror `biget` and+    `bicollect`.  `getI` and `collectI` are left in with a deprecation warning.+    `icollect1` added to ensure a non-empty collection.  `AltConst` added to+    aid in implementation.+*   *Data.HBifunctor.Associative*: `bicollect1` added to ensure a non-empty+    collection.  *biget* and *bicollect* made more efficient.+*   *Data.Functor.Contravariant.Night*, *Data.Functor.Invariant.Night*:+    `refuted` added for a convenient `Not`.  Missing `Invariant` instance for+    `Not` also added.+*   *Data.HFunctor.Chain*: `chainPair` and `chain1Pair` renamed to `toChain`+    and `toChain1`, respectively, to mirror `toListBy` and `toNonEmptyBy`.+ Version 0.3.0.0 --------------- 

@@ -4,10 +4,10 @@ -- -- see: https://github.com/sol/hpack ----- hash: f15c50b5510d900bedb796a057cf16600ffce2bd338dba4daa4015f54400bc18+-- hash: 1a0532f73e7e38dc05fe8b07be016e7013f4f32c9daebe758f093a8abd0f4a45  name:           functor-combinators-version:        0.3.0.0+version:        0.3.1.0 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"@@ -83,6 +83,7 @@     , containers     , contravariant     , deriving-compat+    , dlist >=1.0     , free     , invariant     , kan-extensions

@@ -43,8 +43,9 @@   , Inject(..)   , Interpret(..)   , forI-  , getI-  , collectI+  , iget, icollect, icollect1+  , getI, collectI+  , AltConst(..)   -- ** Multi-Functors   -- | Classes that deal with two-functor combinators, that "mix" two   -- functors together in some way.@@ -52,7 +53,7 @@   -- *** Associative   , Associative(..)   , SemigroupIn(..)-  , biget, bicollect+  , biget, bicollect, bicollect1   , (!*!)   , (!+!)   , (!$!)@@ -94,6 +95,7 @@   , (:*:)(..), prodOutL, prodOutR   , (:+:)(..), V1   , These1(..)+  , Night(..), Not(..), refuted   , Comp(Comp, unComp)   , LeftF(..)   , RightF(..)@@ -127,12 +129,13 @@ import           Control.Natural.IsoF import           Data.Functor.Apply.Free import           Data.Functor.Contravariant-import           Data.Functor.Contravariant.Decide import           Data.Functor.Contravariant.Conclude+import           Data.Functor.Contravariant.Decide import           Data.Functor.Contravariant.Divise import           Data.Functor.Contravariant.Divisible import           Data.Functor.Coyoneda import           Data.Functor.Day+import           Data.Functor.Invariant.Night import           Data.Functor.These import           Data.HBifunctor import           Data.HBifunctor.Associative@@ -171,6 +174,14 @@ --          :* Nil -- @ --+-- Some notes on usefulness depending on how many components you have:+--+-- *    If you have 0 components, use 'conquer'.+-- *    If you have 1 component, use 'inject' directly.+-- *    If you have 2 components, use 'divide' directly.+-- *    If you have 3 or more components, these combinators may be useful;+--      otherwise you'd need to manually peel off tuples one-by-one.+-- -- @since 0.3.0.0 divideN     :: Divisible f@@ -263,6 +274,14 @@ --            :* stringBuilder --            :* Nil -- @+--+-- Some notes on usefulness depending on how many components you have:+--+-- *    If you have 0 components, use 'conclude'.+-- *    If you have 1 component, use 'inject' directly.+-- *    If you have 2 components, use 'decide' directly.+-- *    If you have 3 or more components, these combinators may be useful;+--      otherwise you'd need to manually peel off eithers one-by-one. -- -- @since 0.3.0.0 concludeN

@@ -67,9 +67,10 @@ import GHC.Generics #endif --- | The contravariant analogue of '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 constraint on 'Divisible'.+-- | 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+-- constraint on 'Divisible'. -- -- If one thinks of @f a@ as a consumer of @a@s, then 'conclude' defines -- a consumer that cannot ever receive /any/ input.

@@ -21,7 +21,7 @@   , trans1, trans2   , intro1, intro2   , elim1, elim2-  , Not(..)+  , Not(..), refuted   ) where  import           Control.Natural@@ -105,8 +105,17 @@ -- | A value of type @'Not' a@ is "proof" that @a@ is uninhabited. newtype Not a = Not { refute :: a -> Void } +-- | A useful shortcut for a common usage: 'Void' is always not so.+--+-- @since 0.3.1.0+refuted :: Not Void+refuted = Not id+ instance Contravariant Not where     contramap f (Not g) = Not (g . f)+-- | @since 0.3.1.0+instance Invariant Not where+    invmap _ = contramap  instance Semigroup (Not a) where     Not f <> Not g = Not (f <> g)@@ -114,12 +123,12 @@ -- | The left identity of 'Night' is 'Not'; this is one side of that -- isomorphism. intro1 :: g ~> Night Not g-intro1 x = Night (Not id) x Right+intro1 x = Night refuted x Right  -- | The right identity of 'Night' is 'Not'; this is one side of that -- isomorphism. intro2 :: f ~> Night f Not-intro2 x = Night x (Not id) Left+intro2 x = Night x refuted Left  -- | The left identity of 'Night' is 'Not'; this is one side of that -- isomorphism.

@@ -275,7 +275,7 @@     matchNE = matchChain1      consNE = More1-    toNonEmptyBy = More1 . hright Done1+    toNonEmptyBy = toChain1  instance Tensor Day Identity where     type ListBy Day = DayChain@@ -289,7 +289,7 @@     splitNE = splitChain1     splittingLB = splittingChain -    toListBy = More . hright inject+    toListBy = toChain  instance Matchable Day Identity where     unsplitNE (Day x xs f g) = case xs of@@ -323,9 +323,13 @@ --                   :* Nil -- @ ----- This is much more convenient than doing it using manual applications of--- 'divide' or 'divise' or 'Day', which would require manually peeling off--- tuples one-by-one.+-- Some notes on usefulness depending on how many components you have:+--+-- *    If you have 0 components, use 'Knot' directly.+-- *    If you have 1 component, use 'inject' or 'injectChain' directly.+-- *    If you have 2 components, use 'toListBy' or 'toChain'.+-- *    If you have 3 or more components, these combinators may be useful;+--      otherwise you'd need to manually peel off tuples one-by-one. assembleDayChain     :: NP f as     -> DayChain f (NP I as)

@@ -13,7 +13,7 @@ -- @since 0.3.0.0 module Data.Functor.Invariant.Night (     Night(..)-  , Not(..)+  , Not(..), refuted   , night   , runNightAlt   , runNightDecide@@ -46,7 +46,7 @@ import           Data.Functor.Alt import           Data.Functor.Contravariant.Conclude import           Data.Functor.Contravariant.Decide-import           Data.Functor.Contravariant.Night    (Not(..))+import           Data.Functor.Contravariant.Night    (Not(..), refuted) import           Data.Functor.Invariant import           Data.Functor.Plus import           Data.HBifunctor@@ -149,12 +149,12 @@ -- | The left identity of 'Night' is 'Not'; this is one side of that -- isomorphism. intro1 :: g ~> Night Not g-intro1 y = Night (Not id) y Right absurd id+intro1 y = Night refuted y Right absurd id  -- | The right identity of 'Night' is 'Not'; this is one side of that -- isomorphism. intro2 :: f ~> Night f Not-intro2 x = Night x (Not id) Left id absurd+intro2 x = Night x refuted Left id absurd  -- | The left identity of 'Night' is 'Not'; this is one side of that -- isomorphism.@@ -282,7 +282,7 @@     matchNE = matchChain1      consNE = More1-    toNonEmptyBy = chain1Pair+    toNonEmptyBy = toChain1  instance Tensor Night Not where     type ListBy Night = NightChain@@ -296,7 +296,7 @@     splitNE = splitChain1     splittingLB = splittingChain -    toListBy = chainPair+    toListBy = toChain  instance Matchable Night Not where     unsplitNE (Night x xs f g h) = case xs of@@ -330,9 +330,13 @@ --                     :* Nil -- @ ----- This is much more convenient than doing it using manual applications of--- 'decide' or 'Data.Functor.Contravariant.Divisible.choose' or 'Night',--- which would require manually peeling off eithers one-by-one.+-- Some notes on usefulness depending on how many components you have:+--+-- *    If you have 0 components, use 'Reject' directly.+-- *    If you have 1 component, use 'inject' or 'injectChain' directly.+-- *    If you have 2 components, use 'toListBy' or 'toChain'.+-- *    If you have 3 or more components, these combinators may be useful;+--      otherwise you'd need to manually peel off eithers one-by-one. assembleNightChain     :: NP f as     -> NightChain f (NS I as)@@ -385,7 +389,8 @@  -- | A version of 'concatNightChain' but for 'NightChain1' instead.  Can be -- useful if you intend on interpreting it into something with only--- a 'Decide' or 'Alt' instance, but no 'Decidable' or 'Plus' or+-- a 'Decide' or 'Alt' instance, but no+-- 'Data.Functor.Contravariant.Divisible.Decidable' or 'Plus' or -- 'Control.Applicative.Alternative'. concatNightChain1     :: Invariant f

@@ -45,6 +45,7 @@   -- ** Utility   , biget   , bicollect+  , bicollect1   , (!*!)   , (!$!)   , (!+!)@@ -52,7 +53,6 @@   , WrapNE(..)   ) where -import           Control.Applicative import           Control.Applicative.ListF import           Control.Applicative.Step import           Control.Monad.Freer.Church@@ -88,6 +88,8 @@ import           Data.List.NonEmpty                        (NonEmpty(..)) import           Data.Void import           GHC.Generics+import qualified Data.DList                                as DL+import qualified Data.DList.DNonEmpty                      as NEDL import qualified Data.Functor.Contravariant.Day            as CD import qualified Data.Functor.Contravariant.Night          as N import qualified Data.Functor.Day                          as D@@ -307,8 +309,11 @@ -- you may have extra constraints on @b@. -- -- *    If @f@ is unconstrained, there are no constraints on @b@--- *    If @f@ must be 'Apply', @b@ needs to be an instance of 'Semigroup'--- *    If @f@ must be 'Applicative', @b@ needs to be an instance of 'Monoid'+-- *    If @f@ must be 'Apply', 'Alt', 'Divise', or 'Decide', @b@ needs to be an instance of 'Semigroup'+-- *    If @f@ is 'Applicative', 'Plus',+--      'Data.Functor.Contravariant.Divisible.Divisible', or+--      'Data.Functor.Contravariant.Conclude.Conclude', @b@ needs to be an+--      instance of 'Monoid' -- -- For some constraints (like 'Monad'), this will not be usable. --@@ -325,12 +330,12 @@ --     -> Sum Int -- @ biget-    :: SemigroupIn t (Const b)+    :: SemigroupIn t (AltConst b)     => (forall x. f x -> b)     -> (forall x. g x -> b)     -> t f g a     -> b-biget f g = getConst . binterpret (Const . f) (Const . g)+biget f g = getAltConst . binterpret (AltConst . f) (AltConst . g)  -- | Infix alias for 'biget' --@@ -347,7 +352,7 @@ --     -> Sum Int -- @ (!$!)-    :: SemigroupIn t (Const b)+    :: SemigroupIn t (AltConst b)     => (forall x. f x -> b)     -> (forall x. g x -> b)     -> t f g a@@ -386,14 +391,33 @@ -- instances of @f@ and @g@ inside a @t f g a@. -- -- This will work if the constraint on @f@ for @'SemigroupIn' t f@ is--- 'Apply' or 'Applicative', or if it is unconstrained.+-- 'Apply', 'Applicative', 'Alt', 'Plus', 'Divise',+-- 'Data.Functor.Contravariant.Divisible.Divisible', 'Decide',+-- 'Data.Functor.Contravariant.Conclude.Conclude', or if it is unconstrained. bicollect-    :: SemigroupIn t (Const [b])+    :: SemigroupIn t (AltConst (DL.DList b))     => (forall x. f x -> b)     -> (forall x. g x -> b)     -> t f g a     -> [b]-bicollect f g = biget ((:[]) . f) ((:[]) . g)+bicollect f g = toList . biget (DL.singleton . f) (DL.singleton . g)++-- | Useful wrapper over 'biget' to allow you to collect a @b@ from all+-- instances of @f@ and @g@ inside a @t f g a@ into a non-empty collection+-- of @b@s.+--+-- This will work if the constraint on @f@ for @'SemigroupIn' t f@ is+-- 'Apply', 'Alt', 'Divise', 'Decide', or if it is unconstrained.+--+-- @since 0.3.1.0+bicollect1+    :: SemigroupIn t (AltConst (NEDL.DNonEmpty b))+    => (forall x. f x -> b)+    -> (forall x. g x -> b)+    -> t f g a+    -> NonEmpty b+bicollect1 f g = NEDL.toNonEmpty . biget (NEDL.singleton . f) (NEDL.singleton . g)+  instance Associative (:*:) where     type NonEmptyBy (:*:) = NonEmptyF

@@ -256,13 +256,11 @@ prodRightIdentity :: g <~> g :*: Proxy prodRightIdentity = isoF (:*: Proxy) (\case x :*: _ -> x) --- | 'outL' for ':*:' actually does not require 'Functor'.  This is the--- more general version.+-- | A poly-kinded version of 'outL' for ':*:'. prodOutL :: f :*: g ~> f prodOutL (x :*: _) = x --- | 'outR' for ':*:' actually does not require 'Functor'.  This is the--- more general version.+-- | A poly-kinded version of 'outR' for ':*:'. prodOutR :: f :*: g ~> g prodOutR (_ :*: y) = y 

@@ -32,7 +32,7 @@   , unrolling   , appendChain   , splittingChain-  , chainPair+  , toChain   , injectChain   , unconsChain   -- * 'Chain1'@@ -45,7 +45,7 @@   , appendChain1   , fromChain1   , matchChain1-  , chain1Pair+  , toChain1   , injectChain1   -- ** Matchable   -- | The following conversions between 'Chain' and 'Chain1' are only@@ -240,11 +240,12 @@           Done1 x  -> f x           More1 xs -> binterpret f go xs --- | Convert a tensor value pairing two @f@s into a two-item chain.+-- | Convert a tensor value pairing two @f@s into a two-item 'Chain1'.  An+-- analogue of 'toNonEmptyBy'. ----- @since 0.3.0.0-chain1Pair :: HBifunctor t => t f f ~> Chain1 t f-chain1Pair = More1 . hright Done1+-- @since 0.3.1.0+toChain1 :: HBifunctor t => t f f ~> Chain1 t f+toChain1 = More1 . hright Done1  -- | Create a singleton 'Chain1'. --@@ -486,13 +487,14 @@           Done x  -> pureT @t x           More xs -> binterpret f go xs --- | Convert a tensor value pairing two @f@s into a two-item chain.+-- | Convert a tensor value pairing two @f@s into a two-item 'Chain'.  An+-- analogue of 'toListBy'. ----- @since 0.3.0.0-chainPair :: Tensor t i => t f f ~> Chain t i f-chainPair = More . hright inject+-- @since 0.3.1.0+toChain :: Tensor t i => t f f ~> Chain t i f+toChain = More . hright inject --- | Create a singleton chain+-- | Create a singleton chain. -- -- @since 0.3.0.0 injectChain :: Tensor t i => f ~> Chain t i f

@@ -43,8 +43,11 @@ module Data.HFunctor.Interpret (     Interpret(..), forI   -- * Utilities-  , getI-  , collectI+  , iget+  , icollect+  , icollect1+  , getI, collectI+  , AltConst(..)   , AndC   , WrapHF(..)   ) where@@ -54,7 +57,7 @@ import           Control.Applicative.Lift import           Control.Applicative.ListF import           Control.Applicative.Step-import           Control.Comonad.Trans.Env           (EnvT(..))+import           Control.Comonad.Trans.Env            (EnvT(..)) import           Control.Monad.Freer.Church import           Control.Monad.Reader import           Control.Monad.Trans.Compose@@ -62,26 +65,35 @@ import           Control.Natural import           Data.Coerce import           Data.Data+import           Data.Foldable import           Data.Functor.Bind import           Data.Functor.Classes import           Data.Functor.Contravariant+import           Data.Functor.Contravariant.Conclude+import           Data.Functor.Contravariant.Decide+import           Data.Functor.Contravariant.Divise+import           Data.Functor.Contravariant.Divisible import           Data.Functor.Coyoneda+import           Data.Functor.Invariant import           Data.Functor.Plus import           Data.Functor.Product import           Data.Functor.Reverse import           Data.Functor.Sum import           Data.Functor.These import           Data.HFunctor+import           Data.List.NonEmpty                   (NonEmpty(..)) import           Data.Maybe import           Data.Pointed import           Data.Semigroup.Foldable import           GHC.Generics-import qualified Control.Alternative.Free            as Alt-import qualified Control.Applicative.Free            as Ap-import qualified Control.Applicative.Free.Fast       as FAF-import qualified Control.Applicative.Free.Final      as FA-import qualified Data.Functor.Contravariant.Coyoneda as CCY-import qualified Data.Map.NonEmpty                   as NEM+import qualified Control.Alternative.Free             as Alt+import qualified Control.Applicative.Free             as Ap+import qualified Control.Applicative.Free.Fast        as FAF+import qualified Control.Applicative.Free.Final       as FA+import qualified Data.DList                           as DL+import qualified Data.DList.DNonEmpty                 as NEDL+import qualified Data.Functor.Contravariant.Coyoneda  as CCY+import qualified Data.Map.NonEmpty                    as NEM  -- | An 'Interpret' lets us move in and out of the "enhanced" 'Functor' (@t -- f@) and the functor it enhances (@f@).  An instance @'Interpret' t f@@@ -157,43 +169,135 @@ -- may have extra constraints on @b@. -- -- *    If @f@ is unconstrained, there are no constraints on @b@--- *    If @f@ must be 'Apply', @b@ needs to be an instance of 'Semigroup'--- *    If @f@ is 'Applicative', @b@ needs to be an instance of 'Monoid'+-- *    If @f@ must be 'Apply', 'Alt', 'Divise', or 'Decide', @b@ needs to be an instance of 'Semigroup'+-- *    If @f@ is 'Applicative', 'Plus', 'Divisible', or 'Conclude', @b@ needs to be an instance of 'Monoid' -- -- For some constraints (like 'Monad'), this will not be usable. -- -- @ -- -- get the length of the @Map String@ in the 'Step'.--- 'collectI' length+-- 'icollect' length --      :: Step (Map String) Bool --      -> Int -- @-getI-    :: Interpret t (Const b)+--+-- @since 0.3.1.0+iget+    :: Interpret t (AltConst b)     => (forall x. f x -> b)     -> t f a     -> b-getI f = getConst . interpret (Const . f)+iget f = getAltConst . interpret (AltConst . f) --- | Useful wrapper over 'getI' to allow you to collect a @b@ from all+-- | (Deprecated) Old name for 'getI'; will be removed in a future+-- version.+getI :: Interpret t (AltConst b) => (forall x. f x -> b) -> t f a -> b+getI = iget+{-# DEPRECATED getI "Use iget instead" #-}++-- | Useful wrapper over 'iget' to allow you to collect a @b@ from all -- instances of @f@ inside a @t f a@. ----- Will work if there is an instance of @'Interpret' t ('Const' [b])@,--- which will be the case if the constraint on the target functor is--- 'Functor', 'Apply', 'Applicative', or unconstrianed.+-- Will work if there is an instance of @'Interpret' t ('AltConst'+-- ('DL.DList' b))@, which will be the case if the constraint on the target+-- functor is 'Functor', 'Apply', 'Applicative', 'Alt', 'Plus',+-- 'Data.Functor.Contravariant.Decide.Decide', 'Divisible', 'Decide',+-- 'Conclude', or unconstrained. -- -- @ -- -- get the lengths of all @Map String@s in the 'Ap.Ap'.--- 'collectI' length+-- 'icollect' length --      :: Ap (Map String) Bool --      -> [Int] -- @-collectI-    :: Interpret t (Const [b])+--+-- @since 0.3.1.0+icollect+    :: Interpret t (AltConst (DL.DList b))     => (forall x. f x -> b)     -> t f a     -> [b]-collectI f = getI ((:[]) . f)+icollect f = toList . iget (DL.singleton . f)++-- | (Deprecated) Old name for 'icollect'; will be removed in a future+-- version.+collectI :: Interpret t (AltConst (DL.DList b)) => (forall x. f x -> b) -> t f a -> [b]+collectI = icollect+{-# DEPRECATED collectI "Use icollect instead" #-}++-- | Useful wrapper over 'iget' to allow you to collect a @b@ from all+-- instances of @f@ inside a @t f a@, into a non-empty collection of @b@s.+--+-- Will work if there is an instance of @'Interpret' t ('AltConst'+-- ('NEDL.DNonEmpty' b))@, which will be the case if the constraint on the+-- target functor is 'Functor', 'Apply', 'Alt', 'Divise', 'Decide', or+-- unconstrained.+--+-- @+-- -- get the lengths of all @Map String@s in the 'Ap.Ap'.+-- 'icollect1' length+--      :: Ap1 (Map String) Bool+--      -> 'NonEmpty' Int+-- @+--+-- @since 0.3.1.0+icollect1+    :: Interpret t (AltConst (NEDL.DNonEmpty b))+    => (forall x. f x -> b)+    -> t f a+    -> NonEmpty b+icollect1 f = NEDL.toNonEmpty . iget (NEDL.singleton . f)++-- | A version of 'Const' that supports 'Alt', 'Plus', 'Decide', and+-- 'Conclude' instances.  It does this+-- by avoiding having an 'Alternative' or 'Decidable' instance, which+-- causes all sorts of problems with the interactions between+-- 'Alternative'/'Applicative' and+-- 'Decidable'/'Data.Functor.Contravariant.Divisible.Divisible'.+--+-- @since 0.3.1.0+newtype AltConst w a = AltConst { getAltConst :: w }+  deriving (Show, Eq, Ord, Generic, Functor, Foldable, Traversable, Data)++instance Show w => Show1 (AltConst w) where+    liftShowsPrec _ _ d (AltConst x) = showsUnaryWith showsPrec "AltConst" d x+instance Eq w => Eq1 (AltConst w) where+    liftEq _ (AltConst x) (AltConst y) = x == y+instance Ord w => Ord1 (AltConst w) where+    liftCompare _ (AltConst x) (AltConst y) = compare x y++instance Contravariant (AltConst w) where+    contramap _ = coerce+instance Invariant (AltConst w) where+    invmap _ _ = coerce++instance Semigroup w => Apply (AltConst w) where+    AltConst x <.> AltConst y = AltConst (x <> y)+instance Monoid w => Applicative (AltConst w) where+    (<*>) = (<.>)+    pure _ = AltConst mempty+-- | Unlike for 'Const', this is possible because there is no 'Alternative'+-- instance to complicate things.+instance Semigroup w => Alt (AltConst w) where+    AltConst x <!> AltConst y = AltConst (x <> y)+-- | Unlike for 'Const', this is possible because there is no 'Alternative'+-- instance to complicate things.+instance Monoid w => Plus (AltConst w) where+    zero = AltConst mempty++instance Semigroup w => Divise (AltConst w) where+    divise _ (AltConst x) (AltConst y) = AltConst (x <> y)+instance Monoid w => Divisible (AltConst w) where+    divide  = divise+    conquer = AltConst mempty+-- | Unlike for 'Const', this is possible because there is no 'Decidable'+-- instance to complicate things.+instance Semigroup w => Decide (AltConst w) where+    decide _ (AltConst x) (AltConst y) = AltConst (x <> y)+-- | Unlike for 'Const', this is possible because there is no 'Decidable'+-- instance to complicate things.+instance Monoid w => Conclude (AltConst w) where+    conclude _ = AltConst mempty  -- | A free 'Functor' instance Functor f => Interpret Coyoneda f where

@@ -29,6 +29,7 @@ import           Data.GADT.Show import           Data.HBifunctor.Tensor import           Data.HFunctor.Chain+import           Data.HFunctor.Interpret import           Data.Kind import           Data.Semigroup                 (Any(..)) import           Data.Semigroup.Traversable@@ -250,9 +251,6 @@  instance (Enum e, Bounded e) => TestHFunctor (EnvT e) where     genHF gx = EnvT <$> Gen.enumBounded <*> gx--class (c f, d f) => AndC c d f-instance (c f, d f) => AndC c d f  instance (TestHFunctor s, HTraversable s, TestHFunctor t) => TestHFunctor (ComposeT s t) where     type TestHFunctorBy (ComposeT s t) = AndC (TestHFunctorBy s) (TestHFunctorBy t)