# TypeCompose

### From HaskellWiki

(Difference between revisions)

(→Abstract: talk page & DataDriven link) |
(Category:Applicative -> Applicative Functor) |
||

(8 intermediate revisions by 2 users not shown) | |||

Line 1: | Line 1: | ||

[[Category:Composition]] | [[Category:Composition]] | ||

− | [[Category:Applicative]] | + | [[Category:Applicative Functor]] |

[[Category:Libraries]] | [[Category:Libraries]] | ||

[[Category:Packages]] | [[Category:Packages]] | ||

− | + | [[Category:Type-level programming]] | |

== Abstract == | == Abstract == | ||

− | |||

− | |||

'''TypeCompose''' provides some classes & instances for forms of type composition, as well as some modules that haven't found another home. | '''TypeCompose''' provides some classes & instances for forms of type composition, as well as some modules that haven't found another home. | ||

− | Besides this wiki page, here are more ways to find out about TypeCompose | + | Besides this wiki page, here are more ways to find out about TypeCompose: |

− | * | + | * Visit the [http://hackage.haskell.org/cgi-bin/hackage-scripts/package/TypeCompose Hackage page] for library documentation and to download & install. |

− | * Get the code repository: | + | * Or install with <tt>cabal install TypeCompose</tt>. |

− | + | * Get the code repository: <tt>darcs get http://code.haskell.org/~conal/code/TypeCompose</tt>. | |

− | * See the [[TypeCompose/Versions| version history]]. | + | <!--* See the [[TypeCompose/Versions| version history]].--> |

− | + | ||

− | + | ||

− | + | ||

== Type composition == | == Type composition == | ||

Line 39: | Line 34: | ||

=== Pair- & function-like types === | === Pair- & function-like types === | ||

− | The <hask>Data. | + | The <hask>Data.Zip</hask> and <hask>Data.Lambda</hask> patterns emerged while working on [[DeepArrow]] and [[Eros]]. <hask>Data.Zip</hask> generalizes <hask>zip</hask> and <hask>unzip</hask> from <hask>[]</hask> to other functors. It also provides variants of type <hask>f a -> f (a,b)</hask> and <hask>f a -> f (a,b)</hask>. <hask>Data.Lambda</hask> is similar with classes for lambda-like constructions. |

For example uses of <hask>Pair</hask> and <hask>Lambda</hask>, see [[TV]] and [[Eros]]. | For example uses of <hask>Pair</hask> and <hask>Lambda</hask>, see [[TV]] and [[Eros]]. | ||

Line 53: | Line 48: | ||

=== Partial values === | === Partial values === | ||

− | A monoid of partial values. See the [http://conal | + | A monoid of partial values. See the [http://conal.net/blog/posts/a-type-for-partial-values/ teaser] and [http://conal.net/blog/posts/implementing-a-type-for-partial-values/ solution] blog |

posts. | posts. | ||

## Revision as of 17:48, 9 January 2011

## Contents |

## 1 Abstract

**TypeCompose** provides some classes & instances for forms of type composition, as well as some modules that haven't found another home.

Besides this wiki page, here are more ways to find out about TypeCompose:

- Visit the Hackage page for library documentation and to download & install.
- Or install with
`cabal install TypeCompose`. - Get the code repository:
`darcs get http://code.haskell.org/~conal/code/TypeCompose`.

## 2 Type composition

TheControl.Compose

- Various type compositions (unary/unary, binary/unary, etc). Most are from Applicative Programming with Effects. In particular, composes functors in to functors and applicative functors (AFs) into AFs. (In contrast, monads do not in general compose.) Composition makes AF-based programming simple and elegant, partly because we don't need an AF counterpart to monad transformers.g `O` f
- Cofunctors (contravariant functors). Great for "consumer" types, just as functors suit "producer" (container) types. There are several composition options.
- Type argument flip. Handy for cofunctors: use , forFlip (->) o.(-> o)
- Constructor in pairs: .(f a, g a)
- Constructor in arrows/functions: .f a ~> g a

## 3 Other features

### 3.1 Composable bijections

Given all the type constructors and compositions of them, I found myself writing some pretty awkward code to wrap & unwrap through multiple layers. Composable bijections help a lot.

TheData.Bijection

### 3.2 Pair- & function-like types

TheData.Zip

Data.Lambda

Data.Zip

zip

unzip

[]

f a -> f (a,b)

f a -> f (a,b)

Data.Lambda

Pair

Lambda

### 3.3 References

Monads with references. Direct rip-off from Global Variables in Haskell.

### 3.4 Titling

For giving titles to things. I know it sounds kind of random. More useful than I first thought. Used in Phooey, TV, and Eros.

### 3.5 Partial values

A monoid of partial values. See the teaser and solution blog posts.

### 3.6 Context-dependent monoids

Bit of an oddball also.Data.CxMonoid

mempty

mappend