s      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None$%&+,/9:;DOQRTbf$A type-level version of  for BMainly useful when constructing continuation kind functors using  and .A type-level version of ., it's used to convert between types of kind  i -> j -> * and types of kind  (i,j) -> *.The ? constructor is useful when you need to construct/destruct an  Uncurry a z( value without placing restrictions on zH:t (\(UncurryLazy axy) -> UncurryLazy axy) :: Uncurry a z -> Uncurry a zE(\(UncurryLazy axy) -> UncurryLazy axy) :: Uncurry a z -> Uncurry a z :: Uncurry a z -> Uncurry a zimport Data.Tuple (swap)a: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 (,)) zPIt 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...a type-level version of ., it's used to convert between types of kind  (i,j) -> * and types of kind  i -> j -> * a type-level version of ", it's used in the definition of ! and "? 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 -A continuation kind functor for tagged unions8:t [ Here (Identity True), There $ Here (Identity 'a') ]5[ Here (Identity True), There $ Here (Identity 'a') ]) :: [Tagged (Bool : Char : xs) Identity];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&A continuation kind functor for pairs.%:t Pair (Identity True, Identity 'a')=Pair (Identity True, Identity 'a') :: Pair Bool Char IdentityOThe coproduct of two continuation kind functors is a continuation kind functor.Cdata A z where { AL :: i -> A ('Left i) ; AR :: j -> A ('Right j) }Cdata B z where { BL :: i -> i -> B ('Left i) ; BR :: B ('Right j) }Cbar = Coproduct (Pure . Compose $ AL True, Pure . Compose $ AR 'a'):t bar*bar :: Coproduct (Pure Bool) (Pure Char) A9a2b :: A z -> B z ; a2b (AL i) = BL i i ; a2b (AR _) = BR:t fmap a2b bar3fmap a2b bar :: Coproduct (Pure Bool) (Pure Char) BMThe product of two continuation kind functors is a continuation kind functor.1data A z where A :: Int -> [x] -> [y] -> A '(x,y)'data B z where B :: [(x,y)] -> B '(x,y)Gfoo = Product . Pure . Compose . Pure . Curry $ A 0 "abc" [True, False]:t foo(foo :: Product (Pure Char) (Pure Bool) A3a2b :: A z -> B z ; a2b (A _ xs ys) = B $ zip xs ys:t fmap a2b foo1fmap a2b foo :: Product (Pure Char) (Pure Bool) BIf 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  from the kan-extensions' package, differing only in kind, and  Coyoneda t a is isomorphic to  t (Const a) for any ,.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 3Dispose f ~ Flip (Compose f) :: k -> (k -> *) -> *W, as a pun off the latin prefixes "com-", meaning together, and "dis-", meaning apart. An analogue of  for kind  (k -> *) -> *#An analogue of  for kind  (k -> *) -> *& arrows in Hask^k have type a ~> b :: k -> * )An analogue of  for kind  (k -> *) -> *,A functor from Hask^k to Hask, an analogue of  for kind  (k -> *) -> *.The .S 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)1:t UncurryStrict . Flip . swap . getUncurryStrict.UncurryStrict . Flip . swap . getUncurryStrict6 :: 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 -.J: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 ...J: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 =./An analogue of  for use with Conkin's ,0An analogue of  for use with Conkin's )1An analogue of  for use with Conkin's )2An extension of 1 to functions of four arguments3 version of ! that unflips the inner type 4 version of " that unflips the inner type 5") 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:}6"& 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 where2 sequenceA (OfTwo fai fac) = liftT2 OfTwo fai fac:}7"( helper for three-parameter constructors:{ 2data 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 aU OfThree fi fc fb <*> OfThree ai ac ab = OfThree (fi ~$~ ai) (fc ~$~ ac) (fb ~$~ ab)instance Foldable OfThree where5 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:}8"' helper for four-parameter constructors:{ ;data OfFour a = OfFour (a Int) (a Char) (a Bool) (a Double)instance Functor OfFour whereB 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 ad 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 whereD sequenceA (OfFour fai fac fab fad) = liftT4 OfFour fai fac fab fad:}9 Loosely, 9u transforms an array of structures into a structure of arrays, if by "array" one means an arbitrary collection type.Grows = zipWith (\ch ix -> Pair (Identity ch, Identity ix)) "abc" [0..2]rows2[ Pair { getPair = ( Identity 'a' , Identity 0 ) }2, Pair { getPair = ( Identity 'b' , Identity 1 ) }2, Pair { getPair = ( Identity 'c' , Identity 2 ) }] align rows,Pair { getPair = ( "abc" , [ 0 , 1 , 2 ] ) }: Loosely, :u transforms a structure of arrays into an array of structures, if by "array" one means an arbitrary collection type.Depending on the collection's 2 instance, this may or may not be the inverse of 9.3cols = Pair { getPair = ( "abc" , [ 0 , 1 , 2 ] ) }apportion cols 2[ Pair { getPair = ( Identity 'a' , Identity 0 ) }2, Pair { getPair = ( Identity 'a' , Identity 1 ) }2, Pair { getPair = ( Identity 'a' , Identity 2 ) }2, Pair { getPair = ( Identity 'b' , Identity 0 ) }2, Pair { getPair = ( Identity 'b' , Identity 1 ) }2, Pair { getPair = ( Identity 'b' , Identity 2 ) }2, Pair { getPair = ( Identity 'c' , Identity 0 ) }2, Pair { getPair = ( Identity 'c' , Identity 1 ) }2, Pair { getPair = ( Identity 'c' , Identity 2 ) }]apportion $ fmap ZipList colsZipList { getZipList = 8 [ Pair { getPair = ( Identity 'a' , Identity 0 ) }8 , Pair { getPair = ( Identity 'b' , Identity 1 ) }8 , Pair { getPair = ( Identity 'c' , Identity 2 ) } ] };convert a functor from its  representation<convert a functor to its  representation=helper to make a ( when the inner type is already curried.+comma = Pure . Compose . Pure $ ('a', True):t comma,comma :: Pure Char (Compose (Pure Bool) (,)) :t toProduct UncurryStrict commatoProduct UncurryStrict comma2 :: Product (Pure Char) (Pure Bool) (Uncurry (,))>helper to unwrap a ( when the inner type is already curried.Fcomma' = toProduct UncurryStrict . Pure . Compose . Pure $ ('a', True) :t comma'7comma' :: 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) (,))?8a pseudo-record accessor, corresponding to matching the .+ pattern. Can be useful when paired with >@ya helper for lifting functions on curried types to functions on their uncurried equivalents. Very useful when using the , instance for s.Fcomma' = toProduct UncurryStrict . Pure . Compose . Pure $ ('a', True) :t comma'7comma' :: Product (Pure Char) (Pure Bool) (Uncurry (,))%:t uncurried (const . snd) <$> comma'"uncurried (const . snd) <$> comma'3 :: Product (Pure Char) (Pure Bool) (Uncurry (->))  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstA  !"#%$&'()+*,-./0123456789:;<=>?@A,-/)*+&'(012#$% !"3456789:;<=>  .?@[    !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrst5&0(0+4/4        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~' &),-.#conkin-1.0.2-GiXViZfIKg82Y5lEx7OWhBConkin Control.MonadContData.Functor.CoyonedaCoyonedaPuregetPureUncurry UncurryLazygetUncurryLazyCurrygetCurryFlipgetFlipTaggedHereThereTupleNilConsPairgetPair Coproduct getCoproductProduct getProductDispose getDispose Traversabletraverse sequenceAFoldablefoldrfoldMap~>Arrow~$~ Applicativepure<*>Functorfmap UncurryStrict<$>liftA2liftA3liftA4 traverse' sequenceA'liftT1liftT2liftT3liftT4align apportion getCoyoneda toCoyoneda toProduct fromProductgetUncurryStrict uncurried$fTraversableiPure$fFoldablekPure$fApplicativekPure$fFunctorkPure$fTraversableiCompose$fFoldablekCompose$fApplicativekCompose$fFunctorkCompose$fTraversableiConst$fFoldablekConst$fApplicativekConst$fFunctorkConst$fTraversableiTagged$fFoldablekTagged$fFunctorkTagged $fOrdTagged $fEqTagged $fShowTagged $fOrdTagged0 $fEqTagged0 $fShowTagged0$fTraversableiTuple$fFoldablekTuple$fApplicativekTuple$fApplicativekTuple0$fFunctorkTuple $fOrdTuple $fOrdTuple0 $fEqTuple $fEqTuple0 $fShowTuple $fShowTuple0$fTraversableiPair$fFoldablekPair$fApplicativekPair$fFunctorkPair$fTraversableEitherCoproduct$fFoldableEitherCoproduct$fApplicativeEitherCoproduct$fFunctorEitherCoproduct$fTraversable(,)Product$fFoldable(,)Product$fApplicative(,)Product$fFunctor(,)Product$fTraversableCoyoneda$fFoldableCoyoneda$fApplicativeCoyoneda$fFunctorCoyoneda$fTraversableiDispose$fFoldablekDispose$fApplicativekDispose$fFunctorkDispose $fShowDispose $fEqDispose $fOrdDispose $fShowPair$fEqPair $fOrdPair $fShowFlip$fEqFlip $fOrdFlip $fShowPure$fEqPure $fOrdPure $fOrdUncurry $fEqUncurry $fShowUncurry $fOrdCurry $fEqCurry $fShowCurry$fOrdCoproduct $fEqCoproduct$fShowCoproduct $fOrdProduct $fEqProduct $fShowProductbaseGHC.Base Data.TupleuncurrycurryflipData.Traversable Data.Foldable Data.FunctorCompose2 getCompose2Curry2 getCurry2BothExists