Categorical.Dual.Example

This should be tests, but if you look for the source of this module, you’ll see how to use the package.

Documentation

class Functor f => Coapplicative (f :: Type -> Type) where

This should get mapped to the newly created class … right?

Methods

extract :: forall (a :: Type). f a -> a

class Coapplicative m => Comonad (m :: Type -> Type) where

This should get mapped to the newly created class … right?

Methods

(=>>) :: forall (a :: Type) (b :: Type). m a -> m b -> m b -> a

class (Functor t, Functor t) => Distributive (t :: Type -> Type) where

Because Foldable is semi-dual to Functor (which isn’t safe), we end up with a duplicate Functor constraint here.

Methods

cotraverse :: forall (f :: Type -> Type) (a :: Type) (b :: Type). Coapplicative f => (f b -> a) -> f (t b) -> t a

distribute :: forall (f :: Type -> Type) (a :: Type). Coapplicative f => f (t a) -> t (f a)

consume :: (Traversable g, Applicative f) => (g b -> a) -> g (f b) -> f a

type Algebra f a = f a -> a

Sometimes the doc is mapped to the original.

type Coalgebra f a = a -> f a

type GAlgebra w f a = f (w a) -> a

Other times, to the dual.

type GCoalgebra w f a = a -> f (w a)

type ElgotAlgebra w f a = w (f a) -> a

I’m not sure why one or the other happens.

type ElgotCoalgebra w f a = a -> w (f a)

newtype NewEither a b

Constructors

NewEither (Either a b)

newtype NewTuple a b

Constructors

NewTuple ((,) a b)

data NewEither' a b

Constructors

NewEither' (Either a b)

data NewTuple' a b

Constructors

NewTuple' ((,) a b)

data family TestA a

I wonder if

data family DualA a

type family TestB a

This always

type family DualB a

type family TestC a where ...

Happens.

Equations

TestC (Either b c) = b

TestC Int = Char

type family DualC a where ...

Equations

DualC ((,) b c) = b

DualC Int = Char

(>^>) :: (a -> b) -> (b -> c) -> a -> c

(<^<) :: (b -> a) -> (c -> b) -> c -> a

These docs are going to end up on <^<, which is not what I’d expect.

data Mu f

Constructors

Mu (forall a. Algebra f a -> a)

data Nu f where

Constructors

Nu :: Coalgebra f a -> a -> Nu f

data Fix f

Constructors

Fix

Fields

• unfix :: f (Fix f)

cata :: Functor f => (f a -> a) -> Fix f -> a

ana :: Functor f => (a -> f a) -> a -> Fix f

Interestingly, the documentation for a dualized function definition is added to the dual, not the explicitly-defined name. I don’t know why this behaves differently than the other cases.

exampleDuals :: Q DualMappings

Duals for this module.