-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Bifunctors.
@package bifunctors
@version 5.6.2


module Data.Biapplicative
class Bifunctor p => Biapplicative (p :: Type -> Type -> Type)
bipure :: Biapplicative p => a -> b -> p a b
(<<*>>) :: Biapplicative p => p (a -> b) (c -> d) -> p a c -> p b d

-- | Lift binary functions
biliftA2 :: Biapplicative p => (a -> b -> c) -> (d -> e -> f) -> p a d -> p b e -> p c f

-- | <pre>
--   a <a>*&gt;&gt;</a> b ≡ <a>bimap</a> (<a>const</a> <a>id</a>) (<a>const</a> <a>id</a>) <a>&lt;&lt;$&gt;&gt;</a> a <a>&lt;&lt;*&gt;&gt;</a> b
--   </pre>
(*>>) :: Biapplicative p => p a b -> p c d -> p c d

-- | <pre>
--   a <a>&lt;&lt;*</a> b ≡ <a>bimap</a> <a>const</a> <a>const</a> <a>&lt;&lt;$&gt;&gt;</a> a <a>&lt;&lt;*&gt;&gt;</a> b
--   </pre>
(<<*) :: Biapplicative p => p a b -> p c d -> p a b
infixl 4 *>>
infixl 4 <<*
infixl 4 <<*>>
(<<$>>) :: (a -> b) -> a -> b
infixl 4 <<$>>
(<<**>>) :: Biapplicative p => p a c -> p (a -> b) (c -> d) -> p b d
infixl 4 <<**>>

-- | Lift ternary functions
biliftA3 :: Biapplicative w => (a -> b -> c -> d) -> (e -> f -> g -> h) -> w a e -> w b f -> w c g -> w d h

-- | Traverse a <a>Traversable</a> container in a <a>Biapplicative</a>.
--   
--   <a>traverseBia</a> satisfies the following properties:
--   
--   <ul>
--   <li><i><i>Pairing</i></i> <pre><a>traverseBia</a> (,) t = (t,
--   t)</pre></li>
--   <li><i><i>Composition</i></i> <pre><a>traverseBia</a> (<a>Biff</a> .
--   <a>bimap</a> g h . f) = <a>Biff</a> . <a>bimap</a> (<a>traverse</a> g)
--   (<a>traverse</a> h) . <a>traverseBia</a>
--   f</pre><pre><a>traverseBia</a> (<a>Tannen</a> . <a>fmap</a> f . g) =
--   <a>Tannen</a> . <a>fmap</a> (<a>traverseBia</a> f) . <a>traverse</a>
--   g</pre></li>
--   <li><i><i>Naturality</i></i> <pre> t . <a>traverseBia</a> f =
--   <a>traverseBia</a> (t . f)</pre>for every biapplicative transformation
--   <tt>t</tt>.A <i>biapplicative transformation</i> from a
--   <a>Biapplicative</a> <tt>P</tt> to a <a>Biapplicative</a> <tt>Q</tt>
--   is a function<pre>t :: P a b -&gt; Q a b</pre>preserving the
--   <a>Biapplicative</a> operations. That is,<ul><li><pre>t (<a>bipure</a>
--   x y) = <a>bipure</a> x y</pre></li><li><pre>t (x
--   <a>&lt;&lt;*&gt;&gt;</a> y) = t x <a>&lt;&lt;*&gt;&gt;</a> t
--   y</pre></li></ul></li>
--   </ul>
--   
--   <h3>Performance note</h3>
--   
--   <a>traverseBia</a> is fairly efficient, and uses compiler rewrite
--   rules to be even more efficient for a few important types like
--   <tt>[]</tt>. However, if performance is critical, you might consider
--   writing a container-specific implementation.
traverseBia :: (Traversable t, Biapplicative p) => (a -> p b c) -> t a -> p (t b) (t c)

-- | Perform all the <a>Biapplicative</a> actions in a <a>Traversable</a>
--   container and produce a container with all the results.
--   
--   <pre>
--   sequenceBia = <a>traverseBia</a> id
--   </pre>
sequenceBia :: (Traversable t, Biapplicative p) => t (p b c) -> p (t b) (t c)

-- | A version of <a>traverseBia</a> that doesn't care how the traversal is
--   done.
--   
--   <pre>
--   <a>traverseBia</a> = traverseBiaWith traverse
--   </pre>
traverseBiaWith :: forall p a b c s t. Biapplicative p => (forall (f :: Type -> Type) x. Applicative f => (a -> f x) -> s -> f (t x)) -> (a -> p b c) -> s -> p (t b) (t c)
class forall a. () => Functor p a => Bifunctor (p :: Type -> Type -> Type)
bimap :: Bifunctor p => (a -> b) -> (c -> d) -> p a c -> p b d
first :: Bifunctor p => (a -> b) -> p a c -> p b c
second :: Bifunctor p => (b -> c) -> p a b -> p a c
instance GHC.Internal.Base.Applicative (Data.Biapplicative.Mag a b)
instance Data.Biapplicative.Biapplicative Data.Semigroup.Arg
instance Data.Biapplicative.Biapplicative GHC.Internal.Data.Functor.Const.Const
instance Data.Biapplicative.Biapplicative Data.Tagged.Tagged
instance Data.Biapplicative.Biapplicative (,)
instance GHC.Internal.Base.Monoid x => Data.Biapplicative.Biapplicative ((,,) x)
instance (GHC.Internal.Base.Monoid x, GHC.Internal.Base.Monoid y) => Data.Biapplicative.Biapplicative ((,,,) x y)
instance (GHC.Internal.Base.Monoid x, GHC.Internal.Base.Monoid y, GHC.Internal.Base.Monoid z) => Data.Biapplicative.Biapplicative ((,,,,) x y z)
instance (GHC.Internal.Base.Monoid x, GHC.Internal.Base.Monoid y, GHC.Internal.Base.Monoid z, GHC.Internal.Base.Monoid w) => Data.Biapplicative.Biapplicative ((,,,,,) x y z w)
instance (GHC.Internal.Base.Monoid x, GHC.Internal.Base.Monoid y, GHC.Internal.Base.Monoid z, GHC.Internal.Base.Monoid w, GHC.Internal.Base.Monoid v) => Data.Biapplicative.Biapplicative ((,,,,,,) x y z w v)
instance GHC.Internal.Base.Functor (Data.Biapplicative.Mag a b)


module Data.Bifunctor.Biap

