-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/
-- | Tools for functors from Hask^k to Hask
--
-- Tools for functors from Hask^k to Hask
@package conkin
@version 1.0.2
-- | The Conkin module defines tools for types of kind (k
-- -> *) -> * (continuation kind types),
-- treating them as functors from the category of types of kind k
-- -> * (Hask^k) to the category of types of kind
-- * (Hask).
--
-- It defines its own Functor, Applicative,
-- Foldable, and Traversable classes, as continuation kind
-- types are kind-incompatible with the homonymous classes in
-- Prelude.
--
-- The Dispose type lifts a traditional functor to a continuation
-- kind functor:
--
--
-- >>> :k Dispose Maybe 0
-- Dispose Maybe 0 :: (Nat -> *) -> *
--
--
-- While the Coyoneda type does the opposite.
--
--
-- >>> data OfSymbol a = OfSymbol (a "hello")
--
-- >>> :k OfSymbol
-- OfSymbol :: (Symbol -> *) -> *
--
-- >>> :k Coyoneda OfSymbol
-- Coyoneda OfSymbol :: * -> *
--
--
-- Two of the most useful functions provided by the module are
-- align and apportion, as they allow you to transpose the
-- composition of a traditional endofunctor and a continuation kind
-- functor.
--
--
-- >>> rows = zipWith (\ch ix -> Pair (Identity ch, Identity ix)) "abc" [0..2]
--
-- >>> rows
-- [ Pair { getPair = ( Identity 'a' , Identity 0 ) }
-- , Pair { getPair = ( Identity 'b' , Identity 1 ) }
-- , Pair { getPair = ( Identity 'c' , Identity 2 ) }
-- ]
--
-- >>> cols = align rows
--
-- >>> cols
-- Pair { getPair = ( "abc" , [ 0 , 1 , 2 ] ) }
--
-- >>> apportion cols
-- [ Pair { getPair = ( Identity 'a' , Identity 0 ) }
-- , Pair { getPair = ( Identity 'a' , Identity 1 ) }
-- , Pair { getPair = ( Identity 'a' , Identity 2 ) }
-- , Pair { getPair = ( Identity 'b' , Identity 0 ) }
-- , Pair { getPair = ( Identity 'b' , Identity 1 ) }
-- , Pair { getPair = ( Identity 'b' , Identity 2 ) }
-- , Pair { getPair = ( Identity 'c' , Identity 0 ) }
-- , Pair { getPair = ( Identity 'c' , Identity 1 ) }
-- , Pair { getPair = ( Identity 'c' , Identity 2 ) }
-- ]
--
-- >>> apportion $ fmap ZipList cols
-- ZipList
-- { getZipList =
-- [ Pair { getPair = ( Identity 'a' , Identity 0 ) }
-- , Pair { getPair = ( Identity 'b' , Identity 1 ) }
-- , Pair { getPair = ( Identity 'c' , Identity 2 ) }
-- ]
-- }
--
--
-- There's also convenience types for Products and
-- Coproducts of continuation kind functors, as well as for
-- Tuples and Tagged unions of arbitrary types.
module Conkin
-- | A functor from Hask^k to Hask, an analogue of
-- Functor for kind (k -> *) -> *
class Functor (f :: (k -> *) -> *)
fmap :: Functor f => (forall (x :: k). a x -> b x) -> f a -> f b
-- | An analogue of <$> for use with Conkin's
-- Functor
(<$>) :: Functor f => (forall x. a x -> b x) -> f a -> f b
infixl 4 <$>
-- | An analogue of Applicative for kind (k -> *) ->
-- *
class Functor f => Applicative (f :: (k -> *) -> *)
pure :: Applicative f => (forall (x :: k). a x) -> f a
(<*>) :: Applicative f => f (a ~> b) -> f a -> f b
-- | arrows in Hask^k have type a ~> b :: k -> *
newtype (~>) (a :: k -> *) (b :: k -> *) (x :: k)
Arrow :: (a x -> b x) -> (~>)
[~$~] :: (~>) -> a x -> b x
-- | An analogue of liftA2 for use with Conkin's
-- Applicative
liftA2 :: Applicative f => (forall x. a x -> b x -> c x) -> f a -> f b -> f c
-- | An analogue of liftA3 for use with Conkin's
-- Applicative
liftA3 :: Applicative f => (forall x. a x -> b x -> c x -> d x) -> f a -> f b -> f c -> f d
-- | An extension of liftA3 to functions of four arguments
liftA4 :: Applicative f => (forall x. a x -> b x -> c x -> d x -> e x) -> f a -> f b -> f c -> f d -> f e
-- | An analogue of Foldable for kind (k -> *) -> *
class Foldable (t :: (k -> *) -> *) where foldr f b ta = foldMap (Endo . f) ta `appEndo` b foldMap f = foldr (\ ax b -> f ax <> b) mempty
foldr :: Foldable t => (forall (x :: k). a x -> b -> b) -> b -> t a -> b
foldMap :: (Foldable t, Monoid m) => (forall (x :: k). a x -> m) -> t a -> m
-- | An analogue of Traversable for kind (k -> *) ->
-- *
class (Foldable t, Functor t) => Traversable (t :: (i -> *) -> *) where traverse f = sequenceA . fmap (Compose . f) sequenceA = traverse getCompose
traverse :: forall (f :: (j -> *) -> *) (a :: i -> *) (b :: i -> j -> *). (Traversable t, Applicative f) => (forall x. a x -> f (b x)) -> t a -> f (Compose t (Flip b))
sequenceA :: forall (f :: (j -> *) -> *) (a :: i -> j -> *). (Traversable t, Applicative f) => t (Compose f a) -> f (Compose t (Flip a))
-- | version of traverse that unflips the inner type
traverse' :: (Traversable t, Applicative f) => (forall x. a x -> f (Flip b x)) -> t a -> f (Compose t b)
-- | version of sequenceA that unflips the inner type
sequenceA' :: (Traversable t, Applicative f) => t (Compose f (Flip a)) -> f (Compose t a)
-- | sequenceA helper for single-parameter constructors
--
--
-- >>> :{
-- data OfOne a = OfOne (a Int)
-- instance Functor OfOne where
-- fmap h (OfOne a) = OfOne (h a)
-- instance Applicative OfOne where
-- pure = OfOne
-- OfOne f <*> OfOne a = OfOne (f ~$~ a)
-- instance Foldable OfOne where
-- foldMap h (OfOne a) = h a
-- instance Traversable OfOne where
-- sequenceA (OfOne fa) = liftT1 OfOne fa
-- :}
--
liftT1 :: Applicative g => (forall h. h w -> f h) -> Compose g a w -> g (Compose f (Flip a))
-- | sequenceA helper for two-parameter constructors
--
--
-- >>> :{
-- data OfTwo a = OfTwo (a Int) (a Char)
-- instance Functor OfTwo where
-- fmap h (OfTwo ai ac) = OfTwo (h ai) (h ac)
-- instance Applicative OfTwo where
-- pure a = OfTwo a a
-- OfTwo fi fc <*> OfTwo ai ac = OfTwo (fi ~$~ ai) (fc ~$~ ac)
-- instance Foldable OfTwo where
-- foldMap h (OfTwo ai ac) = h ai <> h ac
-- instance Traversable OfTwo where
-- sequenceA (OfTwo fai fac) = liftT2 OfTwo fai fac
-- :}
--
liftT2 :: Applicative g => (forall h. h w -> h x -> f h) -> Compose g a w -> Compose g a x -> g (Compose f (Flip a))
-- | sequenceA helper for three-parameter constructors
--
--
-- >>> :{
-- data OfThree a = OfThree (a Int) (a Char) (a Bool)
-- instance Functor OfThree where
-- fmap h (OfThree ai ac ab) = OfThree (h ai) (h ac) (h ab)
-- instance Applicative OfThree where
-- pure a = OfThree a a a
-- OfThree fi fc fb <*> OfThree ai ac ab = OfThree (fi ~$~ ai) (fc ~$~ ac) (fb ~$~ ab)
-- instance Foldable OfThree where
-- foldMap h (OfThree ai ac ab) = h ai <> h ac <> h ab
-- instance Traversable OfThree where
-- sequenceA (OfThree fai fac fab) = liftT3 OfThree fai fac fab
-- :}
--
liftT3 :: Applicative g => (forall h. h w -> h x -> h y -> f h) -> Compose g a w -> Compose g a x -> Compose g a y -> g (Compose f (Flip a))
-- | sequenceA helper for four-parameter constructors
--
--
-- >>> :{
-- data OfFour a = OfFour (a Int) (a Char) (a Bool) (a Double)
-- instance Functor OfFour where
-- fmap h (OfFour ai ac ab ad) = OfFour (h ai) (h ac) (h ab) (h ad)
-- instance Applicative OfFour where
-- pure a = OfFour a a a a
-- OfFour fi fc fb fd <*> OfFour ai ac ab ad = OfFour (fi ~$~ ai) (fc ~$~ ac) (fb ~$~ ab) (fd ~$~ ad)
-- instance Foldable OfFour where
-- foldMap h (OfFour ai ac ab ad) = h ai <> h ac <> h ab <> h ad
-- instance Traversable OfFour where
-- sequenceA (OfFour fai fac fab fad) = liftT4 OfFour fai fac fab fad
-- :}
--
liftT4 :: Applicative g => (forall h. h w -> h x -> h y -> h z -> f h) -> Compose g a w -> Compose g a x -> Compose g a y -> Compose g a z -> g (Compose f (Flip a))
-- | Loosely, align transforms an array of structures into a
-- structure of arrays, if by "array" one means an arbitrary collection
-- type.
--
--
-- >>> rows = zipWith (\ch ix -> Pair (Identity ch, Identity ix)) "abc" [0..2]
--
-- >>> rows
-- [ Pair { getPair = ( Identity 'a' , Identity 0 ) }
-- , Pair { getPair = ( Identity 'b' , Identity 1 ) }
-- , Pair { getPair = ( Identity 'c' , Identity 2 ) }
-- ]
--
-- >>> align rows
-- Pair { getPair = ( "abc" , [ 0 , 1 , 2 ] ) }
--
align :: (Traversable f, Applicative g) => f (g Identity) -> g f
-- | Loosely, apportion transforms a structure of arrays into an
-- array of structures, if by "array" one means an arbitrary collection
-- type.
--
-- Depending on the collection's Applicative instance, this may or
-- may not be the inverse of align.
--
--
-- >>> cols = Pair { getPair = ( "abc" , [ 0 , 1 , 2 ] ) }
--
-- >>> apportion cols
-- [ Pair { getPair = ( Identity 'a' , Identity 0 ) }
-- , Pair { getPair = ( Identity 'a' , Identity 1 ) }
-- , Pair { getPair = ( Identity 'a' , Identity 2 ) }
-- , Pair { getPair = ( Identity 'b' , Identity 0 ) }
-- , Pair { getPair = ( Identity 'b' , Identity 1 ) }
-- , Pair { getPair = ( Identity 'b' , Identity 2 ) }
-- , Pair { getPair = ( Identity 'c' , Identity 0 ) }
-- , Pair { getPair = ( Identity 'c' , Identity 1 ) }
-- , Pair { getPair = ( Identity 'c' , Identity 2 ) }
-- ]
--
-- >>> apportion $ fmap ZipList cols
-- ZipList
-- { getZipList =
-- [ Pair { getPair = ( Identity 'a' , Identity 0 ) }
-- , Pair { getPair = ( Identity 'b' , Identity 1 ) }
-- , Pair { getPair = ( Identity 'c' , Identity 2 ) }
-- ]
-- }
--
apportion :: (Applicative f, Traversable g) => g f -> f (g Identity)
-- | If f is a functor from Hask to Hask, then,
-- forall (x :: k). Dispose f x is a functor from Hask^k
-- to Hask
--
-- The name comes from the isomorphism Dispose f ~ Flip (Compose f)
-- :: k -> (k -> *) -> *, as a pun off the latin prefixes
-- "com-", meaning together, and "dis-", meaning apart.
newtype Dispose (f :: * -> *) (x :: k) (a :: k -> *)
Dispose :: f (a x) -> Dispose
[getDispose] :: Dispose -> f (a x)
-- | If t is a functor from Hask^k to Hask, then
-- Coyoneda t is a functor from Hask to Hask.
--
-- It's very similar to the Coyoneda from the
-- kan-extensions package, differing only in kind, and
-- Coyoneda t a is isomorphic to t (Const a) for any
-- Functor.
data Coyoneda (t :: (k -> *) -> *) (u :: *)
[Coyoneda] :: (forall x. a x -> u) -> t a -> Coyoneda t u
-- | convert a functor from its Coyoneda representation
getCoyoneda :: Functor t => Coyoneda t a -> t (Const a)
-- | convert a functor to its Coyoneda representation
toCoyoneda :: t (Const a) -> Coyoneda t a
-- | The product of two continuation kind functors is a continuation kind
-- functor.
--
--
-- >>> data A z where A :: Int -> [x] -> [y] -> A '(x,y)
--
-- >>> data B z where B :: [(x,y)] -> B '(x,y)
--
-- >>> foo = Product . Pure . Compose . Pure . Curry $ A 0 "abc" [True, False]
--
-- >>> :t foo
-- foo :: Product (Pure Char) (Pure Bool) A
--
-- >>> a2b :: A z -> B z ; a2b (A _ xs ys) = B $ zip xs ys
--
-- >>> :t fmap a2b foo
-- fmap a2b foo :: Product (Pure Char) (Pure Bool) B
--
newtype Product (f :: (i -> *) -> *) (g :: (j -> *) -> *) (a :: (i, j) -> *)
Product :: f (Compose g (Curry a)) -> Product
[getProduct] :: Product -> f (Compose g (Curry a))
-- | helper to make a Product when the inner type is already
-- curried.
--
--
-- >>> comma = Pure . Compose . Pure $ ('a', True)
--
-- >>> :t comma
-- comma :: Pure Char (Compose (Pure Bool) (,))
--
-- >>> :t toProduct UncurryStrict comma
-- toProduct UncurryStrict comma
-- :: Product (Pure Char) (Pure Bool) (Uncurry (,))
--
toProduct :: (Functor f, Functor g) => (forall x y. a x y -> b '(x, y)) -> f (Compose g a) -> Product f g b
-- | helper to unwrap a Product when the inner type is already
-- curried.
--
--
-- >>> comma' = toProduct UncurryStrict . Pure . Compose . Pure $ ('a', True)
--
-- >>> :t comma'
-- comma' :: Product (Pure Char) (Pure Bool) (Uncurry (,))
--
-- >>> :t getProduct comma'
-- getProduct comma'
-- :: Pure Char (Compose (Pure Bool) (Curry (Uncurry (,))))
--
-- >>> :t fromProduct getUncurryStrict comma'
-- fromProduct getUncurryStrict comma'
-- :: Pure Char (Compose (Pure Bool) (,))
--
fromProduct :: (Functor f, Functor g) => (forall x y. b '(x, y) -> a x y) -> Product f g b -> f (Compose g a)
-- | The coproduct of two continuation kind functors is a continuation kind
-- functor.
--
--
-- >>> data A z where { AL :: i -> A ('Left i) ; AR :: j -> A ('Right j) }
--
-- >>> data B z where { BL :: i -> i -> B ('Left i) ; BR :: B ('Right j) }
--
-- >>> bar = Coproduct (Pure . Compose $ AL True, Pure . Compose $ AR 'a')
--
-- >>> :t bar
-- bar :: Coproduct (Pure Bool) (Pure Char) A
--
-- >>> a2b :: A z -> B z ; a2b (AL i) = BL i i ; a2b (AR _) = BR
--
-- >>> :t fmap a2b bar
-- fmap a2b bar :: Coproduct (Pure Bool) (Pure Char) B
--
newtype Coproduct (f :: (i -> *) -> *) (g :: (j -> *) -> *) (a :: Either i j -> *)
Coproduct :: (f (Compose a Left), g (Compose a Right)) -> Coproduct
[getCoproduct] :: Coproduct -> (f (Compose a Left), g (Compose a Right))
-- | A continuation kind functor for pairs.
--
--
-- >>> :t Pair (Identity True, Identity 'a')
-- Pair (Identity True, Identity 'a') :: Pair Bool Char Identity
--
newtype Pair (x0 :: k) (x1 :: k) (a :: k -> *)
Pair :: (a x0, a x1) -> Pair
[getPair] :: Pair -> (a x0, a x1)
-- | A continuation kind functor for tuples of arbitrary length.
--
--
-- >>> :t Identity True `Cons` Identity 'a' `Cons` Nil
-- Identity True `Cons` Identity 'a' `Cons` Nil
-- :: Tuple '[Bool, Char] Identity
--
data Tuple (xs :: [k]) (a :: k -> *)
[Nil] :: Tuple '[] a
[Cons] :: a x -> !(Tuple xs a) -> Tuple (x : xs) a
-- | A continuation kind functor for tagged unions
--
--
-- >>> :t [ Here (Identity True), There $ Here (Identity 'a') ]
-- [ Here (Identity True), There $ Here (Identity 'a') ]
-- :: [Tagged (Bool : Char : xs) Identity]
--
data Tagged (xs :: [k]) (a :: k -> *)
[Here] :: a x -> Tagged (x : xs) a
[There] :: !(Tagged xs a) -> Tagged (x : xs) a
-- | a type-level version of flip, it's used in the definition of
-- traverse and sequenceA as a way to reverse the order in
-- which parameters are passed.
--
-- Flip (Flip a) is isomorphic to Identity a
--
--
-- >>> :t Flip . Flip
-- Flip . Flip :: a y x -> Flip (Flip a) y x
--
-- >>> :t getFlip . getFlip
-- getFlip . getFlip :: Flip (Flip a) x y -> a x y
--
newtype Flip (a :: i -> j -> *) (y :: j) (x :: i)
Flip :: a x y -> Flip
[getFlip] :: Flip -> a x y
-- | a type-level version of curry, it's used to convert between
-- types of kind (i,j) -> * and types of kind i -> j
-- -> *
newtype Curry (a :: (i, j) -> *) (x :: i) (y :: j)
Curry :: a '(x, y) -> Curry
[getCurry] :: Curry -> a '(x, y)
-- | A type-level version of uncurry, it's used to convert between
-- types of kind i -> j -> * and types of kind (i,j)
-- -> *.
newtype Uncurry (a :: i -> j -> *) (z :: (i, j))
-- | The UncurryLazy constructor is useful when you need to
-- construct/destruct an Uncurry a z value without placing
-- restrictions on z
--
--
-- >>> :t (\(UncurryLazy axy) -> UncurryLazy axy) :: Uncurry a z -> Uncurry a z
-- (\(UncurryLazy axy) -> UncurryLazy axy) :: Uncurry a z -> Uncurry a z
-- :: Uncurry a z -> Uncurry a z
--
-- >>> import Data.Tuple (swap)
--
-- >>> :t (\(UncurryLazy axy) -> UncurryLazy $ Flip $ swap axy) :: Uncurry (,) z -> Uncurry (Flip (,)) z
-- (\(UncurryLazy axy) -> UncurryLazy $ Flip $ swap axy) :: Uncurry (,) z -> Uncurry (Flip (,)) z
-- :: Uncurry (,) z -> Uncurry (Flip (,)) z
--
--
-- It is slightly finnicky, and doesn't work well with function
-- composition (i.e. .), and requires more hints from the
-- compiler.
--
--
-- >>> :t (UncurryLazy . getUncurryLazy) :: Uncurry a z -> Uncurry a z
--
-- <interactive>:1:2: error:
-- • Couldn't match type ‘a1 x0 y0’
-- with ‘forall x y. z1 ~ '(x, y) => a1 x y’
-- ...
--
-- >>> :t (\(UncurryLazy axy) -> UncurryLazy axy)
--
-- <interactive>:1:36: error:
-- • Couldn't match type ‘z’ with ‘'(x, y)’
-- arising from a use of ‘axy’
-- because type variables ‘x’, ‘y’ would escape their scope
-- ...
--
UncurryLazy :: (forall x y. (z ~ '(x, y)) => a x y) -> Uncurry
[getUncurryLazy] :: Uncurry -> forall x y. (z ~ '(x, y)) => a x y
-- | The UncurryStrict pattern is useful when you need to
-- construct/destruct an 'Uncurry a '(x,y)' value
--
--
-- >>> :t UncurryStrict . getUncurryStrict
-- UncurryStrict . getUncurryStrict
-- :: Uncurry a '(x, y) -> Uncurry a '(x, y)
--
-- >>> import Data.Tuple (swap)
--
-- >>> :t UncurryStrict . Flip . swap . getUncurryStrict
-- UncurryStrict . Flip . swap . getUncurryStrict
-- :: Uncurry (,) '(x, y) -> Uncurry (Flip (,)) '(x, y)
--
--
-- It works well with function composition and requires fewer hints, but
-- cannot be used to construct or match values of type Uncurry a
-- z, such as are needed by fmap.
--
--
-- >>> :t (\(UncurryLazy axy) -> UncurryStrict axy) :: Uncurry a z -> Uncurry a z
--
-- <interactive>:1:38: error:
-- • Couldn't match type ‘z1’ with ‘'(x0, y0)’
-- ...
-- • In the first argument of ‘UncurryStrict’, namely ‘axy’
-- ...
--
-- >>> :t (\(UncurryStrict axy) -> UncurryLazy axy) :: Uncurry a z -> Uncurry a z
--
-- <interactive>:1:4: error:
-- • Couldn't match type ‘z1’ with ‘'(x0, y0)’
-- ...
-- • In the pattern: UncurryStrict axy
-- ...
--
--
-- However, it is very useful when paired with toProduct.
-- | a pseudo-record accessor, corresponding to matching the
-- UncurryStrict pattern. Can be useful when paired with
-- fromProduct
getUncurryStrict :: Uncurry a '(x, y) -> a x y
-- | a helper for lifting functions on curried types to functions on their
-- uncurried equivalents. Very useful when using the Functor
-- instance for Products.
--
--
-- >>> comma' = toProduct UncurryStrict . Pure . Compose . Pure $ ('a', True)
--
-- >>> :t comma'
-- comma' :: Product (Pure Char) (Pure Bool) (Uncurry (,))
--
-- >>> :t uncurried (const . snd) <$> comma'
-- uncurried (const . snd) <$> comma'
-- :: Product (Pure Char) (Pure Bool) (Uncurry (->))
--
uncurried :: (forall x y. a x y -> b x y) -> Uncurry a z -> Uncurry b z
-- | A type-level version of pure for Cont
--
-- Mainly useful when constructing continuation kind functors using
-- Product and Coproduct.
newtype Pure (x :: k) (a :: k -> *)
Pure :: a x -> Pure
[getPure] :: Pure -> a x
instance forall k (x :: k) (a :: k -> GHC.Types.*). GHC.Classes.Ord (a x) => GHC.Classes.Ord (Conkin.Pure x a)
instance forall k (x :: k) (a :: k -> GHC.Types.*). GHC.Classes.Eq (a x) => GHC.Classes.Eq (Conkin.Pure x a)
instance forall k (x :: k) (a :: k -> GHC.Types.*). GHC.Show.Show (a x) => GHC.Show.Show (Conkin.Pure x a)
instance forall j i (a :: i -> j -> GHC.Types.*) (y :: j) (x :: i). GHC.Classes.Ord (a x y) => GHC.Classes.Ord (Conkin.Flip a y x)
instance forall j i (a :: i -> j -> GHC.Types.*) (y :: j) (x :: i). GHC.Classes.Eq (a x y) => GHC.Classes.Eq (Conkin.Flip a y x)
instance forall j i (a :: i -> j -> GHC.Types.*) (y :: j) (x :: i). GHC.Show.Show (a x y) => GHC.Show.Show (Conkin.Flip a y x)
instance forall k (x0 :: k) (x1 :: k) (a :: k -> GHC.Types.*). (GHC.Classes.Ord (a x1), GHC.Classes.Ord (a x0)) => GHC.Classes.Ord (Conkin.Pair x0 x1 a)
instance forall k (x0 :: k) (x1 :: k) (a :: k -> GHC.Types.*). (GHC.Classes.Eq (a x1), GHC.Classes.Eq (a x0)) => GHC.Classes.Eq (Conkin.Pair x0 x1 a)
instance forall k (x0 :: k) (x1 :: k) (a :: k -> GHC.Types.*). (GHC.Show.Show (a x1), GHC.Show.Show (a x0)) => GHC.Show.Show (Conkin.Pair x0 x1 a)
instance forall (f :: GHC.Types.* -> GHC.Types.*) k (x :: k) (a :: k -> GHC.Types.*). GHC.Classes.Ord (f (a x)) => GHC.Classes.Ord (Conkin.Dispose f x a)
instance forall (f :: GHC.Types.* -> GHC.Types.*) k (x :: k) (a :: k -> GHC.Types.*). GHC.Classes.Eq (f (a x)) => GHC.Classes.Eq (Conkin.Dispose f x a)
instance forall (f :: GHC.Types.* -> GHC.Types.*) k (x :: k) (a :: k -> GHC.Types.*). GHC.Show.Show (f (a x)) => GHC.Show.Show (Conkin.Dispose f x a)
instance forall j i (f :: (i -> *) -> *) (g :: (j -> *) -> *) (a :: (i, j) -> GHC.Types.*). GHC.Show.Show (f (Data.Functor.Compose.Compose g (Conkin.Curry a))) => GHC.Show.Show (Conkin.Product f g a)
instance forall i (f :: (i -> *) -> *) j (g :: (j -> *) -> *) (a :: (i, j) -> GHC.Types.*). GHC.Classes.Eq (f (Data.Functor.Compose.Compose g (Conkin.Curry a))) => GHC.Classes.Eq (Conkin.Product f g a)
instance forall i (f :: (i -> *) -> *) j (g :: (j -> *) -> *) (a :: (i, j) -> GHC.Types.*). GHC.Classes.Ord (f (Data.Functor.Compose.Compose g (Conkin.Curry a))) => GHC.Classes.Ord (Conkin.Product f g a)
instance forall j i (f :: (i -> *) -> *) (a :: Data.Either.Either i j -> *) (g :: (j -> *) -> *). (GHC.Show.Show (f (Data.Functor.Compose.Compose a 'Data.Either.Left)), GHC.Show.Show (g (Data.Functor.Compose.Compose a 'Data.Either.Right))) => GHC.Show.Show (Conkin.Coproduct f g a)
instance forall i (f :: (i -> *) -> *) j (g :: (j -> *) -> *) (a :: Data.Either.Either i j -> *). (GHC.Classes.Eq (f (Data.Functor.Compose.Compose a 'Data.Either.Left)), GHC.Classes.Eq (g (Data.Functor.Compose.Compose a 'Data.Either.Right))) => GHC.Classes.Eq (Conkin.Coproduct f g a)
instance forall i (f :: (i -> *) -> *) j (g :: (j -> *) -> *) (a :: Data.Either.Either i j -> *). (GHC.Classes.Ord (f (Data.Functor.Compose.Compose a 'Data.Either.Left)), GHC.Classes.Ord (g (Data.Functor.Compose.Compose a 'Data.Either.Right))) => GHC.Classes.Ord (Conkin.Coproduct f g a)
instance forall i j (a :: (i, j) -> *) (x :: i) (y :: j). GHC.Show.Show (a '(x, y)) => GHC.Show.Show (Conkin.Curry a x y)
instance forall i j (a :: (i, j) -> *) (x :: i) (y :: j). GHC.Classes.Eq (a '(x, y)) => GHC.Classes.Eq (Conkin.Curry a x y)
instance forall i j (a :: (i, j) -> *) (x :: i) (y :: j). GHC.Classes.Ord (a '(x, y)) => GHC.Classes.Ord (Conkin.Curry a x y)
instance forall k k1 (a :: k1 -> k -> *) (x :: k1) (y :: k). GHC.Show.Show (a x y) => GHC.Show.Show (Conkin.Uncurry a '(x, y))
instance forall k k1 (a :: k -> k1 -> *) (x :: k) (y :: k1). GHC.Classes.Eq (a x y) => GHC.Classes.Eq (Conkin.Uncurry a '(x, y))
instance forall k k1 (a :: k -> k1 -> *) (x :: k) (y :: k1). GHC.Classes.Ord (a x y) => GHC.Classes.Ord (Conkin.Uncurry a '(x, y))
instance forall k (f :: * -> *) (x :: k). GHC.Base.Functor f => Conkin.Functor (Conkin.Dispose f x)
instance forall k (f :: * -> *) (x :: k). GHC.Base.Applicative f => Conkin.Applicative (Conkin.Dispose f x)
instance forall k (t :: * -> *) (x :: k). Data.Foldable.Foldable t => Conkin.Foldable (Conkin.Dispose t x)
instance forall i (t :: * -> *) (x :: i). Data.Traversable.Traversable t => Conkin.Traversable (Conkin.Dispose t x)
instance forall k (t :: (k -> GHC.Types.*) -> GHC.Types.*). GHC.Base.Functor (Conkin.Coyoneda t)
instance forall k (t :: (k -> GHC.Types.*) -> GHC.Types.*). Conkin.Applicative t => GHC.Base.Applicative (Conkin.Coyoneda t)
instance forall k (t :: (k -> GHC.Types.*) -> GHC.Types.*). Conkin.Foldable t => Data.Foldable.Foldable (Conkin.Coyoneda t)
instance forall k (t :: (k -> GHC.Types.*) -> GHC.Types.*). Conkin.Traversable t => Data.Traversable.Traversable (Conkin.Coyoneda t)
instance forall j i (f :: (i -> GHC.Types.*) -> GHC.Types.*) (g :: (j -> GHC.Types.*) -> GHC.Types.*). (Conkin.Functor f, Conkin.Functor g) => Conkin.Functor (Conkin.Product f g)
instance forall j i (f :: (i -> GHC.Types.*) -> GHC.Types.*) (g :: (j -> GHC.Types.*) -> GHC.Types.*). (Conkin.Applicative f, Conkin.Applicative g) => Conkin.Applicative (Conkin.Product f g)
instance forall j i (f :: (i -> GHC.Types.*) -> GHC.Types.*) (g :: (j -> GHC.Types.*) -> GHC.Types.*). (Conkin.Foldable f, Conkin.Foldable g) => Conkin.Foldable (Conkin.Product f g)
instance forall j i (f :: (i -> GHC.Types.*) -> GHC.Types.*) (g :: (j -> GHC.Types.*) -> GHC.Types.*). (Conkin.Traversable f, Conkin.Traversable g) => Conkin.Traversable (Conkin.Product f g)
instance forall j i (f :: (i -> GHC.Types.*) -> GHC.Types.*) (g :: (j -> GHC.Types.*) -> GHC.Types.*). (Conkin.Functor f, Conkin.Functor g) => Conkin.Functor (Conkin.Coproduct f g)
instance forall j i (f :: (i -> GHC.Types.*) -> GHC.Types.*) (g :: (j -> GHC.Types.*) -> GHC.Types.*). (Conkin.Applicative f, Conkin.Applicative g) => Conkin.Applicative (Conkin.Coproduct f g)
instance forall j i (f :: (i -> GHC.Types.*) -> GHC.Types.*) (g :: (j -> GHC.Types.*) -> GHC.Types.*). (Conkin.Foldable f, Conkin.Foldable g) => Conkin.Foldable (Conkin.Coproduct f g)
instance forall j i (f :: (i -> GHC.Types.*) -> GHC.Types.*) (g :: (j -> GHC.Types.*) -> GHC.Types.*). (Conkin.Traversable f, Conkin.Traversable g) => Conkin.Traversable (Conkin.Coproduct f g)
instance forall k (x0 :: k) (x1 :: k). Conkin.Functor (Conkin.Pair x0 x1)
instance forall k (x0 :: k) (x1 :: k). Conkin.Applicative (Conkin.Pair x0 x1)
instance forall k (x0 :: k) (x1 :: k). Conkin.Foldable (Conkin.Pair x0 x1)
instance forall i (x0 :: i) (x1 :: i). Conkin.Traversable (Conkin.Pair x0 x1)
instance forall k (a :: k -> GHC.Types.*). GHC.Show.Show (Conkin.Tuple '[] a)
instance forall k (a :: k -> *) (x :: k) (xs :: [k]). (GHC.Show.Show (a x), GHC.Show.Show (Conkin.Tuple xs a)) => GHC.Show.Show (Conkin.Tuple (x : xs) a)
instance forall k (a :: k -> GHC.Types.*). GHC.Classes.Eq (Conkin.Tuple '[] a)
instance forall k (a :: k -> *) (x :: k) (xs :: [k]). (GHC.Classes.Eq (a x), GHC.Classes.Eq (Conkin.Tuple xs a)) => GHC.Classes.Eq (Conkin.Tuple (x : xs) a)
instance forall k (a :: k -> GHC.Types.*). GHC.Classes.Ord (Conkin.Tuple '[] a)
instance forall k (a :: k -> *) (x :: k) (xs :: [k]). (GHC.Classes.Ord (a x), GHC.Classes.Ord (Conkin.Tuple xs a)) => GHC.Classes.Ord (Conkin.Tuple (x : xs) a)
instance forall k (xs :: [k]). Conkin.Functor (Conkin.Tuple xs)
instance Conkin.Applicative (Conkin.Tuple '[])
instance forall k (xs :: [k]) (x :: k). Conkin.Applicative (Conkin.Tuple xs) => Conkin.Applicative (Conkin.Tuple (x : xs))
instance forall k (xs :: [k]). Conkin.Foldable (Conkin.Tuple xs)
instance forall i (xs :: [i]). Conkin.Traversable (Conkin.Tuple xs)
instance forall k (a :: k -> GHC.Types.*). GHC.Show.Show (Conkin.Tagged '[] a)
instance forall k (a :: k -> GHC.Types.*). GHC.Classes.Eq (Conkin.Tagged '[] a)
instance forall k (a :: k -> GHC.Types.*). GHC.Classes.Ord (Conkin.Tagged '[] a)
instance forall k (a :: k -> *) (x :: k) (xs :: [k]). (GHC.Show.Show (a x), GHC.Show.Show (Conkin.Tagged xs a)) => GHC.Show.Show (Conkin.Tagged (x : xs) a)
instance forall k (a :: k -> *) (x :: k) (xs :: [k]). (GHC.Classes.Eq (a x), GHC.Classes.Eq (Conkin.Tagged xs a)) => GHC.Classes.Eq (Conkin.Tagged (x : xs) a)
instance forall k (a :: k -> *) (x :: k) (xs :: [k]). (GHC.Classes.Ord (a x), GHC.Classes.Ord (Conkin.Tagged xs a)) => GHC.Classes.Ord (Conkin.Tagged (x : xs) a)
instance forall k (xs :: [k]). Conkin.Functor (Conkin.Tagged xs)
instance forall k (xs :: [k]). Conkin.Foldable (Conkin.Tagged xs)
instance forall i (xs :: [i]). Conkin.Traversable (Conkin.Tagged xs)
instance Conkin.Functor (Data.Functor.Const.Const a)
instance GHC.Base.Monoid m => Conkin.Applicative (Data.Functor.Const.Const m)
instance Conkin.Foldable (Data.Functor.Const.Const m)
instance Conkin.Traversable (Data.Functor.Const.Const m)
instance forall k (f :: * -> *) (g :: (k -> GHC.Types.*) -> GHC.Types.*). (GHC.Base.Functor f, Conkin.Functor g) => Conkin.Functor (Data.Functor.Compose.Compose f g)
instance forall k (f :: * -> *) (g :: (k -> GHC.Types.*) -> GHC.Types.*). (GHC.Base.Applicative f, Conkin.Applicative g) => Conkin.Applicative (Data.Functor.Compose.Compose f g)
instance forall k (f :: * -> *) (g :: (k -> GHC.Types.*) -> GHC.Types.*). (Data.Foldable.Foldable f, Conkin.Foldable g) => Conkin.Foldable (Data.Functor.Compose.Compose f g)
instance forall i (f :: * -> *) (g :: (i -> GHC.Types.*) -> GHC.Types.*). (Data.Traversable.Traversable f, Conkin.Traversable g) => Conkin.Traversable (Data.Functor.Compose.Compose f g)
instance forall k (x :: k). Conkin.Functor (Conkin.Pure x)
instance forall k (x :: k). Conkin.Applicative (Conkin.Pure x)
instance forall k (x :: k). Conkin.Foldable (Conkin.Pure x)
instance forall i (x :: i). Conkin.Traversable (Conkin.Pure x)