Conkin

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.

Documentation

class Functor f where

A functor from Hask^k to Hask, an analogue of Functor for kind (k -> *) -> *

Minimal complete definition

fmap

Methods

fmap :: (forall x. a x -> b x) -> f a -> f b

Instances

Functor k (Pure k x)

Methods

fmap :: (forall a. a a -> b a) -> f a -> f b

Functor k (Const (k -> *) a)

Methods

fmap :: (forall x. a x -> b x) -> f a -> f b

Functor k (Tagged k xs)

Methods

fmap :: (forall x. a x -> b x) -> f a -> f b

Functor k (Tuple k xs)

Methods

fmap :: (forall x. a x -> b x) -> f a -> f b

Functor k (Pair k x0 x1)

Methods

fmap :: (forall x. a x -> b x) -> f a -> f b

Functor f => Functor k (Dispose k f x)

Methods

fmap :: (forall a. a a -> b a) -> f a -> f b

(Functor f, Functor k g) => Functor k (Compose (k -> *) * f g)

Methods

fmap :: (forall x. a x -> b x) -> f a -> f b

(Functor i f, Functor j g) => Functor (Either i j) (Coproduct j i f g)

Methods

fmap :: (forall x. a x -> b x) -> f a -> f b

(Functor i f, Functor j g) => Functor (i, j) (Product j i f g)

Methods

fmap :: (forall x. a x -> b x) -> f a -> f b

(<$>) :: Functor f => (forall x. a x -> b x) -> f a -> f b infixl 4

An analogue of <$> for use with Conkin's Functor

class Functor f => Applicative f where

An analogue of Applicative for kind (k -> *) -> *

Minimal complete definition

pure, (<*>)

Methods

pure :: (forall x. a x) -> f a

(<*>) :: f (a ~> b) -> f a -> f b infixl 4

Instances

Applicative k (Pure k x)

Methods

pure :: (forall a. a a) -> f a

(<*>) :: f ((Pure k x ~> a) b) -> f a -> f b

Monoid m => Applicative k (Const (k -> *) m)

Methods

pure :: (forall x. a x) -> f a

(<*>) :: f ((Const (k -> *) m ~> a) b) -> f a -> f b

Applicative k (Tuple k xs) => Applicative k (Tuple k ((:) k x xs))

Methods

pure :: (forall a. a a) -> f a