-- | Pointwise lifting of a class over two arguments, using
--   <a>Biapplicative</a>.
--   
--   Classes that can be lifted include <a>Monoid</a>, <a>Num</a> and
--   <a>Bounded</a>. Each method of those classes can be defined as lifting
--   themselves over each argument of <a>Biapplicative</a>.
--   
--   <pre>
--   mempty        = bipure mempty          mempty
--   minBound      = bipure minBound        minBound
--   maxBound      = bipure maxBound        maxBound
--   fromInteger n = bipure (fromInteger n) (fromInteger n)
--   
--   negate = bimap negate negate
--   
--   (+)  = biliftA2 (+)  (+)
--   (&lt;&gt;) = biliftA2 (&lt;&gt;) (&lt;&gt;)
--   </pre>
--   
--   <a>Biap</a> is to <a>Biapplicative</a> as <a>Ap</a> is to
--   <a>Applicative</a>.
--   
--   <a>Biap</a> can be used with <tt>DerivingVia</tt> to derive a numeric
--   instance for pairs:
--   
--   <pre>
--   newtype Numpair a = Np (a, a)
--    deriving (S.Semigroup, Monoid, Num, Bounded)
--    via Biap (,) a a
--   </pre>
newtype Biap (bi :: Type -> Type -> Type) a b
Biap :: bi a b -> Biap (bi :: Type -> Type -> Type) a b
[getBiap] :: Biap (bi :: Type -> Type -> Type) a b -> bi a b
instance GHC.Internal.Base.Alternative (bi a) => GHC.Internal.Base.Alternative (Data.Bifunctor.Biap.Biap bi a)
instance GHC.Internal.Base.Applicative (bi a) => GHC.Internal.Base.Applicative (Data.Bifunctor.Biap.Biap bi a)
instance Data.Biapplicative.Biapplicative bi => Data.Biapplicative.Biapplicative (Data.Bifunctor.Biap.Biap bi)
instance Data.Bifoldable.Bifoldable bi => Data.Bifoldable.Bifoldable (Data.Bifunctor.Biap.Biap bi)
instance Data.Bifunctor.Bifunctor bi => Data.Bifunctor.Bifunctor (Data.Bifunctor.Biap.Biap bi)
instance Data.Bitraversable.Bitraversable bi => Data.Bitraversable.Bitraversable (Data.Bifunctor.Biap.Biap bi)
instance (Data.Biapplicative.Biapplicative bi, GHC.Internal.Enum.Bounded a, GHC.Internal.Enum.Bounded b) => GHC.Internal.Enum.Bounded (Data.Bifunctor.Biap.Biap bi a b)
instance GHC.Internal.Enum.Enum (bi a b) => GHC.Internal.Enum.Enum (Data.Bifunctor.Biap.Biap bi a b)
instance Data.Functor.Classes.Eq1 (bi a) => Data.Functor.Classes.Eq1 (Data.Bifunctor.Biap.Biap bi a)
instance Data.Functor.Classes.Eq2 bi => Data.Functor.Classes.Eq2 (Data.Bifunctor.Biap.Biap bi)
instance GHC.Classes.Eq (bi a b) => GHC.Classes.Eq (Data.Bifunctor.Biap.Biap bi a b)
instance GHC.Internal.Data.Foldable.Foldable (bi a) => GHC.Internal.Data.Foldable.Foldable (Data.Bifunctor.Biap.Biap bi a)
instance GHC.Internal.Base.Functor (bi a) => GHC.Internal.Base.Functor (Data.Bifunctor.Biap.Biap bi a)
instance GHC.Internal.Generics.Generic1 (Data.Bifunctor.Biap.Biap bi a)
instance GHC.Internal.Generics.Generic (Data.Bifunctor.Biap.Biap bi a b)
instance GHC.Internal.Base.Monad (bi a) => GHC.Internal.Base.Monad (Data.Bifunctor.Biap.Biap bi a)
instance GHC.Internal.Control.Monad.Fail.MonadFail (bi a) => GHC.Internal.Control.Monad.Fail.MonadFail (Data.Bifunctor.Biap.Biap bi a)
instance GHC.Internal.Base.MonadPlus (bi a) => GHC.Internal.Base.MonadPlus (Data.Bifunctor.Biap.Biap bi a)
instance (Data.Biapplicative.Biapplicative bi, GHC.Internal.Base.Monoid a, GHC.Internal.Base.Monoid b) => GHC.Internal.Base.Monoid (Data.Bifunctor.Biap.Biap bi a b)
instance (Data.Biapplicative.Biapplicative bi, GHC.Internal.Num.Num a, GHC.Internal.Num.Num b) => GHC.Internal.Num.Num (Data.Bifunctor.Biap.Biap bi a b)
instance Data.Functor.Classes.Ord1 (bi a) => Data.Functor.Classes.Ord1 (Data.Bifunctor.Biap.Biap bi a)
instance Data.Functor.Classes.Ord2 bi => Data.Functor.Classes.Ord2 (Data.Bifunctor.Biap.Biap bi)
instance GHC.Classes.Ord (bi a b) => GHC.Classes.Ord (Data.Bifunctor.Biap.Biap bi a b)
instance GHC.Internal.Read.Read (bi a b) => GHC.Internal.Read.Read (Data.Bifunctor.Biap.Biap bi a b)
instance (Data.Biapplicative.Biapplicative bi, GHC.Internal.Base.Semigroup a, GHC.Internal.Base.Semigroup b) => GHC.Internal.Base.Semigroup (Data.Bifunctor.Biap.Biap bi a b)
instance GHC.Internal.Show.Show (bi a b) => GHC.Internal.Show.Show (Data.Bifunctor.Biap.Biap bi a b)
instance GHC.Internal.Data.Traversable.Traversable (bi a) => GHC.Internal.Data.Traversable.Traversable (Data.Bifunctor.Biap.Biap bi a)


module Data.Bifunctor.Biff

-- | Compose two <a>Functor</a>s on the inside of a <a>Bifunctor</a>.
newtype Biff (p :: k -> k1 -> Type) (f :: k2 -> k) (g :: k3 -> k1) (a :: k2) (b :: k3)
Biff :: p (f a) (g b) -> Biff (p :: k -> k1 -> Type) (f :: k2 -> k) (g :: k3 -> k1) (a :: k2) (b :: k3)
[runBiff] :: Biff (p :: k -> k1 -> Type) (f :: k2 -> k) (g :: k3 -> k1) (a :: k2) (b :: k3) -> p (f a) (g b)
instance (Data.Biapplicative.Biapplicative p, GHC.Internal.Base.Applicative f, GHC.Internal.Base.Applicative g) => Data.Biapplicative.Biapplicative (Data.Bifunctor.Biff.Biff p f g)
instance (Data.Bifoldable1.Bifoldable1 p, Data.Foldable1.Foldable1 f, Data.Foldable1.Foldable1 g) => Data.Bifoldable1.Bifoldable1 (Data.Bifunctor.Biff.Biff p f g)
instance (Data.Bifoldable.Bifoldable p, GHC.Internal.Data.Foldable.Foldable f, GHC.Internal.Data.Foldable.Foldable g) => Data.Bifoldable.Bifoldable (Data.Bifunctor.Biff.Biff p f g)
instance (Data.Bifunctor.Bifunctor p, GHC.Internal.Base.Functor f, GHC.Internal.Base.Functor g) => Data.Bifunctor.Bifunctor (Data.Bifunctor.Biff.Biff p f g)
instance (Data.Bitraversable.Bitraversable p, GHC.Internal.Data.Traversable.Traversable f, GHC.Internal.Data.Traversable.Traversable g) => Data.Bitraversable.Bitraversable (Data.Bifunctor.Biff.Biff p f g)
instance (Data.Functor.Classes.Eq2 p, Data.Functor.Classes.Eq1 f, Data.Functor.Classes.Eq1 g, GHC.Classes.Eq a) => Data.Functor.Classes.Eq1 (Data.Bifunctor.Biff.Biff p f g a)
instance (Data.Functor.Classes.Eq2 p, Data.Functor.Classes.Eq1 f, Data.Functor.Classes.Eq1 g) => Data.Functor.Classes.Eq2 (Data.Bifunctor.Biff.Biff p f g)
instance forall k1 k2 (p :: k1 -> k2 -> *) k3 (f :: k3 -> k1) k4 (g :: k4 -> k2) (a :: k3) (b :: k4). GHC.Classes.Eq (p (f a) (g b)) => GHC.Classes.Eq (Data.Bifunctor.Biff.Biff p f g a b)
instance forall k (p :: * -> * -> *) (g :: * -> *) (f :: k -> *) (a :: k). (Data.Bifoldable.Bifoldable p, GHC.Internal.Data.Foldable.Foldable g) => GHC.Internal.Data.Foldable.Foldable (Data.Bifunctor.Biff.Biff p f g a)
instance forall k (p :: * -> * -> *) (g :: * -> *) (f :: k -> *) (a :: k). (Data.Bifunctor.Bifunctor p, GHC.Internal.Base.Functor g) => GHC.Internal.Base.Functor (Data.Bifunctor.Biff.Biff p f g a)
instance forall k1 k2 k3 (p :: k1 -> * -> *) (f :: k2 -> k1) (a :: k2) (g :: k3 -> *). GHC.Internal.Base.Functor (p (f a)) => GHC.Internal.Generics.Generic1 (Data.Bifunctor.Biff.Biff p f g a)
instance forall k1 k2 (p :: k1 -> k2 -> *) k3 (f :: k3 -> k1) k4 (g :: k4 -> k2) (a :: k3) (b :: k4). GHC.Internal.Generics.Generic (Data.Bifunctor.Biff.Biff p f g a b)
instance (Data.Functor.Classes.Ord2 p, Data.Functor.Classes.Ord1 f, Data.Functor.Classes.Ord1 g, GHC.Classes.Ord a) => Data.Functor.Classes.Ord1 (Data.Bifunctor.Biff.Biff p f g a)
instance (Data.Functor.Classes.Ord2 p, Data.Functor.Classes.Ord1 f, Data.Functor.Classes.Ord1 g) => Data.Functor.Classes.Ord2 (Data.Bifunctor.Biff.Biff p f g)
instance forall k1 k2 (p :: k1 -> k2 -> *) k3 (f :: k3 -> k1) k4 (g :: k4 -> k2) (a :: k3) (b :: k4). GHC.Classes.Ord (p (f a) (g b)) => GHC.Classes.Ord (Data.Bifunctor.Biff.Biff p f g a b)
instance (Data.Functor.Classes.Read2 p, Data.Functor.Classes.Read1 f, Data.Functor.Classes.Read1 g, GHC.Internal.Read.Read a) => Data.Functor.Classes.Read1 (Data.Bifunctor.Biff.Biff p f g a)
instance (Data.Functor.Classes.Read2 p, Data.Functor.Classes.Read1 f, Data.Functor.Classes.Read1 g) => Data.Functor.Classes.Read2 (Data.Bifunctor.Biff.Biff p f g)
instance forall k1 k2 (p :: k1 -> k2 -> *) k3 (f :: k3 -> k1) k4 (g :: k4 -> k2) (a :: k3) (b :: k4). GHC.Internal.Read.Read (p (f a) (g b)) => GHC.Internal.Read.Read (Data.Bifunctor.Biff.Biff p f g a b)
instance (Data.Functor.Classes.Show2 p, Data.Functor.Classes.Show1 f, Data.Functor.Classes.Show1 g, GHC.Internal.Show.Show a) => Data.Functor.Classes.Show1 (Data.Bifunctor.Biff.Biff p f g a)
instance (Data.Functor.Classes.Show2 p, Data.Functor.Classes.Show1 f, Data.Functor.Classes.Show1 g) => Data.Functor.Classes.Show2 (Data.Bifunctor.Biff.Biff p f g)
instance forall k1 k2 (p :: k1 -> k2 -> *) k3 (f :: k3 -> k1) k4 (g :: k4 -> k2) (a :: k3) (b :: k4). GHC.Internal.Show.Show (p (f a) (g b)) => GHC.Internal.Show.Show (Data.Bifunctor.Biff.Biff p f g a b)
instance (f GHC.Types.~ g, GHC.Internal.Base.Functor f, Data.Bifunctor.Swap.Swap p) => Data.Bifunctor.Swap.Swap (Data.Bifunctor.Biff.Biff p f g)
instance forall k (p :: * -> * -> *) (g :: * -> *) (f :: k -> *) (a :: k). (Data.Bitraversable.Bitraversable p, GHC.Internal.Data.Traversable.Traversable g) => GHC.Internal.Data.Traversable.Traversable (Data.Bifunctor.Biff.Biff p f g a)


