Data.Profunctor.Linear

This module provides profunctor classes and instances.

Please import this module qualified.

Some of the definitions in this module are heavily connected to and motivated by linear optics. Please see Control.Optics.Linear and other optics modules for motivations for the definitions provided here.

Connections to Linear Optics

• Strong and Wandering are classes drawn from this paper
• Exchange and Market are ways of encoding isomorphisms and prisms

Documentation

class Profunctor (arr :: Type -> Type -> Type) where

A Profunctor can be thought of as a computation that involves taking a(s) as input and returning b(s). These computations compose with (linear) functions. Profunctors generalize the function arrow ->.

Hence, think of a value of type x arr y for profunctor arr to be something like a function from x to y.

Laws:

lmap id = id
lmap (f . g) = lmap f . lmap g
rmap id = id
rmap (f . g) = rmap f . rmap g

Minimal complete definition

dimap | lmap, rmap

Methods

dimap :: (s %1 -> a) -> (b %1 -> t) -> (a `arr` b) -> s `arr` t

lmap :: (s %1 -> a) -> (a `arr` t) -> s `arr` t

rmap :: (b %1 -> t) -> (s `arr` b) -> s `arr` t

Instances

Functor f => Profunctor (Kleisli f)

Defined in Data.Profunctor.Linear

Methods

dimap :: (s %1 -> a) -> (b %1 -> t) -> Kleisli f a b -> Kleisli f s t

lmap :: (s %1 -> a) -> Kleisli f a t -> Kleisli f s t

rmap :: (b %1 -> t) -> Kleisli f s b -> Kleisli f s t

Functor f => Profunctor (CoKleisli f)

Defined in Data.Profunctor.Kleisli.Linear

Methods

dimap :: (s %1 -> a) -> (b %1 -> t) -> CoKleisli f a b -> CoKleisli f s t

lmap :: (s %1 -> a) -> CoKleisli f a t -> CoKleisli f s t

rmap :: (b %1 -> t) -> CoKleisli f s b -> CoKleisli f s t

Functor f => Profunctor (Kleisli f)

Defined in Data.Profunctor.Kleisli.Linear

Methods

dimap :: (s %1 -> a) -> (b %1 -> t) -> Kleisli f a b -> Kleisli f s t

lmap :: (s %1 -> a) -> Kleisli f a t -> Kleisli f s t

rmap :: (b %1 -> t) -> Kleisli f s b -> Kleisli f s t

Profunctor (Exchange a b)

Defined in Data.Profunctor.Linear

Methods

dimap :: (s %1 -> a0) -> (b0 %1 -> t) -> Exchange a b a0 b0 -> Exchange a b s t

lmap :: (s %1 -> a0) -> Exchange a b a0 t -> Exchange a b s t

rmap :: (b0 %1 -> t) -> Exchange a b s b0 -> Exchange a b s t

Profunctor (Market a b)

Defined in Data.Profunctor.Linear

Methods

dimap :: (s %1 -> a0) -> (b0 %1 -> t) -> Market a b a0 b0 -> Market a b s t

lmap :: (s %1 -> a0) -> Market a b a0 t -> Market a b s t

rmap :: (b0 %1 -> t) -> Market a b s b0 -> Market a b s t

Profunctor (->)

Defined in Data.Profunctor.Linear

Methods

dimap :: (s %1 -> a) -> (b %1 -> t) -> (a -> b) -> s -> t

lmap :: (s %1 -> a) -> (a -> t) -> s -> t

rmap :: (b %1 -> t) -> (s -> b) -> s -> t