(<*>) :: f ((Tuple k ((k ': x) xs) ~> a) b) -> f a -> f b

Applicative k (Tuple k ([] k))

Methods

pure :: (forall x. a x) -> f a

(<*>) :: f ((Tuple k [k] ~> a) b) -> f a -> f b

Applicative k (Pair k x0 x1)

Methods

pure :: (forall x. a x) -> f a

(<*>) :: f ((Pair k x0 x1 ~> a) b) -> f a -> f b

Applicative f => Applicative k (Dispose k f x)

Methods

pure :: (forall a. a a) -> f a

(<*>) :: f ((Dispose k f x ~> a) b) -> f a -> f b

(Applicative f, Applicative k g) => Applicative k (Compose (k -> *) * f g)

Methods

pure :: (forall x. a x) -> f a

(<*>) :: f ((Compose (k -> *) * f g ~> a) b) -> f a -> f b

(Applicative i f, Applicative j g) => Applicative (Either i j) (Coproduct j i f g)

Methods

pure :: (forall x. a x) -> f a

(<*>) :: f ((Coproduct j i f g ~> a) b) -> f a -> f b

(Applicative i f, Applicative j g) => Applicative (i, j) (Product j i f g)

Methods

pure :: (forall x. a x) -> f a

(<*>) :: f ((Product j i f g ~> a) b) -> f a -> f b

newtype (a ~> b) x infixr 0

arrows in Hask^k have type a ~> b :: k -> *

Constructors

Arrow

Fields

• (~$~) :: a x -> b x

liftA2 :: Applicative f => (forall x. a x -> b x -> c x) -> f a -> f b -> f c

An analogue of liftA2 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 analogue of liftA3 for use with Conkin's Applicative

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 extension of liftA3 to functions of four arguments

class Foldable t where

An analogue of Foldable for kind (k -> *) -> *

Minimal complete definition

foldr | foldMap

Methods

foldr :: (forall x. a x -> b -> b) -> b -> t a -> b

foldMap :: Monoid m => (forall x. a x -> m) -> t a -> m

Instances

Foldable k (Pure k x)

Methods

foldr :: (forall a. a a -> b -> b) -> b -> t a -> b

foldMap :: Monoid m => (forall a. a a -> m) -> t a -> m

Foldable k (Const (k -> *) m)

Methods

foldr :: (forall x. a x -> b -> b) -> b -> t a -> b

foldMap :: Monoid m => (forall x. a x -> m) -> t a -> m

Foldable k (Tagged k xs)

Methods

foldr :: (forall x. a x -> b -> b) -> b -> t a -> b

foldMap :: Monoid m => (forall x. a x -> m) -> t a -> m

Foldable k (Tuple k xs)

Methods

foldr :: (forall x. a x -> b -> b) -> b -> t a -> b

foldMap :: Monoid m => (forall x. a x -> m) -> t a -> m

Foldable k (Pair k x0 x1)

Methods

foldr :: (forall x. a x -> b -> b) -> b -> t a -> b

foldMap :: Monoid m => (forall x. a x -> m) -> t a -> m

Foldable t => Foldable k (Dispose k t x)

Methods

foldr :: (forall a. a a -> b -> b) -> b -> t a -> b

foldMap :: Monoid m => (forall a. a a -> m) -> t a -> m

(Foldable f, Foldable k g) => Foldable k (Compose (k -> *) * f g)

Methods

foldr :: (forall x. a x -> b -> b) -> b -> t a -> b

foldMap :: Monoid m => (forall x. a x -> m) -> t a -> m

(Foldable i f, Foldable j g) => Foldable (Either i j) (Coproduct j i f g)

Methods

foldr :: (forall x. a x -> b -> b) -> b -> t a -> b

foldMap :: Monoid m => (forall x. a x -> m) -> t a -> m

(Foldable i f, Foldable j g) => Foldable (i, j) (Product j i f g)

Methods

foldr :: (forall x. a x -> b -> b) -> b -> t a -> b

foldMap :: Monoid m => (forall x. a x -> m) -> t a -> m

class (Foldable t, Functor t) => Traversable t where

An analogue of Traversable for kind (k -> *) -> *

Minimal complete definition

traverse | sequenceA

Methods

traverse :: forall f a b. Applicative f => (forall x. a x -> f (b x)) -> t a -> f (Compose t (Flip b))

sequenceA :: forall f a. Applicative f => t (Compose f a) -> f (Compose t (Flip a))

Instances

Traversable i (Pure i x)

Methods

traverse :: Applicative j f => (forall a. a a -> f (b a)) -> t a -> f (Compose j (Pure i x -> *) t (Flip j (Pure i x) b))

sequenceA :: Applicative j f => t (Compose (Pure i x) (j -> *) f a) -> f (Compose j (Pure i x -> *) t (Flip j (Pure i x) a))

Traversable i (Const (i -> *) m)

Methods

traverse :: Applicative j f => (forall x. a x -> f (b x)) -> t a -> f (Compose j (Const (i -> *) m -> *) t (Flip j (Const (i -> *) m) b))

sequenceA :: Applicative j f => t (Compose (Const (i -> *) m) (j -> *) f a) -> f (Compose j (Const (i -> *) m -> *) t (Flip j (Const (i -> *) m) a))

Traversable i (Tagged i xs)

Methods

traverse :: Applicative j f => (forall x. a x -> f (b x)) -> t a -> f (Compose j (Tagged i xs -> *) t (Flip j (Tagged i xs) b))

sequenceA :: Applicative j f => t (Compose (Tagged i xs) (j -> *) f a) -> f (Compose j (Tagged i xs -> *) t (Flip j (Tagged i xs) a))

Traversable i (Tuple i xs)

Methods

traverse :: Applicative j f => (forall x. a x -> f (b x)) -> t a -> f (Compose j (Tuple i xs -> *) t (Flip j (Tuple i xs) b))

sequenceA :: Applicative j f => t (Compose (Tuple i xs) (j -> *) f a) -> f (Compose j (Tuple i xs -> *) t (Flip j (Tuple i xs) a))

Traversable i (Pair i x0 x1)

Methods

traverse :: Applicative j f => (forall x. a x -> f (b x)) -> t a -> f (Compose j (Pair i x0 x1 -> *) t (Flip j (Pair i x0 x1) b))

sequenceA :: Applicative j f => t (Compose (Pair i x0 x1) (j -> *) f a) -> f (Compose j (Pair i x0 x1 -> *) t (Flip j (Pair i x0 x1) a))

Traversable t => Traversable i (Dispose i t x)

Methods

traverse :: Applicative j f => (forall a. a a -> f (b a)) -> t a -> f (Compose j (Dispose i t x -> *) t (Flip j (Dispose i t x) b))

sequenceA :: Applicative j f => t (Compose (Dispose i t x) (j -> *) f a) -> f (Compose j (Dispose i t x -> *) t (Flip j (Dispose i t x) a))

(Traversable f, Traversable i g) => Traversable i (Compose (i -> *) * f g)

Methods

traverse :: Applicative j f => (forall x. a x -> f (b x)) -> t a -> f (Compose j (Compose (i -> *) * f g -> *) t (Flip j (Compose (i -> *) * f g) b))

sequenceA :: Applicative j f => t (Compose (Compose (i -> *) * f g) (j -> *) f a) -> f (Compose j (Compose (i -> *) * f g -> *) t (Flip j (Compose (i -> *) * f g) a))

(Traversable i f, Traversable j g) => Traversable (Either i j) (Coproduct j i f g)

Methods

traverse :: Applicative j f => (forall x. a x -> f (b x)) -> t a -> f (Compose j (Coproduct j i f g -> *) t (Flip j (Coproduct j i f g) b))

sequenceA :: Applicative j f => t (Compose (Coproduct j i f g) (j -> *) f a) -> f (Compose j (Coproduct j i f g -> *) t (Flip j (Coproduct j i f g) a))

(Traversable i f, Traversable j g) => Traversable (i, j) (Product j i f g)

Methods

traverse :: Applicative j f => (forall x. a x -> f (b x)) -> t a -> f (Compose j (Product j i f g -> *) t (Flip j (Product j i f g) b))

sequenceA :: Applicative j f => t (Compose (Product j i f g) (j -> *) f a) -> f (Compose j (Product j i f g -> *) t (Flip j (Product j i f g) a))

traverse' :: (Traversable t, Applicative f) => (forall x. a x -> f (Flip b x)) -> t a -> f (Compose t b)

version of traverse that unflips the inner type

sequenceA' :: (Traversable t, Applicative f) => t (Compose f (Flip a)) -> f (Compose t a)

version of sequenceA that unflips the inner type

liftT1 :: Applicative g => (forall h. h w -> f h) -> Compose g a w -> g (Compose f (Flip 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
:}

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 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
:}

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 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
:}

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))

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
:}