-- | From the Functional Pearl "Clowns to the Left of me, Jokers to the
--   Right: Dissecting Data Structures" by Conor McBride.
module Data.Bifunctor.Clown

-- | Make a <a>Functor</a> over the first argument of a <a>Bifunctor</a>.
--   
--   Mnemonic: C<b>l</b>owns to the <b>l</b>eft (parameter of the
--   Bifunctor), joke<b>r</b>s to the <b>r</b>ight.
newtype Clown (f :: k -> Type) (a :: k) (b :: k1)
Clown :: f a -> Clown (f :: k -> Type) (a :: k) (b :: k1)
[runClown] :: Clown (f :: k -> Type) (a :: k) (b :: k1) -> f a
instance GHC.Internal.Base.Applicative f => Data.Biapplicative.Biapplicative (Data.Bifunctor.Clown.Clown f)
instance Data.Foldable1.Foldable1 f => Data.Bifoldable1.Bifoldable1 (Data.Bifunctor.Clown.Clown f)
instance GHC.Internal.Data.Foldable.Foldable f => Data.Bifoldable.Bifoldable (Data.Bifunctor.Clown.Clown f)
instance GHC.Internal.Base.Functor f => Data.Bifunctor.Bifunctor (Data.Bifunctor.Clown.Clown f)
instance GHC.Internal.Data.Traversable.Traversable f => Data.Bitraversable.Bitraversable (Data.Bifunctor.Clown.Clown f)
instance (Data.Functor.Classes.Eq1 f, GHC.Classes.Eq a) => Data.Functor.Classes.Eq1 (Data.Bifunctor.Clown.Clown f a)
instance Data.Functor.Classes.Eq1 f => Data.Functor.Classes.Eq2 (Data.Bifunctor.Clown.Clown f)
instance forall k1 (f :: k1 -> *) (a :: k1) k2 (b :: k2). GHC.Classes.Eq (f a) => GHC.Classes.Eq (Data.Bifunctor.Clown.Clown f a b)
instance forall k (f :: k -> *) (a :: k). GHC.Internal.Data.Foldable.Foldable (Data.Bifunctor.Clown.Clown f a)
instance forall k (f :: k -> *) (a :: k). GHC.Internal.Base.Functor (Data.Bifunctor.Clown.Clown f a)
instance forall k1 k2 (f :: k2 -> *) (a :: k2). GHC.Internal.Generics.Generic1 (Data.Bifunctor.Clown.Clown f a)
instance forall k1 (f :: k1 -> *) (a :: k1) k2 (b :: k2). GHC.Internal.Generics.Generic (Data.Bifunctor.Clown.Clown f a b)
instance (Data.Functor.Classes.Ord1 f, GHC.Classes.Ord a) => Data.Functor.Classes.Ord1 (Data.Bifunctor.Clown.Clown f a)
instance Data.Functor.Classes.Ord1 f => Data.Functor.Classes.Ord2 (Data.Bifunctor.Clown.Clown f)
instance forall k1 (f :: k1 -> *) (a :: k1) k2 (b :: k2). GHC.Classes.Ord (f a) => GHC.Classes.Ord (Data.Bifunctor.Clown.Clown f a b)
instance (Data.Functor.Classes.Read1 f, GHC.Internal.Read.Read a) => Data.Functor.Classes.Read1 (Data.Bifunctor.Clown.Clown f a)
instance Data.Functor.Classes.Read1 f => Data.Functor.Classes.Read2 (Data.Bifunctor.Clown.Clown f)
instance forall k1 (f :: k1 -> *) (a :: k1) k2 (b :: k2). GHC.Internal.Read.Read (f a) => GHC.Internal.Read.Read (Data.Bifunctor.Clown.Clown f a b)
instance (Data.Functor.Classes.Show1 f, GHC.Internal.Show.Show a) => Data.Functor.Classes.Show1 (Data.Bifunctor.Clown.Clown f a)
instance Data.Functor.Classes.Show1 f => Data.Functor.Classes.Show2 (Data.Bifunctor.Clown.Clown f)
instance forall k1 (f :: k1 -> *) (a :: k1) k2 (b :: k2). GHC.Internal.Show.Show (f a) => GHC.Internal.Show.Show (Data.Bifunctor.Clown.Clown f a b)
instance forall k (f :: k -> *) (a :: k). GHC.Internal.Data.Traversable.Traversable (Data.Bifunctor.Clown.Clown f a)


module Data.Bifunctor.Fix

-- | Greatest fixpoint of a <a>Bifunctor</a> (a <a>Functor</a> over the
--   first argument with zipping).
newtype Fix (p :: Type -> k -> Type) (a :: k)
In :: p (Fix p a) a -> Fix (p :: Type -> k -> Type) (a :: k)
[out] :: Fix (p :: Type -> k -> Type) (a :: k) -> p (Fix p a) a
instance Data.Biapplicative.Biapplicative p => GHC.Internal.Base.Applicative (Data.Bifunctor.Fix.Fix p)
instance Data.Functor.Classes.Eq2 p => Data.Functor.Classes.Eq1 (Data.Bifunctor.Fix.Fix p)
instance forall k (p :: * -> k -> *) (a :: k). GHC.Classes.Eq (p (Data.Bifunctor.Fix.Fix p a) a) => GHC.Classes.Eq (Data.Bifunctor.Fix.Fix p a)
instance Data.Bifoldable.Bifoldable p => GHC.Internal.Data.Foldable.Foldable (Data.Bifunctor.Fix.Fix p)
instance Data.Bifunctor.Bifunctor p => GHC.Internal.Base.Functor (Data.Bifunctor.Fix.Fix p)
instance forall k (p :: * -> k -> *) (a :: k). GHC.Internal.Generics.Generic (Data.Bifunctor.Fix.Fix p a)
instance Data.Functor.Classes.Ord2 p => Data.Functor.Classes.Ord1 (Data.Bifunctor.Fix.Fix p)
instance forall k (p :: * -> k -> *) (a :: k). GHC.Classes.Ord (p (Data.Bifunctor.Fix.Fix p a) a) => GHC.Classes.Ord (Data.Bifunctor.Fix.Fix p a)
instance Data.Functor.Classes.Read2 p => Data.Functor.Classes.Read1 (Data.Bifunctor.Fix.Fix p)
instance forall k (p :: * -> k -> *) (a :: k). GHC.Internal.Read.Read (p (Data.Bifunctor.Fix.Fix p a) a) => GHC.Internal.Read.Read (Data.Bifunctor.Fix.Fix p a)
instance Data.Functor.Classes.Show2 p => Data.Functor.Classes.Show1 (Data.Bifunctor.Fix.Fix p)
instance forall k (p :: * -> k -> *) (a :: k). GHC.Internal.Show.Show (p (Data.Bifunctor.Fix.Fix p a) a) => GHC.Internal.Show.Show (Data.Bifunctor.Fix.Fix p a)
instance Data.Bitraversable.Bitraversable p => GHC.Internal.Data.Traversable.Traversable (Data.Bifunctor.Fix.Fix p)

module Data.Bifunctor.Functor

