TypeCompose-0.9.1: Type composition classes & instances

Portabilitysee LANGUAGE pragma
Stabilityexperimental
Maintainerconal@conal.net
Safe HaskellNone

Control.Compose

Contents

Description

Various type constructor compositions and instances for them. Some come from "Applicative Programming with Effects" http://www.soi.city.ac.uk/~ross/papers/Applicative.html

Synopsis

Value transformers

type Unop a = a -> a

Unary functions

type Binop a = a -> a -> a

Binary functions

Specialized semantic editor combinators

result :: (b -> b') -> (a -> b) -> a -> b'

Add post-processing

argument :: (a' -> a) -> (a -> b) -> a' -> b

Add pre-processing

(~>) :: Category --> => (a' --> a) -> (b --> b') -> (a --> b) -> a' --> b'

Add pre- and post processing

(~>*) :: Functor f => (a' -> a) -> (b -> b') -> (f a -> f b) -> f a' -> f b'

Like '(~>)' but specialized to functors

Contravariant functors

class ContraFunctor h where

Contravariant functors. often useful for acceptors (consumers, sinks) of values.

Methods

contraFmap :: (a -> b) -> h b -> h a

Instances

Arrow ~> => ContraFunctor (Flip ~> b) 
(Arrow ~>, Functor f, ContraFunctor g) => ContraFunctor (Arrw ~> f g) 

bicomap :: ContraFunctor f => (a :<->: b) -> f a :<->: f b

Bijections on contravariant functors

Unary/unary composition

newtype (g :. f) a

Composition of unary type constructors

There are (at least) two useful Monoid instances, so you'll have to pick one and type-specialize it (filling in all or parts of g and/or f).

     -- standard Monoid instance for Applicative applied to Monoid
     instance (Applicative (g :. f), Monoid a) => Monoid ((g :. f) a) where
       { mempty = pure mempty; mappend = liftA2 mappend }
     -- Especially handy when g is a Monoid_f.
     instance Monoid (g (f a)) => Monoid ((g :. f) a) where
       { mempty = O mempty; mappend = inO2 mappend }

Corresponding to the first and second definitions above,

     instance (Applicative g, Monoid_f f) => Monoid_f (g :. f) where
       { mempty_f = O (pure mempty_f); mappend_f = inO2 (liftA2 mappend_f) }
     instance Monoid_f g => Monoid_f (g :. f) where
       { mempty_f = O mempty_f; mappend_f = inO2 mappend_f }

Similarly, there are two useful Functor instances and two useful ContraFunctor instances.

     instance (      Functor g,       Functor f) => Functor (g :. f) where fmap = fmapFF
     instance (ContraFunctor g, ContraFunctor f) => Functor (g :. f) where fmap = fmapCC
 
     instance (      Functor g, ContraFunctor f) => ContraFunctor (g :. f) where contraFmap = contraFmapFC
     instance (ContraFunctor g,       Functor f) => ContraFunctor (g :. f) where contraFmap = contraFmapCF

However, it's such a bother to define the Functor instances per composition type, I've left the fmapFF case in. If you want the fmapCC one, you're out of luck for now. I'd love to hear a good solution. Maybe someday Haskell will do Prolog-style search for instances, subgoaling the constraints, rather than just matching instance heads.

Constructors

O (g (f a)) 

Instances

Applicative f => Lambda f (:. (Flip (->) o) f) 
Applicative f => Lambda f (:. f (Flip (->) o)) 
(Functor g, Functor f) => Functor (:. g f) 
(Applicative g, Applicative f) => Applicative (:. g f) 
(Foldable g, Foldable f, Functor g) => Foldable (:. g f) 
(Traversable g, Traversable f) => Traversable (:. g f) 
Title_f g => Title_f (:. g f) 
(Functor h, Copair f) => Copair (:. h f) 
(Functor h, Cozip f) => Cozip (:. h f) 
Show (g (f a)) => Show (:. g f a) 

type O = :.

Compatibility synonym

unO :: (g :. f) a -> g (f a)

Unwrap a '(:.)'.

biO :: g (f a) :<->: (g :. f) a

newtype bijection

convO :: Functor g => (b :<->: g c) -> (c :<->: f a) -> b :<->: (g :. f) a

Compose a bijection, Functor style

coconvO :: ContraFunctor g => (b :<->: g c) -> (c :<->: f a) -> b :<->: (g :. f) a

Compose a bijection, ContraFunctor style

inO :: (g (f a) -> g' (f' a')) -> (g :. f) a -> (g' :. f') a'

Apply a unary function within the O constructor.

inO2 :: (g (f a) -> g' (f' a') -> g'' (f'' a'')) -> (g :. f) a -> (g' :. f') a' -> (g'' :. f'') a''

Apply a binary function within the O constructor.

inO3 :: (g (f a) -> g' (f' a') -> g'' (f'' a'') -> g''' (f''' a''')) -> (g :. f) a -> (g' :. f') a' -> (g'' :. f'') a'' -> (g''' :. f''') a'''

Apply a ternary function within the O constructor.

oPure :: Applicative g => f a -> (g :. f) a

Handy combination of O and pure.

oFmap :: Functor g' => (f a -> f' a') -> (g' :. f) a -> (g' :. f') a'

Handy combination of inO and fmap.

oLiftA2 :: Applicative g'' => (f a -> f' a' -> f'' a'') -> (g'' :. f) a -> (g'' :. f') a' -> (g'' :. f'') a''

Handy combination of inO2 and liftA2.

oLiftA3 :: Applicative g''' => (f a -> f' a' -> f'' a'' -> f''' a''') -> (g''' :. f) a -> (g''' :. f') a' -> (g''' :. f'') a'' -> (g''' :. f''') a'''

Handy combination of inO3 and liftA3.

fmapFF :: (Functor g, Functor f) => (a -> b) -> (g :. f) a -> (g :. f) b

Used for the Functor :. Functor instance of Functor

fmapCC :: (ContraFunctor g, ContraFunctor f) => (a -> b) -> (g :. f) a -> (g :. f) b

Used for the ContraFunctor :. ContraFunctor instance of Functor

contraFmapFC :: (Functor g, ContraFunctor f) => (b -> a) -> (g :. f) a -> (g :. f) b

Used for the Functor :. ContraFunctor instance of Functor

contraFmapCF :: (ContraFunctor g, Functor f) => (b -> a) -> (g :. f) a -> (g :. f) b

Used for the ContraFunctor :. Functor instance of Functor

Type composition

Unary/binary

newtype OO f (~>) a b

Composition of type constructors: unary with binary. Called StaticArrow in [1].

Constructors

OO 

Fields

unOO :: f (a ~> b)
 

Instances

(Applicative f, Arrow ~>) => Arrow (OO f ~>) 
(Applicative f, Category ~>) => Category (OO f ~>) 

(->)/unary

newtype FunA h a b

Common pattern for Arrows.

Constructors

FunA 

Fields

unFunA :: h a -> h b
 

Instances

FunAble h => Arrow (FunA h) 
FunAble h => Category (FunA h) 

inFunA :: ((h a -> h b) -> h' a' -> h' b') -> FunA h a b -> FunA h' a' b'

Apply unary function in side a FunA representation.

inFunA2 :: ((h a -> h b) -> (h' a' -> h' b') -> h'' a'' -> h'' b'') -> FunA h a b -> FunA h' a' b' -> FunA h'' a'' b''

Apply binary function in side a FunA representation.

class FunAble h where

Support needed for a FunA to be an Arrow.

Methods

arrFun

Arguments

:: (a -> b) 
-> h a -> h b

for arr

firstFun :: (h a -> h a') -> h (a, b) -> h (a', b)

secondFun :: (h b -> h b') -> h (a, b) -> h (a, b')

(***%) :: (h a -> h b) -> (h a' -> h b') -> h (a, a') -> h (b, b')

(&&&%) :: (h a -> h b) -> (h a -> h b') -> h a -> h (b, b')

Instances

Monoid constructors

class Monoid_f m where

Simulates universal constraint forall a. Monoid (f a).

See Simulating Quantified Class Constraints (http://flint.cs.yale.edu/trifonov/papers/sqcc.pdf) Instantiate this schema wherever necessary:

    instance Monoid_f f where { mempty_f = mempty ; mappend_f = mappend }

Methods

mempty_f :: forall a. m a

mappend_f :: forall a. m a -> m a -> m a

Instances

Monoid_f [] 
Monoid_f Endo 
(Monoid_f f, Monoid_f g) => Monoid_f (:*: f g) 
Monoid o => Monoid_f (Flip (->) o) 

Flip a binary constructor's type arguments

newtype Flip (~>) b a

Flip type arguments

Constructors

Flip 

Fields

unFlip :: a ~> b
 

Instances

ToOI OI 
Lambda IO OI 
Applicative f => Lambda f (:. (Flip (->) o) f) 
Applicative f => Lambda f (:. f (Flip (->) o)) 
Lambda Id (Flip (->) o) 
Monoid o => Monoid_f (Flip (->) o) 
Arrow ~> => ContraFunctor (Flip ~> b) 
Title o => Title_f (Flip (->) o) 
Arrow ~> => Copair (Flip ~> o) 
(Arrow ~>, Monoid_f (Flip ~> o)) => Pair (Flip ~> o) 
Arrow ~> => Cozip (Flip ~> o) 
(Arrow ~>, Monoid_f (Flip ~> o)) => Zip (Flip ~> o) 
(Applicative (~> a), Monoid o) => Monoid (Flip ~> o a) 

biFlip :: (a ~> b) :<->: Flip ~> b a

newtype bijection

inFlip :: ((a ~> b) -> a' ~~> b') -> Flip ~> b a -> Flip ~~> b' a'

inFlip2 :: ((a ~> b) -> (a' ~~> b') -> a'' ~~~> b'') -> Flip ~> b a -> Flip ~~> b' a' -> Flip ~~~> b'' a''

inFlip3 :: ((a ~> b) -> (a' ~~> b') -> (a'' ~~~> b'') -> a''' ~~~~> b''') -> Flip ~> b a -> Flip ~~> b' a' -> Flip ~~~> b'' a'' -> Flip ~~~~> b''' a'''

type OI = Flip (->) (IO ())

(-> IO ()) as a Flip. A ContraFunctor.

class ToOI sink where

Convert to an OI.

Methods

toOI :: sink b -> OI b

Instances

Type application

newtype f :$ a

Type application We can also drop the App constructor, but then we overlap with many other instances, like [a]. Here's a template for App-free instances.

    instance (Applicative f, Monoid a) => Monoid (f a) where
      mempty  = pure mempty
      mappend = liftA2 mappend

Constructors

App 

Fields

unApp :: f a
 

Instances

(Applicative f, Monoid m) => Monoid (App f m) 

type App = :$

Compatibility synonym for (:$).

biApp :: f a :<->: App f a

newtype bijection

inApp :: (f a -> f' a') -> App f a -> App f' a'

inApp2 :: (f a -> f' a' -> f'' a'') -> App f a -> App f' a' -> App f'' a''

Identity

newtype Id a

Identity type constructor. Until there's a better place to find it. I'd use Control.Monad.Identity, but I don't want to introduce a dependency on mtl just for Id.

Constructors

Id a 

unId :: Id a -> a

biId :: a :<->: Id a

newtype bijection

inId :: (a -> b) -> Id a -> Id b

inId2 :: (a -> b -> c) -> Id a -> Id b -> Id c

Constructor pairing

Unary

newtype (f :*: g) a

Pairing of unary type constructors

Constructors

Prod 

Fields

unProd :: (f a, g a)
 

Instances

(Functor f, Functor g) => Functor (:*: f g) 
(Applicative f, Applicative g) => Applicative (:*: f g) 
(Monoid_f f, Monoid_f g) => Monoid_f (:*: f g) 
(Copair f, Copair g) => Copair (:*: f g) 
(Pair f, Pair g) => Pair (:*: f g) 
(Cozip f, Cozip g) => Cozip (:*: f g) 
(Zip f, Zip g) => Zip (:*: f g) 
(Lambda src snk, Lambda dom' ran') => Lambda (:*: src dom') (:*: snk ran') 
Eq (f a, g a) => Eq (:*: f g a) 
Ord (f a, g a) => Ord (:*: f g a) 
Show (f a, g a) => Show (:*: f g a) 

biProd :: (f a, g a) :<->: (f :*: g) a

newtype bijection

convProd :: (b :<->: f a) -> (c :<->: g a) -> (b, c) :<->: (f :*: g) a

Compose a bijection

(***#) :: (a -> b -> c) -> (a' -> b' -> c') -> (a, a') -> (b, b') -> (c, c')

Combine two binary functions into a binary function on pairs

($*) :: (a -> b, a' -> b') -> (a, a') -> (b, b')

A handy combining form. See '(***#)' for an sample use.

inProd :: ((f a, g a) -> (f' a', g' a')) -> (f :*: g) a -> (f' :*: g') a'

Apply unary function inside of f :*: g representation.

inProd2 :: ((f a, g a) -> (f' a', g' a') -> (f'' a'', g'' a'')) -> (f :*: g) a -> (f' :*: g') a' -> (f'' :*: g'') a''

Apply binary function inside of f :*: g representation.

inProd3 :: ((f a, g a) -> (f' a', g' a') -> (f'' a'', g'' a'') -> (f''' a''', g''' a''')) -> (f :*: g) a -> (f' :*: g') a' -> (f'' :*: g'') a'' -> (f''' :*: g''') a'''

Apply ternary function inside of f :*: g representation.

Binary

newtype (f ::*:: g) a b

Pairing of binary type constructors

Constructors

Prodd 

Fields

unProdd :: (f a b, g a b)
 

Instances

(Arrow f, Arrow f') => Arrow (::*:: f f') 
(Category f, Category f') => Category (::*:: f f') 
(Eq (f a b), Eq (g a b)) => Eq (::*:: f g a b) 
(Ord (f a b), Ord (g a b)) => Ord (::*:: f g a b) 
(Show (f a b), Show (g a b)) => Show (::*:: f g a b) 

inProdd :: ((f a b, g a b) -> (f' a' b', g' a' b')) -> (f ::*:: g) a b -> (f' ::*:: g') a' b'

Apply binary function inside of f :*: g representation.

inProdd2 :: ((f a b, g a b) -> (f' a' b', g' a' b') -> (f'' a'' b'', g'' a'' b'')) -> (f ::*:: g) a b -> (f' ::*:: g') a' b' -> (f'' ::*:: g'') a'' b''

Apply binary function inside of f :*: g representation.

Arrow between two constructor applications

newtype Arrw (~>) f g a

Arrow-like type between type constructors (doesn't enforce Arrow (~>) here).

Constructors

Arrw 

Fields

unArrw :: f a ~> g a
 

Instances

Applicative f => Lambda f (:->: f (Const o)) 
(Arrow ~>, ContraFunctor f, Functor g) => Functor (Arrw ~> f g) 
(Arrow ~>, Functor f, ContraFunctor g) => ContraFunctor (Arrw ~> f g) 
(Arrow ~>, Unpair f, Pair g) => Pair (Arrw ~> f g) 
(Arrow ~>, Unzip f, Zip g) => Zip (Arrw ~> f g) 
(Arrow ~>, Unlambda f f', Lambda g g') => Lambda (Arrw ~> f g) (Arrw ~> f' g') 
Monoid (~> (f a) (g a)) => Monoid (Arrw ~> f g a) 

type :->: = Arrw (->)

biFun :: (f a -> g a) :<->: (f :->: g) a

newtype bijection

convFun :: (b :<->: f a) -> (c :<->: g a) -> (b -> c) :<->: (f :->: g) a

Compose a bijection

inArrw :: ((f a ~> g a) -> f' a' ~> g' a') -> Arrw ~> f g a -> Arrw ~> f' g' a'

Apply unary function inside of Arrw representation.

inArrw2 :: ((f a ~> g a) -> (f' a' ~> g' a') -> f'' a'' ~> g'' a'') -> Arrw ~> f g a -> Arrw ~> f' g' a' -> Arrw ~> f'' g'' a''

Apply binary function inside of Arrw (~>) f g representation.

inArrw3 :: ((f a ~> g a) -> (f' a' ~> g' a') -> (f'' a'' ~> g'' a'') -> f''' a''' ~> g''' a''') -> Arrw ~> f g a -> Arrw ~> f' g' a' -> Arrw ~> f'' g'' a'' -> Arrw ~> f''' g''' a'''

Apply ternary function inside of Arrw (~>) f g representation.

Augment other modules

biConst :: a :<->: Const a b

newtype bijection

inConst :: (a -> b) -> Const a u -> Const b v

inConst2 :: (a -> b -> c) -> Const a u -> Const b v -> Const c w

inConst3 :: (a -> b -> c -> d) -> Const a u -> Const b v -> Const c w -> Const d x

biEndo :: (a -> a) :<->: Endo a

newtype bijection

inEndo :: (Unop a -> Unop a') -> Endo a -> Endo a'

Convenience for partial-manipulating functions