align :: (Traversable f, Applicative g) => f (g Identity) -> g f

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 ] ) }

apportion :: (Applicative f, Traversable g) => g f -> f (g Identity)

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 ) }
      ]
  }

newtype Dispose f x a

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.

Constructors

Dispose

Fields

• getDispose :: f (a x)

Instances

Traversable t => Traversable i (Dispose i t x)

Methods

traverse :: Applicative j f => (forall a. a a -> f (b a)) -> t a -> f (Compose j (Dispose i t x -> *) t (Flip j (Dispose i t x) b))

sequenceA :: Applicative j f => t (Compose (Dispose i t x) (j -> *) f a) -> f (Compose j (Dispose i t x -> *) t (Flip j (Dispose i t x) a))

Foldable t => Foldable k (Dispose k t x)

Methods

foldr :: (forall a. a a -> b -> b) -> b -> t a -> b

foldMap :: Monoid m => (forall a. a a -> m) -> t a -> m

Applicative f => Applicative k (Dispose k f x)

Methods

pure :: (forall a. a a) -> f a

(<*>) :: f ((Dispose k f x ~> a) b) -> f a -> f b

Functor f => Functor k (Dispose k f x)

Methods

fmap :: (forall a. a a -> b a) -> f a -> f b

Eq (f (a x)) => Eq (Dispose k f x a)

Methods

(==) :: Dispose k f x a -> Dispose k f x a -> Bool

(/=) :: Dispose k f x a -> Dispose k f x a -> Bool

Ord (f (a x)) => Ord (Dispose k f x a)

Methods

compare :: Dispose k f x a -> Dispose k f x a -> Ordering

(<) :: Dispose k f x a -> Dispose k f x a -> Bool

(<=) :: Dispose k f x a -> Dispose k f x a -> Bool

(>) :: Dispose k f x a -> Dispose k f x a -> Bool

(>=) :: Dispose k f x a -> Dispose k f x a -> Bool

max :: Dispose k f x a -> Dispose k f x a -> Dispose k f x a

min :: Dispose k f x a -> Dispose k f x a -> Dispose k f x a

Show (f (a x)) => Show (Dispose k f x a)

Methods

showsPrec :: Int -> Dispose k f x a -> ShowS

show :: Dispose k f x a -> String

showList :: [Dispose k f x a] -> ShowS

data Coyoneda t u where

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.

Constructors

Coyoneda :: (forall x. a x -> u) -> t a -> Coyoneda t u

Instances

Functor (Coyoneda k t)

Methods

fmap :: (a -> b) -> Coyoneda k t a -> Coyoneda k t b

(<$) :: a -> Coyoneda k t b -> Coyoneda k t a

Applicative k t => Applicative (Coyoneda k t)

Methods

pure :: a -> Coyoneda k t a

(<*>) :: Coyoneda k t (a -> b) -> Coyoneda k t a -> Coyoneda k t b

(*>) :: Coyoneda k t a -> Coyoneda k t b -> Coyoneda k t b

(<*) :: Coyoneda k t a -> Coyoneda k t b -> Coyoneda k t a

Foldable k t => Foldable (Coyoneda k t)

Methods