-- | Using parametricity as an approximation of a natural transformation in
--   two arguments.
type (p :: k -> k1 -> Type) :-> (q :: k -> k1 -> Type) = forall (a :: k) (b :: k1). () => p a b -> q a b
infixr 0 :->
class BifunctorFunctor (t :: k -> k1 -> Type -> k2 -> k3 -> Type)
bifmap :: forall (p :: k -> k1 -> Type) (q :: k -> k1 -> Type). BifunctorFunctor t => (p :-> q) -> t p :-> t q
class BifunctorFunctor t => BifunctorMonad (t :: k -> k1 -> Type -> k -> k1 -> Type)
bireturn :: forall (p :: k -> k1 -> Type). BifunctorMonad t => p :-> t p
bibind :: forall (p :: k -> k1 -> Type) (q :: k -> k1 -> Type). BifunctorMonad t => (p :-> t q) -> t p :-> t q
bijoin :: forall (p :: k -> k1 -> Type). BifunctorMonad t => t (t p) :-> t p
biliftM :: forall {k1} {k2} (t :: (k1 -> k2 -> Type) -> k1 -> k2 -> Type) (p :: k1 -> k2 -> Type) (q :: k1 -> k2 -> Type). BifunctorMonad t => (p :-> q) -> t p :-> t q
class BifunctorFunctor t => BifunctorComonad (t :: k -> k1 -> Type -> k -> k1 -> Type)
biextract :: forall (p :: k -> k1 -> Type). BifunctorComonad t => t p :-> p
biextend :: forall (p :: k -> k1 -> Type) (q :: k -> k1 -> Type). BifunctorComonad t => (t p :-> q) -> t p :-> t q
biduplicate :: forall (p :: k -> k1 -> Type). BifunctorComonad t => t p :-> t (t p)
biliftW :: forall {k1} {k2} (t :: (k1 -> k2 -> Type) -> k1 -> k2 -> Type) (p :: k1 -> k2 -> Type) (q :: k1 -> k2 -> Type). BifunctorComonad t => (p :-> q) -> t p :-> t q


module Data.Bifunctor.Flip

-- | Make a <a>Bifunctor</a> flipping the arguments of a <a>Bifunctor</a>.
newtype Flip (p :: k -> k1 -> Type) (a :: k1) (b :: k)
Flip :: p b a -> Flip (p :: k -> k1 -> Type) (a :: k1) (b :: k)
[runFlip] :: Flip (p :: k -> k1 -> Type) (a :: k1) (b :: k) -> p b a
instance Data.Bifunctor.Assoc.Assoc p => Data.Bifunctor.Assoc.Assoc (Data.Bifunctor.Flip.Flip p)
instance Data.Biapplicative.Biapplicative p => Data.Biapplicative.Biapplicative (Data.Bifunctor.Flip.Flip p)
instance Data.Bifoldable1.Bifoldable1 p => Data.Bifoldable1.Bifoldable1 (Data.Bifunctor.Flip.Flip p)
instance Data.Bifoldable.Bifoldable p => Data.Bifoldable.Bifoldable (Data.Bifunctor.Flip.Flip p)
instance Data.Bifunctor.Bifunctor p => Data.Bifunctor.Bifunctor (Data.Bifunctor.Flip.Flip p)
instance Data.Bifunctor.Functor.BifunctorFunctor Data.Bifunctor.Flip.Flip
instance Data.Bitraversable.Bitraversable p => Data.Bitraversable.Bitraversable (Data.Bifunctor.Flip.Flip p)
instance (Data.Functor.Classes.Eq2 p, GHC.Classes.Eq a) => Data.Functor.Classes.Eq1 (Data.Bifunctor.Flip.Flip p a)
instance Data.Functor.Classes.Eq2 p => Data.Functor.Classes.Eq2 (Data.Bifunctor.Flip.Flip p)
instance forall k1 k2 (p :: k2 -> k1 -> *) (a :: k1) (b :: k2). GHC.Classes.Eq (p b a) => GHC.Classes.Eq (Data.Bifunctor.Flip.Flip p a b)
instance Data.Bifoldable.Bifoldable p => GHC.Internal.Data.Foldable.Foldable (Data.Bifunctor.Flip.Flip p a)
instance Data.Bifunctor.Bifunctor p => GHC.Internal.Base.Functor (Data.Bifunctor.Flip.Flip p a)
instance forall k1 k2 (p :: k2 -> k1 -> *) (a :: k1) (b :: k2). GHC.Internal.Generics.Generic (Data.Bifunctor.Flip.Flip p a b)
instance (Data.Functor.Classes.Ord2 p, GHC.Classes.Ord a) => Data.Functor.Classes.Ord1 (Data.Bifunctor.Flip.Flip p a)
instance Data.Functor.Classes.Ord2 p => Data.Functor.Classes.Ord2 (Data.Bifunctor.Flip.Flip p)
instance forall k1 k2 (p :: k2 -> k1 -> *) (a :: k1) (b :: k2). GHC.Classes.Ord (p b a) => GHC.Classes.Ord (Data.Bifunctor.Flip.Flip p a b)
instance (Data.Functor.Classes.Read2 p, GHC.Internal.Read.Read a) => Data.Functor.Classes.Read1 (Data.Bifunctor.Flip.Flip p a)
instance Data.Functor.Classes.Read2 p => Data.Functor.Classes.Read2 (Data.Bifunctor.Flip.Flip p)
instance forall k1 k2 (p :: k2 -> k1 -> *) (a :: k1) (b :: k2). GHC.Internal.Read.Read (p b a) => GHC.Internal.Read.Read (Data.Bifunctor.Flip.Flip p a b)
instance (Data.Functor.Classes.Show2 p, GHC.Internal.Show.Show a) => Data.Functor.Classes.Show1 (Data.Bifunctor.Flip.Flip p a)
instance Data.Functor.Classes.Show2 p => Data.Functor.Classes.Show2 (Data.Bifunctor.Flip.Flip p)
instance forall k1 k2 (p :: k2 -> k1 -> *) (a :: k1) (b :: k2). GHC.Internal.Show.Show (p b a) => GHC.Internal.Show.Show (Data.Bifunctor.Flip.Flip p a b)
instance Data.Bifunctor.Swap.Swap p => Data.Bifunctor.Swap.Swap (Data.Bifunctor.Flip.Flip p)
instance Data.Bitraversable.Bitraversable p => GHC.Internal.Data.Traversable.Traversable (Data.Bifunctor.Flip.Flip p a)


module Data.Bifunctor.Join

-- | Make a <a>Functor</a> over both arguments of a <a>Bifunctor</a>.
newtype Join (p :: k -> k -> Type) (a :: k)
Join :: p a a -> Join (p :: k -> k -> Type) (a :: k)
[runJoin] :: Join (p :: k -> k -> Type) (a :: k) -> p a a
instance Data.Biapplicative.Biapplicative p => GHC.Internal.Base.Applicative (Data.Bifunctor.Join.Join p)
instance Data.Functor.Classes.Eq2 p => Data.Functor.Classes.Eq1 (Data.Bifunctor.Join.Join p)
instance forall k (p :: k -> k -> *) (a :: k). GHC.Classes.Eq (p a a) => GHC.Classes.Eq (Data.Bifunctor.Join.Join p a)
instance Data.Bifoldable1.Bifoldable1 p => Data.Foldable1.Foldable1 (Data.Bifunctor.Join.Join p)
instance Data.Bifoldable.Bifoldable p => GHC.Internal.Data.Foldable.Foldable (Data.Bifunctor.Join.Join p)
instance Data.Bifunctor.Bifunctor p => GHC.Internal.Base.Functor (Data.Bifunctor.Join.Join p)
instance forall k (p :: k -> k -> *) (a :: k). GHC.Internal.Generics.Generic (Data.Bifunctor.Join.Join p a)
instance Data.Functor.Classes.Ord2 p => Data.Functor.Classes.Ord1 (Data.Bifunctor.Join.Join p)
instance forall k (p :: k -> k -> *) (a :: k). GHC.Classes.Ord (p a a) => GHC.Classes.Ord (Data.Bifunctor.Join.Join p a)
instance Data.Functor.Classes.Read2 p => Data.Functor.Classes.Read1 (Data.Bifunctor.Join.Join p)
instance forall k (p :: k -> k -> *) (a :: k). GHC.Internal.Read.Read (p a a) => GHC.Internal.Read.Read (Data.Bifunctor.Join.Join p a)
instance Data.Functor.Classes.Show2 p => Data.Functor.Classes.Show1 (Data.Bifunctor.Join.Join p)
instance forall k (p :: k -> k -> *) (a :: k). GHC.Internal.Show.Show (p a a) => GHC.Internal.Show.Show (Data.Bifunctor.Join.Join p a)
instance Data.Bitraversable.Bitraversable p => GHC.Internal.Data.Traversable.Traversable (Data.Bifunctor.Join.Join p)


-- | From the Functional Pearl "Clowns to the Left of me, Jokers to the
--   Right: Dissecting Data Structures" by Conor McBride.
module Data.Bifunctor.Joker