Profunctor (FUN 'One :: TYPE LiftedRep -> TYPE LiftedRep -> Type)

Defined in Data.Profunctor.Linear

Methods

dimap :: (s %1 -> a) -> (b %1 -> t) -> FUN 'One a b -> FUN 'One s t

lmap :: (s %1 -> a) -> FUN 'One a t -> FUN 'One s t

rmap :: (b %1 -> t) -> FUN 'One s b -> FUN 'One s t

class (SymmetricMonoidal m u, Profunctor arr) => Monoidal m u arr where

A (Monoidal m u arr) is a profunctor arr that can be sequenced with the bifunctor m. In rough terms, you can combine two function-like things to one function-like thing that holds both input and output types with the bifunctor m.

Methods

(***) :: (a `arr` b) -> (x `arr` y) -> (a `m` x) `arr` (b `m` y) infixr 3

unit :: u `arr` u

Instances

Functor f => Monoidal Either Void (Kleisli f)

Defined in Data.Profunctor.Linear

Methods

(***) :: Kleisli f a b -> Kleisli f x y -> Kleisli f (Either a x) (Either b y)

unit :: Kleisli f Void Void

Functor f => Monoidal Either Void (Kleisli f)

Defined in Data.Profunctor.Kleisli.Linear

Methods

(***) :: Kleisli f a b -> Kleisli f x y -> Kleisli f (Either a x) (Either b y)

unit :: Kleisli f Void Void

Applicative f => Monoidal (,) () (Kleisli f)

Defined in Data.Profunctor.Linear

Methods

(***) :: Kleisli f a b -> Kleisli f x y -> Kleisli f (a, x) (b, y)

unit :: Kleisli f () ()

Applicative f => Monoidal (,) () (Kleisli f)

Defined in Data.Profunctor.Kleisli.Linear

Methods

(***) :: Kleisli f a b -> Kleisli f x y -> Kleisli f (a, x) (b, y)

unit :: Kleisli f () ()

Monoidal Either Void (->)

Defined in Data.Profunctor.Linear

Methods

(***) :: (a -> b) -> (x -> y) -> Either a x -> Either b y

unit :: Void -> Void

Monoidal (,) () (->)

Defined in Data.Profunctor.Linear

Methods

(***) :: (a -> b) -> (x -> y) -> (a, x) -> (b, y)

unit :: () -> ()

Monoidal Either Void (FUN 'One :: TYPE LiftedRep -> TYPE LiftedRep -> Type)

Defined in Data.Profunctor.Linear

Methods

(***) :: FUN 'One a b -> FUN 'One x y -> FUN 'One (Either a x) (Either b y)

unit :: FUN 'One Void Void

Monoidal (,) () (FUN 'One :: TYPE LiftedRep -> TYPE LiftedRep -> Type)

Defined in Data.Profunctor.Linear

Methods

(***) :: FUN 'One a b -> FUN 'One x y -> FUN 'One (a, x) (b, y)

unit :: FUN 'One () ()

class (SymmetricMonoidal m u, Profunctor arr) => Strong m u arr where

A (Strong m u arr) instance means that the function-like thing of type a arr b can be extended to pass along a value of type c as a constant via the bifunctor of type m.

This typeclass is used primarily to generalize common patterns and instances that are defined when defining optics. The two uses below are used in defining lenses and prisms respectively in Control.Optics.Linear.Internal:

If m is the tuple type constructor (,) then we can create a function-like thing of type (a,c) arr (b,c) passing along c as a constant.

If m is Either then we can create a function-like thing of type Either a c arr Either b c that either does the original function or behaves like the constant function.

Minimal complete definition

first | second

Methods

first :: (a `arr` b) -> (a `m` c) `arr` (b `m` c)

second :: (b `arr` c) -> (a `m` b) `arr` (a `m` c)

Instances

Applicative f => Strong Either Void (Kleisli f)

Defined in Data.Profunctor.Linear

Methods

first :: Kleisli f a b -> Kleisli f (Either a c) (Either b c)

second :: Kleisli f b c -> Kleisli f (Either a b) (Either a c)

Strong Either Void (CoKleisli (Const x :: Type -> Type))

Defined in Data.Profunctor.Kleisli.Linear

Methods

first :: CoKleisli (Const x) a b -> CoKleisli (Const x) (Either a c) (Either b c)

second :: CoKleisli (Const x) b c -> CoKleisli (Const x) (Either a b) (Either a c)

Applicative f => Strong Either Void (Kleisli f)

Defined in Data.Profunctor.Kleisli.Linear

Methods

first :: Kleisli f a b -> Kleisli f (Either a c) (Either b c)

second :: Kleisli f b c -> Kleisli f (Either a b) (Either a c)

Functor f => Strong (,) () (Kleisli f)

Defined in Data.Profunctor.Linear

Methods

first :: Kleisli f a b -> Kleisli f (a, c) (b, c)

second :: Kleisli f b c -> Kleisli f (a, b) (a, c)

Functor f => Strong (,) () (Kleisli f)

Defined in Data.Profunctor.Kleisli.Linear

Methods

first :: Kleisli f a b -> Kleisli f (a, c) (b, c)

second :: Kleisli f b c -> Kleisli f (a, b) (a, c)

Strong Either Void (Market a b)

Defined in Data.Profunctor.Linear

Methods

first :: Market a b a0 b0 -> Market a b (Either a0 c) (Either b0 c)

second :: Market a b b0 c -> Market a b (Either a0 b0) (Either a0 c)

Strong Either Void (->)

Defined in Data.Profunctor.Linear

Methods

first :: (a -> b) -> Either a c -> Either b c

second :: (b -> c) -> Either a b -> Either a c

Strong (,) () (->)

Defined in Data.Profunctor.Linear

Methods

first :: (a -> b) -> (a, c) -> (b, c)

second :: (b -> c) -> (a, b) -> (a, c)

Strong Either Void (FUN 'One :: TYPE LiftedRep -> TYPE LiftedRep -> Type)

Defined in Data.Profunctor.Linear

Methods

first :: FUN 'One a b -> FUN 'One (Either a c) (Either b c)

second :: FUN 'One b c -> FUN 'One (Either a b) (Either a c)

Strong (,) () (FUN 'One :: TYPE LiftedRep -> TYPE LiftedRep -> Type)

Defined in Data.Profunctor.Linear

Methods

first :: FUN 'One a b -> FUN 'One (a, c) (b, c)

second :: FUN 'One b c -> FUN 'One (a, b) (a, c)

class (Strong (,) () arr, Strong Either Void arr) => Wandering arr where

A Wandering arr instance means that there is a wander function which is the traversable generalization of the classic lens function:

forall f. Functor f => (a -> f b) -> (s -> f t)

in our notation:

forall arr. (HasKleisliFunctor arr) => (a `arr` b) -> (s `arr` t)

wander specializes the Functor constraint to a control applicative:

forall f. Applicative f => (a -> f b) -> (s -> f t)
forall arr. (HasKleisliApplicative arr) => (a `arr` b) -> (s `arr` t)

where HasKleisliFunctor or HasKleisliApplicative are some constraints which allow for the arr to be Kleisli f for control functors or applicatives f.

Methods

wander :: forall s t a b. (forall f. Applicative f => (a %1 -> f b) -> s %1 -> f t) -> (a `arr` b) -> s `arr` t

Equivalently but less efficient in general:

wander :: Data.Traversable f => a `arr` b -> f a `arr` f b

Instances

Applicative f => Wandering (Kleisli f)

Defined in Data.Profunctor.Kleisli.Linear

Methods

wander :: forall s t a b. (forall (f0 :: Type -> Type). Applicative f0 => (a %1 -> f0 b) -> s %1 -> f0 t) -> Kleisli f a b -> Kleisli f s t

Wandering (FUN 'One :: TYPE LiftedRep -> TYPE LiftedRep -> Type)

Defined in Data.Profunctor.Linear

Methods

wander :: forall s t a b. (forall (f :: Type -> Type). Applicative f => (a %1 -> f b) -> s %1 -> f t) -> FUN 'One a b -> FUN 'One s t

data Exchange a b s t

An exchange is a pair of translation functions that encode an isomorphism; an Exchange a b s t is equivalent to a Iso a b s t.

Constructors

Exchange (s %1 -> a) (b %1 -> t)

Instances

Profunctor (Exchange a b)

Defined in Data.Profunctor.Linear

Methods

dimap :: (s %1 -> a0) -> (b0 %1 -> t) -> Exchange a b a0 b0 -> Exchange a b s t

lmap :: (s %1 -> a0) -> Exchange a b a0 t -> Exchange a b s t

rmap :: (b0 %1 -> t) -> Exchange a b s b0 -> Exchange a b s t

data Market a b s t

A market is a pair of constructor and deconstructor functions that encode a prism; a Market a b s t is equivalent to a Prism a b s t.

Constructors

Market (b %1 -> t) (s %1 -> Either t a)

Instances

Strong Either Void (Market a b)

Defined in Data.Profunctor.Linear

Methods

first :: Market a b a0 b0 -> Market a b (Either a0 c) (Either b0 c)

second :: Market a b b0 c -> Market a b (Either a0 b0) (Either a0 c)

Profunctor (Market a b)

Defined in Data.Profunctor.Linear

Methods

dimap :: (s %1 -> a0) -> (b0 %1 -> t) -> Market a b a0 b0 -> Market a b s t

lmap :: (s %1 -> a0) -> Market a b a0 t -> Market a b s t

rmap :: (b0 %1 -> t) -> Market a b s b0 -> Market a b s t

runMarket :: Market a b s t %1 -> (b %1 -> t, s %1 -> Either t a)