fold :: Monoid m => Coyoneda k t m -> m

foldMap :: Monoid m => (a -> m) -> Coyoneda k t a -> m

foldr :: (a -> b -> b) -> b -> Coyoneda k t a -> b

foldr' :: (a -> b -> b) -> b -> Coyoneda k t a -> b

foldl :: (b -> a -> b) -> b -> Coyoneda k t a -> b

foldl' :: (b -> a -> b) -> b -> Coyoneda k t a -> b

foldr1 :: (a -> a -> a) -> Coyoneda k t a -> a

foldl1 :: (a -> a -> a) -> Coyoneda k t a -> a

toList :: Coyoneda k t a -> [a]

null :: Coyoneda k t a -> Bool

length :: Coyoneda k t a -> Int

elem :: Eq a => a -> Coyoneda k t a -> Bool

maximum :: Ord a => Coyoneda k t a -> a

minimum :: Ord a => Coyoneda k t a -> a

sum :: Num a => Coyoneda k t a -> a

product :: Num a => Coyoneda k t a -> a

Traversable k t => Traversable (Coyoneda k t)

Methods

traverse :: Applicative f => (a -> f b) -> Coyoneda k t a -> f (Coyoneda k t b)

sequenceA :: Applicative f => Coyoneda k t (f a) -> f (Coyoneda k t a)

mapM :: Monad m => (a -> m b) -> Coyoneda k t a -> m (Coyoneda k t b)

sequence :: Monad m => Coyoneda k t (m a) -> m (Coyoneda k t a)

getCoyoneda :: Functor t => Coyoneda t a -> t (Const a)

convert a functor from its Coyoneda representation

toCoyoneda :: t (Const a) -> Coyoneda t a

convert a functor to its Coyoneda representation

newtype Product f g 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

Constructors

Product

Fields

• getProduct :: f (Compose g (Curry a))

Instances

(Traversable i f, Traversable j g) => Traversable (i, j) (Product j i f g)

Methods

traverse :: Applicative j f => (forall x. a x -> f (b x)) -> t a -> f (Compose j (Product j i f g -> *) t (Flip j (Product j i f g) b))

sequenceA :: Applicative j f => t (Compose (Product j i f g) (j -> *) f a) -> f (Compose j (Product j i f g -> *) t (Flip j (Product j i f g) a))

(Foldable i f, Foldable j g) => Foldable (i, j) (Product j i f g)

Methods

foldr :: (forall x. a x -> b -> b) -> b -> t a -> b

foldMap :: Monoid m => (forall x. a x -> m) -> t a -> m

(Applicative i f, Applicative j g) => Applicative (i, j) (Product j i f g)

Methods

pure :: (forall x. a x) -> f a

(<*>) :: f ((Product j i f g ~> a) b) -> f a -> f b

(Functor i f, Functor j g) => Functor (i, j) (Product j i f g)

Methods

fmap :: (forall x. a x -> b x) -> f a -> f b

Eq (f (Compose i (j -> *) g (Curry i j a))) => Eq (Product j i f g a)

Methods

(==) :: Product j i f g a -> Product j i f g a -> Bool

(/=) :: Product j i f g a -> Product j i f g a -> Bool

Ord (f (Compose i (j -> *) g (Curry i j a))) => Ord (Product j i f g a)

Methods

compare :: Product j i f g a -> Product j i f g a -> Ordering

(<) :: Product j i f g a -> Product j i f g a -> Bool

(<=) :: Product j i f g a -> Product j i f g a -> Bool

(>) :: Product j i f g a -> Product j i f g a -> Bool

(>=) :: Product j i f g a -> Product j i f g a -> Bool

max :: Product j i f g a -> Product j i f g a -> Product j i f g a

min :: Product j i f g a -> Product j i f g a -> Product j i f g a

Show (f (Compose i (j -> *) g (Curry i j a))) => Show (Product j i f g a)

Methods

showsPrec :: Int -> Product j i f g a -> ShowS

show :: Product j i f g a -> String

showList :: [Product j i f g a] -> ShowS

toProduct :: (Functor f, Functor g) => (forall x y. a x y -> b '(x, y)) -> f (Compose g a) -> Product f g b

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 (,))

fromProduct :: (Functor f, Functor g) => (forall x y. b '(x, y) -> a x y) -> Product f g b -> f (Compose g a)

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) (,))

newtype Coproduct f 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

Constructors

Coproduct

Fields

• getCoproduct :: (f (Compose a Left), g (Compose a Right))

Instances

(Traversable i f, Traversable j g) => Traversable (Either i j) (Coproduct j i f g)

Methods

traverse :: Applicative j f => (forall x. a x -> f (b x)) -> t a -> f (Compose j (Coproduct j i f g -> *) t (Flip j (Coproduct j i f g) b))