-- | Make a <a>Functor</a> over the second argument of a <a>Bifunctor</a>.
--   
--   Mnemonic: C<b>l</b>owns to the <b>l</b>eft (parameter of the
--   Bifunctor), joke<b>r</b>s to the <b>r</b>ight.
newtype Joker (g :: k -> Type) (a :: k1) (b :: k)
Joker :: g b -> Joker (g :: k -> Type) (a :: k1) (b :: k)
[runJoker] :: Joker (g :: k -> Type) (a :: k1) (b :: k) -> g b
instance GHC.Internal.Base.Applicative g => Data.Biapplicative.Biapplicative (Data.Bifunctor.Joker.Joker g)
instance Data.Foldable1.Foldable1 g => Data.Bifoldable1.Bifoldable1 (Data.Bifunctor.Joker.Joker g)
instance GHC.Internal.Data.Foldable.Foldable g => Data.Bifoldable.Bifoldable (Data.Bifunctor.Joker.Joker g)
instance GHC.Internal.Base.Functor g => Data.Bifunctor.Bifunctor (Data.Bifunctor.Joker.Joker g)
instance GHC.Internal.Data.Traversable.Traversable g => Data.Bitraversable.Bitraversable (Data.Bifunctor.Joker.Joker g)
instance forall k (g :: * -> *) (a :: k). Data.Functor.Classes.Eq1 g => Data.Functor.Classes.Eq1 (Data.Bifunctor.Joker.Joker g a)
instance Data.Functor.Classes.Eq1 g => Data.Functor.Classes.Eq2 (Data.Bifunctor.Joker.Joker g)
instance forall k1 (g :: k1 -> *) k2 (a :: k2) (b :: k1). GHC.Classes.Eq (g b) => GHC.Classes.Eq (Data.Bifunctor.Joker.Joker g a b)
instance forall k (g :: * -> *) (a :: k). Data.Foldable1.Foldable1 g => Data.Foldable1.Foldable1 (Data.Bifunctor.Joker.Joker g a)
instance forall k (g :: * -> *) (a :: k). GHC.Internal.Data.Foldable.Foldable g => GHC.Internal.Data.Foldable.Foldable (Data.Bifunctor.Joker.Joker g a)
instance forall k (g :: * -> *) (a :: k). GHC.Internal.Base.Functor g => GHC.Internal.Base.Functor (Data.Bifunctor.Joker.Joker g a)
instance forall k1 (g :: k1 -> *) k2 (a :: k2). GHC.Internal.Generics.Generic1 (Data.Bifunctor.Joker.Joker g a)
instance forall k1 (g :: k1 -> *) k2 (a :: k2) (b :: k1). GHC.Internal.Generics.Generic (Data.Bifunctor.Joker.Joker g a b)
instance forall k (g :: * -> *) (a :: k). Data.Functor.Classes.Ord1 g => Data.Functor.Classes.Ord1 (Data.Bifunctor.Joker.Joker g a)
instance Data.Functor.Classes.Ord1 g => Data.Functor.Classes.Ord2 (Data.Bifunctor.Joker.Joker g)
instance forall k1 (g :: k1 -> *) k2 (a :: k2) (b :: k1). GHC.Classes.Ord (g b) => GHC.Classes.Ord (Data.Bifunctor.Joker.Joker g a b)
instance forall k (g :: * -> *) (a :: k). Data.Functor.Classes.Read1 g => Data.Functor.Classes.Read1 (Data.Bifunctor.Joker.Joker g a)
instance Data.Functor.Classes.Read1 g => Data.Functor.Classes.Read2 (Data.Bifunctor.Joker.Joker g)
instance forall k1 (g :: k1 -> *) k2 (a :: k2) (b :: k1). GHC.Internal.Read.Read (g b) => GHC.Internal.Read.Read (Data.Bifunctor.Joker.Joker g a b)
instance forall k (g :: * -> *) (a :: k). Data.Functor.Classes.Show1 g => Data.Functor.Classes.Show1 (Data.Bifunctor.Joker.Joker g a)
instance Data.Functor.Classes.Show1 g => Data.Functor.Classes.Show2 (Data.Bifunctor.Joker.Joker g)
instance forall k1 (g :: k1 -> *) k2 (a :: k2) (b :: k1). GHC.Internal.Show.Show (g b) => GHC.Internal.Show.Show (Data.Bifunctor.Joker.Joker g a b)
instance forall k (g :: * -> *) (a :: k). GHC.Internal.Data.Traversable.Traversable g => GHC.Internal.Data.Traversable.Traversable (Data.Bifunctor.Joker.Joker g a)


-- | The product of two bifunctors.
module Data.Bifunctor.Product

-- | Form the product of two bifunctors
data Product (f :: k -> k1 -> Type) (g :: k -> k1 -> Type) (a :: k) (b :: k1)
Pair :: f a b -> g a b -> Product (f :: k -> k1 -> Type) (g :: k -> k1 -> Type) (a :: k) (b :: k1)
instance (GHC.Internal.Control.Arrow.ArrowChoice p, GHC.Internal.Control.Arrow.ArrowChoice q) => GHC.Internal.Control.Arrow.ArrowChoice (Data.Bifunctor.Product.Product p q)
instance (GHC.Internal.Control.Arrow.ArrowLoop p, GHC.Internal.Control.Arrow.ArrowLoop q) => GHC.Internal.Control.Arrow.ArrowLoop (Data.Bifunctor.Product.Product p q)
instance (GHC.Internal.Control.Arrow.ArrowPlus p, GHC.Internal.Control.Arrow.ArrowPlus q) => GHC.Internal.Control.Arrow.ArrowPlus (Data.Bifunctor.Product.Product p q)
instance (GHC.Internal.Control.Arrow.Arrow p, GHC.Internal.Control.Arrow.Arrow q) => GHC.Internal.Control.Arrow.Arrow (Data.Bifunctor.Product.Product p q)
instance (GHC.Internal.Control.Arrow.ArrowZero p, GHC.Internal.Control.Arrow.ArrowZero q) => GHC.Internal.Control.Arrow.ArrowZero (Data.Bifunctor.Product.Product p q)
instance (Data.Biapplicative.Biapplicative f, Data.Biapplicative.Biapplicative g) => Data.Biapplicative.Biapplicative (Data.Bifunctor.Product.Product f g)
instance (Data.Bifoldable1.Bifoldable1 f, Data.Bifoldable1.Bifoldable1 g) => Data.Bifoldable1.Bifoldable1 (Data.Bifunctor.Product.Product f g)
instance (Data.Bifoldable.Bifoldable f, Data.Bifoldable.Bifoldable g) => Data.Bifoldable.Bifoldable (Data.Bifunctor.Product.Product f g)
instance forall k k1 (p :: k -> k1 -> *). Data.Bifunctor.Functor.BifunctorComonad (Data.Bifunctor.Product.Product p)
instance forall k2 k3 (p :: k2 -> k3 -> *). Data.Bifunctor.Functor.BifunctorFunctor (Data.Bifunctor.Product.Product p)
instance (Data.Bifunctor.Bifunctor f, Data.Bifunctor.Bifunctor g) => Data.Bifunctor.Bifunctor (Data.Bifunctor.Product.Product f g)
instance (Data.Bitraversable.Bitraversable f, Data.Bitraversable.Bitraversable g) => Data.Bitraversable.Bitraversable (Data.Bifunctor.Product.Product f g)
instance forall k (p :: k -> k -> *) (q :: k -> k -> *). (GHC.Internal.Control.Category.Category p, GHC.Internal.Control.Category.Category q) => GHC.Internal.Control.Category.Category (Data.Bifunctor.Product.Product p q)
instance (Data.Functor.Classes.Eq2 f, Data.Functor.Classes.Eq2 g, GHC.Classes.Eq a) => Data.Functor.Classes.Eq1 (Data.Bifunctor.Product.Product f g a)
instance (Data.Functor.Classes.Eq2 f, Data.Functor.Classes.Eq2 g) => Data.Functor.Classes.Eq2 (Data.Bifunctor.Product.Product f g)
instance forall k1 k2 (f :: k1 -> k2 -> *) (g :: k1 -> k2 -> *) (a :: k1) (b :: k2). (GHC.Classes.Eq (f a b), GHC.Classes.Eq (g a b)) => GHC.Classes.Eq (Data.Bifunctor.Product.Product f g a b)
instance forall k (f :: k -> * -> *) (a :: k) (g :: k -> * -> *). (GHC.Internal.Data.Foldable.Foldable (f a), GHC.Internal.Data.Foldable.Foldable (g a)) => GHC.Internal.Data.Foldable.Foldable (Data.Bifunctor.Product.Product f g a)
instance forall k (f :: k -> * -> *) (a :: k) (g :: k -> * -> *). (GHC.Internal.Base.Functor (f a), GHC.Internal.Base.Functor (g a)) => GHC.Internal.Base.Functor (Data.Bifunctor.Product.Product f g a)
instance forall k1 k2 (f :: k2 -> k1 -> *) (g :: k2 -> k1 -> *) (a :: k2). GHC.Internal.Generics.Generic1 (Data.Bifunctor.Product.Product f g a)
instance forall k1 k2 (f :: k1 -> k2 -> *) (g :: k1 -> k2 -> *) (a :: k1) (b :: k2). GHC.Internal.Generics.Generic (Data.Bifunctor.Product.Product f g a b)
instance (Data.Functor.Classes.Ord2 f, Data.Functor.Classes.Ord2 g, GHC.Classes.Ord a) => Data.Functor.Classes.Ord1 (Data.Bifunctor.Product.Product f g a)
instance (Data.Functor.Classes.Ord2 f, Data.Functor.Classes.Ord2 g) => Data.Functor.Classes.Ord2 (Data.Bifunctor.Product.Product f g)
instance forall k1 k2 (f :: k1 -> k2 -> *) (g :: k1 -> k2 -> *) (a :: k1) (b :: k2). (GHC.Classes.Ord (f a b), GHC.Classes.Ord (g a b)) => GHC.Classes.Ord (Data.Bifunctor.Product.Product f g a b)
instance (Data.Functor.Classes.Read2 f, Data.Functor.Classes.Read2 g, GHC.Internal.Read.Read a) => Data.Functor.Classes.Read1 (Data.Bifunctor.Product.Product f g a)
instance (Data.Functor.Classes.Read2 f, Data.Functor.Classes.Read2 g) => Data.Functor.Classes.Read2 (Data.Bifunctor.Product.Product f g)
instance forall k1 k2 (f :: k1 -> k2 -> *) (g :: k1 -> k2 -> *) (a :: k1) (b :: k2). (GHC.Internal.Read.Read (f a b), GHC.Internal.Read.Read (g a b)) => GHC.Internal.Read.Read (Data.Bifunctor.Product.Product f g a b)
instance (Data.Functor.Classes.Show2 f, Data.Functor.Classes.Show2 g, GHC.Internal.Show.Show a) => Data.Functor.Classes.Show1 (Data.Bifunctor.Product.Product f g a)
instance (Data.Functor.Classes.Show2 f, Data.Functor.Classes.Show2 g) => Data.Functor.Classes.Show2 (Data.Bifunctor.Product.Product f g)
instance forall k1 k2 (f :: k1 -> k2 -> *) (g :: k1 -> k2 -> *) (a :: k1) (b :: k2). (GHC.Internal.Show.Show (f a b), GHC.Internal.Show.Show (g a b)) => GHC.Internal.Show.Show (Data.Bifunctor.Product.Product f g a b)
instance (Data.Bifunctor.Swap.Swap p, Data.Bifunctor.Swap.Swap q) => Data.Bifunctor.Swap.Swap (Data.Bifunctor.Product.Product p q)
instance forall k (f :: k -> * -> *) (a :: k) (g :: k -> * -> *). (GHC.Internal.Data.Traversable.Traversable (f a), GHC.Internal.Data.Traversable.Traversable (g a)) => GHC.Internal.Data.Traversable.Traversable (Data.Bifunctor.Product.Product f g a)

module Data.Bifunctor.Sum
data Sum (p :: k -> k1 -> Type) (q :: k -> k1 -> Type) (a :: k) (b :: k1)
L2 :: p a b -> Sum (p :: k -> k1 -> Type) (q :: k -> k1 -> Type) (a :: k) (b :: k1)
R2 :: q a b -> Sum (p :: k -> k1 -> Type) (q :: k -> k1 -> Type) (a :: k) (b :: k1)
instance (Data.Bifoldable.Bifoldable p, Data.Bifoldable.Bifoldable q) => Data.Bifoldable.Bifoldable (Data.Bifunctor.Sum.Sum p q)
instance forall k2 k3 (p :: k2 -> k3 -> *). Data.Bifunctor.Functor.BifunctorFunctor (Data.Bifunctor.Sum.Sum p)
instance forall k k1 (p :: k -> k1 -> *). Data.Bifunctor.Functor.BifunctorMonad (Data.Bifunctor.Sum.Sum p)
instance (Data.Bifunctor.Bifunctor p, Data.Bifunctor.Bifunctor q) => Data.Bifunctor.Bifunctor (Data.Bifunctor.Sum.Sum p q)
instance (Data.Bitraversable.Bitraversable p, Data.Bitraversable.Bitraversable q) => Data.Bitraversable.Bitraversable (Data.Bifunctor.Sum.Sum p q)
instance (Data.Functor.Classes.Eq2 f, Data.Functor.Classes.Eq2 g, GHC.Classes.Eq a) => Data.Functor.Classes.Eq1 (Data.Bifunctor.Sum.Sum f g a)
instance (Data.Functor.Classes.Eq2 f, Data.Functor.Classes.Eq2 g) => Data.Functor.Classes.Eq2 (Data.Bifunctor.Sum.Sum f g)
instance forall k1 k2 (p :: k1 -> k2 -> *) (q :: k1 -> k2 -> *) (a :: k1) (b :: k2). (GHC.Classes.Eq (p a b), GHC.Classes.Eq (q a b)) => GHC.Classes.Eq (Data.Bifunctor.Sum.Sum p q a b)
instance forall k (f :: k -> * -> *) (a :: k) (g :: k -> * -> *). (GHC.Internal.Data.Foldable.Foldable (f a), GHC.Internal.Data.Foldable.Foldable (g a)) => GHC.Internal.Data.Foldable.Foldable (Data.Bifunctor.Sum.Sum f g a)
instance forall k (f :: k -> * -> *) (a :: k) (g :: k -> * -> *). (GHC.Internal.Base.Functor (f a), GHC.Internal.Base.Functor (g a)) => GHC.Internal.Base.Functor (Data.Bifunctor.Sum.Sum f g a)
instance forall k1 k2 (p :: k2 -> k1 -> *) (q :: k2 -> k1 -> *) (a :: k2). GHC.Internal.Generics.Generic1 (Data.Bifunctor.Sum.Sum p q a)
instance forall k1 k2 (p :: k1 -> k2 -> *) (q :: k1 -> k2 -> *) (a :: k1) (b :: k2). GHC.Internal.Generics.Generic (Data.Bifunctor.Sum.Sum p q a b)
instance (Data.Functor.Classes.Ord2 f, Data.Functor.Classes.Ord2 g, GHC.Classes.Ord a) => Data.Functor.Classes.Ord1 (Data.Bifunctor.Sum.Sum f g a)
instance (Data.Functor.Classes.Ord2 f, Data.Functor.Classes.Ord2 g) => Data.Functor.Classes.Ord2 (Data.Bifunctor.Sum.Sum f g)
instance forall k1 k2 (p :: k1 -> k2 -> *) (q :: k1 -> k2 -> *) (a :: k1) (b :: k2). (GHC.Classes.Ord (p a b), GHC.Classes.Ord (q a b)) => GHC.Classes.Ord (Data.Bifunctor.Sum.Sum p q a b)
instance (Data.Functor.Classes.Read2 f, Data.Functor.Classes.Read2 g, GHC.Internal.Read.Read a) => Data.Functor.Classes.Read1 (Data.Bifunctor.Sum.Sum f g a)
instance (Data.Functor.Classes.Read2 f, Data.Functor.Classes.Read2 g) => Data.Functor.Classes.Read2 (Data.Bifunctor.Sum.Sum f g)
instance forall k1 k2 (p :: k1 -> k2 -> *) (q :: k1 -> k2 -> *) (a :: k1) (b :: k2). (GHC.Internal.Read.Read (p a b), GHC.Internal.Read.Read (q a b)) => GHC.Internal.Read.Read (Data.Bifunctor.Sum.Sum p q a b)
instance (Data.Functor.Classes.Show2 f, Data.Functor.Classes.Show2 g, GHC.Internal.Show.Show a) => Data.Functor.Classes.Show1 (Data.Bifunctor.Sum.Sum f g a)
instance (Data.Functor.Classes.Show2 f, Data.Functor.Classes.Show2 g) => Data.Functor.Classes.Show2 (Data.Bifunctor.Sum.Sum f g)
instance forall k1 k2 (p :: k1 -> k2 -> *) (q :: k1 -> k2 -> *) (a :: k1) (b :: k2). (GHC.Internal.Show.Show (p a b), GHC.Internal.Show.Show (q a b)) => GHC.Internal.Show.Show (Data.Bifunctor.Sum.Sum p q a b)
instance (Data.Bifunctor.Swap.Swap p, Data.Bifunctor.Swap.Swap q) => Data.Bifunctor.Swap.Swap (Data.Bifunctor.Sum.Sum p q)
instance forall k (f :: k -> * -> *) (a :: k) (g :: k -> * -> *). (GHC.Internal.Data.Traversable.Traversable (f a), GHC.Internal.Data.Traversable.Traversable (g a)) => GHC.Internal.Data.Traversable.Traversable (Data.Bifunctor.Sum.Sum f g a)