sequenceA :: Applicative j f => t (Compose (Coproduct j i f g) (j -> *) f a) -> f (Compose j (Coproduct j i f g -> *) t (Flip j (Coproduct j i f g) a))

(Foldable i f, Foldable j g) => Foldable (Either i j) (Coproduct j i f g)

Methods

foldr :: (forall x. a x -> b -> b) -> b -> t a -> b

foldMap :: Monoid m => (forall x. a x -> m) -> t a -> m

(Applicative i f, Applicative j g) => Applicative (Either i j) (Coproduct j i f g)

Methods

pure :: (forall x. a x) -> f a

(<*>) :: f ((Coproduct j i f g ~> a) b) -> f a -> f b

(Functor i f, Functor j g) => Functor (Either i j) (Coproduct j i f g)

Methods

fmap :: (forall x. a x -> b x) -> f a -> f b

(Eq (f (Compose i (Either i j) a (Left i j))), Eq (g (Compose j (Either i j) a (Right i j)))) => Eq (Coproduct j i f g a)

Methods

(==) :: Coproduct j i f g a -> Coproduct j i f g a -> Bool

(/=) :: Coproduct j i f g a -> Coproduct j i f g a -> Bool

(Ord (f (Compose i (Either i j) a (Left i j))), Ord (g (Compose j (Either i j) a (Right i j)))) => Ord (Coproduct j i f g a)

Methods

compare :: Coproduct j i f g a -> Coproduct j i f g a -> Ordering

(<) :: Coproduct j i f g a -> Coproduct j i f g a -> Bool

(<=) :: Coproduct j i f g a -> Coproduct j i f g a -> Bool

(>) :: Coproduct j i f g a -> Coproduct j i f g a -> Bool

(>=) :: Coproduct j i f g a -> Coproduct j i f g a -> Bool

max :: Coproduct j i f g a -> Coproduct j i f g a -> Coproduct j i f g a

min :: Coproduct j i f g a -> Coproduct j i f g a -> Coproduct j i f g a

(Show (f (Compose i (Either i j) a (Left i j))), Show (g (Compose j (Either i j) a (Right i j)))) => Show (Coproduct j i f g a)

Methods

showsPrec :: Int -> Coproduct j i f g a -> ShowS

show :: Coproduct j i f g a -> String

showList :: [Coproduct j i f g a] -> ShowS

newtype Pair x0 x1 a

A continuation kind functor for pairs.

>>> :t Pair (Identity True, Identity 'a')
Pair (Identity True, Identity 'a') :: Pair Bool Char Identity

Constructors

Pair

Fields

• getPair :: (a x0, a x1)

Instances

Traversable i (Pair i x0 x1)

Methods

traverse :: Applicative j f => (forall x. a x -> f (b x)) -> t a -> f (Compose j (Pair i x0 x1 -> *) t (Flip j (Pair i x0 x1) b))

sequenceA :: Applicative j f => t (Compose (Pair i x0 x1) (j -> *) f a) -> f (Compose j (Pair i x0 x1 -> *) t (Flip j (Pair i x0 x1) a))

Foldable k (Pair k x0 x1)

Methods

foldr :: (forall x. a x -> b -> b) -> b -> t a -> b

foldMap :: Monoid m => (forall x. a x -> m) -> t a -> m

Applicative k (Pair k x0 x1)

Methods

pure :: (forall x. a x) -> f a

(<*>) :: f ((Pair k x0 x1 ~> a) b) -> f a -> f b

Functor k (Pair k x0 x1)

Methods

fmap :: (forall x. a x -> b x) -> f a -> f b

(Eq (a x1), Eq (a x0)) => Eq (Pair k x0 x1 a)

Methods

(==) :: Pair k x0 x1 a -> Pair k x0 x1 a -> Bool

(/=) :: Pair k x0 x1 a -> Pair k x0 x1 a -> Bool

(Ord (a x1), Ord (a x0)) => Ord (Pair k x0 x1 a)

Methods

compare :: Pair k x0 x1 a -> Pair k x0 x1 a -> Ordering

(<) :: Pair k x0 x1 a -> Pair k x0 x1 a -> Bool

(<=) :: Pair k x0 x1 a -> Pair k x0 x1 a -> Bool

(>) :: Pair k x0 x1 a -> Pair k x0 x1 a -> Bool

(>=) :: Pair k x0 x1 a -> Pair k x0 x1 a -> Bool

max :: Pair k x0 x1 a -> Pair k x0 x1 a -> Pair k x0 x1 a

min :: Pair k x0 x1 a -> Pair k x0 x1 a -> Pair k x0 x1 a

(Show (a x1), Show (a x0)) => Show (Pair k x0 x1 a)

Methods

showsPrec :: Int -> Pair k x0 x1 a -> ShowS

show :: Pair k x0 x1 a -> String

showList :: [Pair k x0 x1 a] -> ShowS