-- | Functions to mechanically derive <a>Bifunctor</a>, <a>Bifoldable</a>,
--   or <a>Bitraversable</a> instances, or to splice their functions
--   directly into source code. You need to enable the
--   <tt>TemplateHaskell</tt> language extension in order to use this
--   module.
module Data.Bifunctor.TH

-- | Generates a <a>Bifunctor</a> instance declaration for the given data
--   type or data family instance.
deriveBifunctor :: Name -> Q [Dec]

-- | Like <a>deriveBifunctor</a>, but takes an <a>Options</a> argument.
deriveBifunctorOptions :: Options -> Name -> Q [Dec]

-- | Generates a lambda expression which behaves like <tt>bimap</tt>
--   (without requiring a <a>Bifunctor</a> instance).
makeBimap :: Name -> Q Exp

-- | Like <a>makeBimap</a>, but takes an <a>Options</a> argument.
makeBimapOptions :: Options -> Name -> Q Exp

-- | Generates a <a>Bifoldable</a> instance declaration for the given data
--   type or data family instance.
deriveBifoldable :: Name -> Q [Dec]

-- | Like <a>deriveBifoldable</a>, but takes an <a>Options</a> argument.
deriveBifoldableOptions :: Options -> Name -> Q [Dec]
makeBifold :: Name -> Q Exp

-- | Like <a>makeBifold</a>, but takes an <a>Options</a> argument.
makeBifoldOptions :: Options -> Name -> Q Exp

-- | Generates a lambda expression which behaves like <tt>bifoldMap</tt>
--   (without requiring a <a>Bifoldable</a> instance).
makeBifoldMap :: Name -> Q Exp

-- | Like <a>makeBifoldMap</a>, but takes an <a>Options</a> argument.
makeBifoldMapOptions :: Options -> Name -> Q Exp

-- | Generates a lambda expression which behaves like <tt>bifoldr</tt>
--   (without requiring a <a>Bifoldable</a> instance).
makeBifoldr :: Name -> Q Exp

-- | Like <a>makeBifoldr</a>, but takes an <a>Options</a> argument.
makeBifoldrOptions :: Options -> Name -> Q Exp

-- | Generates a lambda expression which behaves like <tt>bifoldl</tt>
--   (without requiring a <a>Bifoldable</a> instance).
makeBifoldl :: Name -> Q Exp

-- | Like <a>makeBifoldl</a>, but takes an <a>Options</a> argument.
makeBifoldlOptions :: Options -> Name -> Q Exp

-- | Generates a <a>Bitraversable</a> instance declaration for the given
--   data type or data family instance.
deriveBitraversable :: Name -> Q [Dec]

-- | Like <a>deriveBitraversable</a>, but takes an <a>Options</a> argument.
deriveBitraversableOptions :: Options -> Name -> Q [Dec]

-- | Generates a lambda expression which behaves like <tt>bitraverse</tt>
--   (without requiring a <a>Bitraversable</a> instance).
makeBitraverse :: Name -> Q Exp

-- | Like <a>makeBitraverse</a>, but takes an <a>Options</a> argument.
makeBitraverseOptions :: Options -> Name -> Q Exp

-- | Generates a lambda expression which behaves like <tt>bisequenceA</tt>
--   (without requiring a <a>Bitraversable</a> instance).
makeBisequenceA :: Name -> Q Exp

-- | Like <tt>makeBitraverseA</tt>, but takes an <a>Options</a> argument.
makeBisequenceAOptions :: Options -> Name -> Q Exp

-- | Generates a lambda expression which behaves like <tt>bimapM</tt>
--   (without requiring a <a>Bitraversable</a> instance).
makeBimapM :: Name -> Q Exp

-- | Like <a>makeBimapM</a>, but takes an <a>Options</a> argument.
makeBimapMOptions :: Options -> Name -> Q Exp

-- | Generates a lambda expression which behaves like <tt>bisequence</tt>
--   (without requiring a <a>Bitraversable</a> instance).
makeBisequence :: Name -> Q Exp

-- | Like <a>makeBisequence</a>, but takes an <a>Options</a> argument.
makeBisequenceOptions :: Options -> Name -> Q Exp

-- | Options that further configure how the functions in
--   <a>Data.Bifunctor.TH</a> should behave.
newtype Options
Options :: Bool -> Options

-- | If <a>True</a>, derived instances for empty data types (i.e., ones
--   with no data constructors) will use the <tt>EmptyCase</tt> language
--   extension. If <a>False</a>, derived instances will simply use
--   <a>seq</a> instead.
[emptyCaseBehavior] :: Options -> Bool

-- | Conservative <a>Options</a> that doesn't attempt to use
--   <tt>EmptyCase</tt> (to prevent users from having to enable that
--   extension at use sites.)
defaultOptions :: Options
instance GHC.Classes.Eq Data.Bifunctor.TH.BiFun
instance GHC.Classes.Eq Data.Bifunctor.TH.Options
instance GHC.Classes.Ord Data.Bifunctor.TH.Options
instance GHC.Internal.Read.Read Data.Bifunctor.TH.Options
instance GHC.Internal.Show.Show Data.Bifunctor.TH.Options


module Data.Bifunctor.Tannen

-- | Compose a <a>Functor</a> on the outside of a <a>Bifunctor</a>.
newtype Tannen (f :: k -> Type) (p :: k1 -> k2 -> k) (a :: k1) (b :: k2)
Tannen :: f (p a b) -> Tannen (f :: k -> Type) (p :: k1 -> k2 -> k) (a :: k1) (b :: k2)
[runTannen] :: Tannen (f :: k -> Type) (p :: k1 -> k2 -> k) (a :: k1) (b :: k2) -> f (p a b)
instance (GHC.Internal.Base.Applicative f, GHC.Internal.Control.Arrow.ArrowChoice p) => GHC.Internal.Control.Arrow.ArrowChoice (Data.Bifunctor.Tannen.Tannen f p)
instance (GHC.Internal.Base.Applicative f, GHC.Internal.Control.Arrow.ArrowLoop p) => GHC.Internal.Control.Arrow.ArrowLoop (Data.Bifunctor.Tannen.Tannen f p)
instance (GHC.Internal.Base.Applicative f, GHC.Internal.Control.Arrow.ArrowPlus p) => GHC.Internal.Control.Arrow.ArrowPlus (Data.Bifunctor.Tannen.Tannen f p)
instance (GHC.Internal.Base.Applicative f, GHC.Internal.Control.Arrow.Arrow p) => GHC.Internal.Control.Arrow.Arrow (Data.Bifunctor.Tannen.Tannen f p)
instance (GHC.Internal.Base.Applicative f, GHC.Internal.Control.Arrow.ArrowZero p) => GHC.Internal.Control.Arrow.ArrowZero (Data.Bifunctor.Tannen.Tannen f p)
instance (GHC.Internal.Base.Applicative f, Data.Biapplicative.Biapplicative p) => Data.Biapplicative.Biapplicative (Data.Bifunctor.Tannen.Tannen f p)
instance (Data.Foldable1.Foldable1 f, Data.Bifoldable1.Bifoldable1 p) => Data.Bifoldable1.Bifoldable1 (Data.Bifunctor.Tannen.Tannen f p)
instance (GHC.Internal.Data.Foldable.Foldable f, Data.Bifoldable.Bifoldable p) => Data.Bifoldable.Bifoldable (Data.Bifunctor.Tannen.Tannen f p)
instance Control.Comonad.Comonad f => Data.Bifunctor.Functor.BifunctorComonad (Data.Bifunctor.Tannen.Tannen f)
instance GHC.Internal.Base.Functor f => Data.Bifunctor.Functor.BifunctorFunctor (Data.Bifunctor.Tannen.Tannen f)
instance (GHC.Internal.Base.Functor f, GHC.Internal.Base.Monad f) => Data.Bifunctor.Functor.BifunctorMonad (Data.Bifunctor.Tannen.Tannen f)
instance (GHC.Internal.Base.Functor f, Data.Bifunctor.Bifunctor p) => Data.Bifunctor.Bifunctor (Data.Bifunctor.Tannen.Tannen f p)
instance (GHC.Internal.Data.Traversable.Traversable f, Data.Bitraversable.Bitraversable p) => Data.Bitraversable.Bitraversable (Data.Bifunctor.Tannen.Tannen f p)
instance forall k (f :: * -> *) (p :: k -> k -> *). (GHC.Internal.Base.Applicative f, GHC.Internal.Control.Category.Category p) => GHC.Internal.Control.Category.Category (Data.Bifunctor.Tannen.Tannen f p)
instance (Data.Functor.Classes.Eq1 f, Data.Functor.Classes.Eq2 p, GHC.Classes.Eq a) => Data.Functor.Classes.Eq1 (Data.Bifunctor.Tannen.Tannen f p a)
instance (Data.Functor.Classes.Eq1 f, Data.Functor.Classes.Eq2 p) => Data.Functor.Classes.Eq2 (Data.Bifunctor.Tannen.Tannen f p)
instance forall k1 (f :: k1 -> *) k2 k3 (p :: k2 -> k3 -> k1) (a :: k2) (b :: k3). GHC.Classes.Eq (f (p a b)) => GHC.Classes.Eq (Data.Bifunctor.Tannen.Tannen f p a b)
instance (GHC.Internal.Data.Foldable.Foldable f, Data.Bifoldable.Bifoldable p) => GHC.Internal.Data.Foldable.Foldable (Data.Bifunctor.Tannen.Tannen f p a)
instance (GHC.Internal.Base.Functor f, Data.Bifunctor.Bifunctor p) => GHC.Internal.Base.Functor (Data.Bifunctor.Tannen.Tannen f p a)
instance forall k1 k2 (f :: * -> *) (p :: k1 -> k2 -> *) (a :: k1). GHC.Internal.Base.Functor f => GHC.Internal.Generics.Generic1 (Data.Bifunctor.Tannen.Tannen f p a)
instance forall k1 (f :: k1 -> *) k2 k3 (p :: k2 -> k3 -> k1) (a :: k2) (b :: k3). GHC.Internal.Generics.Generic (Data.Bifunctor.Tannen.Tannen f p a b)
instance (Data.Functor.Classes.Ord1 f, Data.Functor.Classes.Ord2 p, GHC.Classes.Ord a) => Data.Functor.Classes.Ord1 (Data.Bifunctor.Tannen.Tannen f p a)
instance (Data.Functor.Classes.Ord1 f, Data.Functor.Classes.Ord2 p) => Data.Functor.Classes.Ord2 (Data.Bifunctor.Tannen.Tannen f p)
instance forall k1 (f :: k1 -> *) k2 k3 (p :: k2 -> k3 -> k1) (a :: k2) (b :: k3). GHC.Classes.Ord (f (p a b)) => GHC.Classes.Ord (Data.Bifunctor.Tannen.Tannen f p a b)
instance (Data.Functor.Classes.Read1 f, Data.Functor.Classes.Read2 p, GHC.Internal.Read.Read a) => Data.Functor.Classes.Read1 (Data.Bifunctor.Tannen.Tannen f p a)
instance (Data.Functor.Classes.Read1 f, Data.Functor.Classes.Read2 p) => Data.Functor.Classes.Read2 (Data.Bifunctor.Tannen.Tannen f p)
instance forall k1 (f :: k1 -> *) k2 k3 (p :: k2 -> k3 -> k1) (a :: k2) (b :: k3). GHC.Internal.Read.Read (f (p a b)) => GHC.Internal.Read.Read (Data.Bifunctor.Tannen.Tannen f p a b)
instance (Data.Functor.Classes.Show1 f, Data.Functor.Classes.Show2 p, GHC.Internal.Show.Show a) => Data.Functor.Classes.Show1 (Data.Bifunctor.Tannen.Tannen f p a)
instance (Data.Functor.Classes.Show1 f, Data.Functor.Classes.Show2 p) => Data.Functor.Classes.Show2 (Data.Bifunctor.Tannen.Tannen f p)
instance forall k1 (f :: k1 -> *) k2 k3 (p :: k2 -> k3 -> k1) (a :: k2) (b :: k3). GHC.Internal.Show.Show (f (p a b)) => GHC.Internal.Show.Show (Data.Bifunctor.Tannen.Tannen f p a b)
instance (GHC.Internal.Base.Functor f, Data.Bifunctor.Swap.Swap p) => Data.Bifunctor.Swap.Swap (Data.Bifunctor.Tannen.Tannen f p)
instance (GHC.Internal.Data.Traversable.Traversable f, Data.Bitraversable.Bitraversable p) => GHC.Internal.Data.Traversable.Traversable (Data.Bifunctor.Tannen.Tannen f p a)


module Data.Bifunctor.Wrapped

-- | Make a <a>Functor</a> over the second argument of a <a>Bifunctor</a>.
newtype WrappedBifunctor (p :: k -> k1 -> Type) (a :: k) (b :: k1)
WrapBifunctor :: p a b -> WrappedBifunctor (p :: k -> k1 -> Type) (a :: k) (b :: k1)
[unwrapBifunctor] :: WrappedBifunctor (p :: k -> k1 -> Type) (a :: k) (b :: k1) -> p a b
instance Data.Biapplicative.Biapplicative p => Data.Biapplicative.Biapplicative (Data.Bifunctor.Wrapped.WrappedBifunctor p)
instance Data.Bifoldable1.Bifoldable1 p => Data.Bifoldable1.Bifoldable1 (Data.Bifunctor.Wrapped.WrappedBifunctor p)
instance Data.Bifoldable.Bifoldable p => Data.Bifoldable.Bifoldable (Data.Bifunctor.Wrapped.WrappedBifunctor p)
instance Data.Bifunctor.Bifunctor p => Data.Bifunctor.Bifunctor (Data.Bifunctor.Wrapped.WrappedBifunctor p)
instance Data.Bitraversable.Bitraversable p => Data.Bitraversable.Bitraversable (Data.Bifunctor.Wrapped.WrappedBifunctor p)
instance (Data.Functor.Classes.Eq2 p, GHC.Classes.Eq a) => Data.Functor.Classes.Eq1 (Data.Bifunctor.Wrapped.WrappedBifunctor p a)
instance Data.Functor.Classes.Eq2 p => Data.Functor.Classes.Eq2 (Data.Bifunctor.Wrapped.WrappedBifunctor p)
instance forall k1 k2 (p :: k1 -> k2 -> *) (a :: k1) (b :: k2). GHC.Classes.Eq (p a b) => GHC.Classes.Eq (Data.Bifunctor.Wrapped.WrappedBifunctor p a b)
instance Data.Bifoldable.Bifoldable p => GHC.Internal.Data.Foldable.Foldable (Data.Bifunctor.Wrapped.WrappedBifunctor p a)
instance Data.Bifunctor.Bifunctor p => GHC.Internal.Base.Functor (Data.Bifunctor.Wrapped.WrappedBifunctor p a)
instance forall k1 k2 (p :: k2 -> k1 -> *) (a :: k2). GHC.Internal.Generics.Generic1 (Data.Bifunctor.Wrapped.WrappedBifunctor p a)
instance forall k1 k2 (p :: k1 -> k2 -> *) (a :: k1) (b :: k2). GHC.Internal.Generics.Generic (Data.Bifunctor.Wrapped.WrappedBifunctor p a b)
instance (Data.Functor.Classes.Ord2 p, GHC.Classes.Ord a) => Data.Functor.Classes.Ord1 (Data.Bifunctor.Wrapped.WrappedBifunctor p a)
instance Data.Functor.Classes.Ord2 p => Data.Functor.Classes.Ord2 (Data.Bifunctor.Wrapped.WrappedBifunctor p)
instance forall k1 k2 (p :: k1 -> k2 -> *) (a :: k1) (b :: k2). GHC.Classes.Ord (p a b) => GHC.Classes.Ord (Data.Bifunctor.Wrapped.WrappedBifunctor p a b)
instance (Data.Functor.Classes.Read2 p, GHC.Internal.Read.Read a) => Data.Functor.Classes.Read1 (Data.Bifunctor.Wrapped.WrappedBifunctor p a)
instance Data.Functor.Classes.Read2 p => Data.Functor.Classes.Read2 (Data.Bifunctor.Wrapped.WrappedBifunctor p)
instance forall k1 k2 (p :: k1 -> k2 -> *) (a :: k1) (b :: k2). GHC.Internal.Read.Read (p a b) => GHC.Internal.Read.Read (Data.Bifunctor.Wrapped.WrappedBifunctor p a b)
instance (Data.Functor.Classes.Show2 p, GHC.Internal.Show.Show a) => Data.Functor.Classes.Show1 (Data.Bifunctor.Wrapped.WrappedBifunctor p a)
instance Data.Functor.Classes.Show2 p => Data.Functor.Classes.Show2 (Data.Bifunctor.Wrapped.WrappedBifunctor p)
instance forall k1 k2 (p :: k1 -> k2 -> *) (a :: k1) (b :: k2). GHC.Internal.Show.Show (p a b) => GHC.Internal.Show.Show (Data.Bifunctor.Wrapped.WrappedBifunctor p a b)
instance Data.Bitraversable.Bitraversable p => GHC.Internal.Data.Traversable.Traversable (Data.Bifunctor.Wrapped.WrappedBifunctor p a)