data Tuple xs a where

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

Constructors

Nil :: Tuple '[] a

Cons :: a x -> !(Tuple xs a) -> Tuple (x ': xs) a infixr 5

Instances

Traversable i (Tuple i xs)

Methods

traverse :: Applicative j f => (forall x. a x -> f (b x)) -> t a -> f (Compose j (Tuple i xs -> *) t (Flip j (Tuple i xs) b))

sequenceA :: Applicative j f => t (Compose (Tuple i xs) (j -> *) f a) -> f (Compose j (Tuple i xs -> *) t (Flip j (Tuple i xs) a))

Foldable k (Tuple k xs)

Methods

foldr :: (forall x. a x -> b -> b) -> b -> t a -> b

foldMap :: Monoid m => (forall x. a x -> m) -> t a -> m

Applicative k (Tuple k xs) => Applicative k (Tuple k ((:) k x xs))

Methods

pure :: (forall a. a a) -> f a

(<*>) :: f ((Tuple k ((k ': x) xs) ~> a) b) -> f a -> f b

Applicative k (Tuple k ([] k))

Methods

pure :: (forall x. a x) -> f a

(<*>) :: f ((Tuple k [k] ~> a) b) -> f a -> f b

Functor k (Tuple k xs)

Methods

fmap :: (forall x. a x -> b x) -> f a -> f b

(Eq (a x), Eq (Tuple k xs a)) => Eq (Tuple k ((:) k x xs) a)

Methods

(==) :: Tuple k ((k ': x) xs) a -> Tuple k ((k ': x) xs) a -> Bool

(/=) :: Tuple k ((k ': x) xs) a -> Tuple k ((k ': x) xs) a -> Bool

Eq (Tuple k ([] k) a)

Methods

(==) :: Tuple k [k] a -> Tuple k [k] a -> Bool

(/=) :: Tuple k [k] a -> Tuple k [k] a -> Bool

(Ord (a x), Ord (Tuple k xs a)) => Ord (Tuple k ((:) k x xs) a)

Methods

compare :: Tuple k ((k ': x) xs) a -> Tuple k ((k ': x) xs) a -> Ordering

(<) :: Tuple k ((k ': x) xs) a -> Tuple k ((k ': x) xs) a -> Bool

(<=) :: Tuple k ((k ': x) xs) a -> Tuple k ((k ': x) xs) a -> Bool

(>) :: Tuple k ((k ': x) xs) a -> Tuple k ((k ': x) xs) a -> Bool

(>=) :: Tuple k ((k ': x) xs) a -> Tuple k ((k ': x) xs) a -> Bool

max :: Tuple k ((k ': x) xs) a -> Tuple k ((k ': x) xs) a -> Tuple k ((k ': x) xs) a

min :: Tuple k ((k ': x) xs) a -> Tuple k ((k ': x) xs) a -> Tuple k ((k ': x) xs) a

Ord (Tuple k ([] k) a)

Methods

compare :: Tuple k [k] a -> Tuple k [k] a -> Ordering

(<) :: Tuple k [k] a -> Tuple k [k] a -> Bool

(<=) :: Tuple k [k] a -> Tuple k [k] a -> Bool

(>) :: Tuple k [k] a -> Tuple k [k] a -> Bool

(>=) :: Tuple k [k] a -> Tuple k [k] a -> Bool

max :: Tuple k [k] a -> Tuple k [k] a -> Tuple k [k] a

min :: Tuple k [k] a -> Tuple k [k] a -> Tuple k [k] a

(Show (a x), Show (Tuple k xs a)) => Show (Tuple k ((:) k x xs) a)

Methods

showsPrec :: Int -> Tuple k ((k ': x) xs) a -> ShowS

show :: Tuple k ((k ': x) xs) a -> String

showList :: [Tuple k ((k ': x) xs) a] -> ShowS

Show (Tuple k ([] k) a)

Methods

showsPrec :: Int -> Tuple k [k] a -> ShowS

show :: Tuple k [k] a -> String

showList :: [Tuple k [k] a] -> ShowS

data Tagged xs a where

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]

Constructors

Here :: a x -> Tagged (x ': xs) a

There :: !(Tagged xs a) -> Tagged (x ': xs) a

Instances

Traversable i (Tagged i xs)

Methods

traverse :: Applicative j f => (forall x. a x -> f (b x)) -> t a -> f (Compose j (Tagged i xs -> *) t (Flip j (Tagged i xs) b))

sequenceA :: Applicative j f => t (Compose (Tagged i xs) (j -> *) f a) -> f (Compose j (Tagged i xs -> *) t (Flip j (Tagged i xs) a))

Foldable k (Tagged k xs)

Methods

foldr :: (forall x. a x -> b -> b) -> b -> t a -> b

foldMap :: Monoid m => (forall x. a x -> m) -> t a -> m

Functor k (Tagged k xs)

Methods

fmap :: (forall x. a x -> b x) -> f a -> f b

(Eq (a x), Eq (Tagged k xs a)) => Eq (Tagged k ((:) k x xs) a)

Methods

(==) :: Tagged k ((k ': x) xs) a -> Tagged k ((k ': x) xs) a -> Bool

(/=) :: Tagged k ((k ': x) xs) a -> Tagged k ((k ': x) xs) a -> Bool

Eq (Tagged k ([] k) a)

Methods

(==) :: Tagged k [k] a -> Tagged k [k] a -> Bool

(/=) :: Tagged k [k] a -> Tagged k [k] a -> Bool

(Ord (a x), Ord (Tagged k xs a)) => Ord (Tagged k ((:) k x xs) a)

Methods

compare :: Tagged k ((k ': x) xs) a -> Tagged k ((k ': x) xs) a -> Ordering

(<) :: Tagged k ((k ': x) xs) a -> Tagged k ((k ': x) xs) a -> Bool

(<=) :: Tagged k ((k ': x) xs) a -> Tagged k ((k ': x) xs) a -> Bool

(>) :: Tagged k ((k ': x) xs) a -> Tagged k ((k ': x) xs) a -> Bool

(>=) :: Tagged k ((k ': x) xs) a -> Tagged k ((k ': x) xs) a -> Bool

max :: Tagged k ((k ': x) xs) a -> Tagged k ((k ': x) xs) a -> Tagged k ((k ': x) xs) a

min :: Tagged k ((k ': x) xs) a -> Tagged k ((k ': x) xs) a -> Tagged k ((k ': x) xs) a

Ord (Tagged k ([] k) a)

Methods

compare :: Tagged k [k] a -> Tagged k [k] a -> Ordering

(<) :: Tagged k [k] a -> Tagged k [k] a -> Bool

(<=) :: Tagged k [k] a -> Tagged k [k] a -> Bool

(>) :: Tagged k [k] a -> Tagged k [k] a -> Bool

(>=) :: Tagged k [k] a -> Tagged k [k] a -> Bool

max :: Tagged k [k] a -> Tagged k [k] a -> Tagged k [k] a

min :: Tagged k [k] a -> Tagged k [k] a -> Tagged k [k] a

(Show (a x), Show (Tagged k xs a)) => Show (Tagged k ((:) k x xs) a)

Methods

showsPrec :: Int -> Tagged k ((k ': x) xs) a -> ShowS

show :: Tagged k ((k ': x) xs) a -> String

showList :: [Tagged k ((k ': x) xs) a] -> ShowS

Show (Tagged k ([] k) a)

Methods

showsPrec :: Int -> Tagged k [k] a -> ShowS

show :: Tagged k [k] a -> String

showList :: [Tagged k [k] a] -> ShowS

newtype Flip a y x

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

Constructors

Flip

Fields

• getFlip :: a x y

Instances

Eq (a x y) => Eq (Flip j i a y x)

Methods

(==) :: Flip j i a y x -> Flip j i a y x -> Bool

(/=) :: Flip j i a y x -> Flip j i a y x -> Bool

Ord (a x y) => Ord (Flip j i a y x)

Methods

compare :: Flip j i a y x -> Flip j i a y x -> Ordering

(<) :: Flip j i a y x -> Flip j i a y x -> Bool

(<=) :: Flip j i a y x -> Flip j i a y x -> Bool

(>) :: Flip j i a y x -> Flip j i a y x -> Bool

(>=) :: Flip j i a y x -> Flip j i a y x -> Bool

max :: Flip j i a y x -> Flip j i a y x -> Flip j i a y x

min :: Flip j i a y x -> Flip j i a y x -> Flip j i a y x

Show (a x y) => Show (Flip j i a y x)

Methods

showsPrec :: Int -> Flip j i a y x -> ShowS

show :: Flip j i a y x -> String

showList :: [Flip j i a y x] -> ShowS

newtype Curry 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 -> *

Constructors

Curry

Fields

• getCurry :: a '(x, y)

Instances

Eq (a ((,) i j x y)) => Eq (Curry i j a x y)

Methods

(==) :: Curry i j a x y -> Curry i j a x y -> Bool

(/=) :: Curry i j a x y -> Curry i j a x y -> Bool

Ord (a ((,) i j x y)) => Ord (Curry i j a x y)

Methods

compare :: Curry i j a x y -> Curry i j a x y -> Ordering

(<) :: Curry i j a x y -> Curry i j a x y -> Bool

(<=) :: Curry i j a x y -> Curry i j a x y -> Bool

(>) :: Curry i j a x y -> Curry i j a x y -> Bool

(>=) :: Curry i j a x y -> Curry i j a x y -> Bool

max :: Curry i j a x y -> Curry i j a x y -> Curry i j a x y

min :: Curry i j a x y -> Curry i j a x y -> Curry i j a x y

Show (a ((,) i j x y)) => Show (Curry i j a x y)

Methods

showsPrec :: Int -> Curry i j a x y -> ShowS

show :: Curry i j a x y -> String

showList :: [Curry i j a x y] -> ShowS

newtype Uncurry a z

A type-level version of uncurry, it's used to convert between types of kind i -> j -> * and types of kind (i,j) -> *.

Constructors

UncurryLazy

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
...

Fields

• getUncurryLazy :: forall x y. z ~ '(x, y) => a x y

Instances

Eq (a x y) => Eq (Uncurry k1 k a ((,) k k1 x y))

Methods

(==) :: Uncurry k1 k a ((k, k1) x y) -> Uncurry k1 k a ((k, k1) x y) -> Bool

(/=) :: Uncurry k1 k a ((k, k1) x y) -> Uncurry k1 k a ((k, k1) x y) -> Bool

Ord (a x y) => Ord (Uncurry k1 k a ((,) k k1 x y))

Methods

compare :: Uncurry k1 k a ((k, k1) x y) -> Uncurry k1 k a ((k, k1) x y) -> Ordering

(<) :: Uncurry k1 k a ((k, k1) x y) -> Uncurry k1 k a ((k, k1) x y) -> Bool

(<=) :: Uncurry k1 k a ((k, k1) x y) -> Uncurry k1 k a ((k, k1) x y) -> Bool

(>) :: Uncurry k1 k a ((k, k1) x y) -> Uncurry k1 k a ((k, k1) x y) -> Bool

(>=) :: Uncurry k1 k a ((k, k1) x y) -> Uncurry k1 k a ((k, k1) x y) -> Bool

max :: Uncurry k1 k a ((k, k1) x y) -> Uncurry k1 k a ((k, k1) x y) -> Uncurry k1 k a ((k, k1) x y)

min :: Uncurry k1 k a ((k, k1) x y) -> Uncurry k1 k a ((k, k1) x y) -> Uncurry k1 k a ((k, k1) x y)

Show (a x y) => Show (Uncurry k k1 a ((,) k1 k x y))

Methods

showsPrec :: Int -> Uncurry k k1 a ((k1, k) x y) -> ShowS

show :: Uncurry k k1 a ((k1, k) x y) -> String

showList :: [Uncurry k k1 a ((k1, k) x y)] -> ShowS

pattern UncurryStrict :: forall k k1 a x y. a x y -> Uncurry k k1 a ((,) k1 k 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.

getUncurryStrict :: Uncurry a '(x, y) -> a x y

a pseudo-record accessor, corresponding to matching the UncurryStrict pattern. Can be useful when paired with fromProduct

uncurried :: (forall x y. a x y -> b x y) -> Uncurry a z -> Uncurry b z

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 (->))

newtype Pure x a

A type-level version of pure for Cont

Mainly useful when constructing continuation kind functors using Product and Coproduct.

Constructors

Pure

Fields

• getPure :: a x

Instances

Traversable i (Pure i x)

Methods

traverse :: Applicative j f => (forall a. a a -> f (b a)) -> t a -> f (Compose j (Pure i x -> *) t (Flip j (Pure i x) b))

sequenceA :: Applicative j f => t (Compose (Pure i x) (j -> *) f a) -> f (Compose j (Pure i x -> *) t (Flip j (Pure i x) a))

Foldable k (Pure k x)

Methods

foldr :: (forall a. a a -> b -> b) -> b -> t a -> b

foldMap :: Monoid m => (forall a. a a -> m) -> t a -> m

Applicative k (Pure k x)

Methods

pure :: (forall a. a a) -> f a

(<*>) :: f ((Pure k x ~> a) b) -> f a -> f b

Functor k (Pure k x)

Methods

fmap :: (forall a. a a -> b a) -> f a -> f b

Eq (a x) => Eq (Pure k x a)

Methods

(==) :: Pure k x a -> Pure k x a -> Bool

(/=) :: Pure k x a -> Pure k x a -> Bool

Ord (a x) => Ord (Pure k x a)

Methods

compare :: Pure k x a -> Pure k x a -> Ordering

(<) :: Pure k x a -> Pure k x a -> Bool

(<=) :: Pure k x a -> Pure k x a -> Bool

(>) :: Pure k x a -> Pure k x a -> Bool

(>=) :: Pure k x a -> Pure k x a -> Bool

max :: Pure k x a -> Pure k x a -> Pure k x a

min :: Pure k x a -> Pure k x a -> Pure k x a

Show (a x) => Show (Pure k x a)

Methods

showsPrec :: Int -> Pure k x a -> ShowS

show :: Pure k x a -> String

showList :: [Pure k x a] -> ShowS