Difference between revisions of "TypeCompose"
(Category:Applicative -> Applicative Functor) |
|||
| (9 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 == |
||
| − | |||
| − | ''Warning'': The Haddock docs are out of date. I'm trying to get a working haddock 2.0 running (on my windows machine). |
||
'''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: |
||
| − | * Read [http://darcs.haskell.org/packages/TypeCompose/doc/html the Haddock docs] (with source code, additional examples, and Comment/Talk links). |
||
| + | * Visit the [http://hackage.haskell.org/cgi-bin/hackage-scripts/package/TypeCompose Hackage page] for library documentation and to download & install. |
||
| ⚫ | |||
| + | * Or install with <tt>cabal install TypeCompose</tt>. |
||
| − | * Grab a [http://darcs.haskell.org/packages/TypeCompose/dist distribution tarball]. |
||
| ⚫ | |||
| − | * See the [[TypeCompose/Versions| version history]]. |
+ | <!--* See the [[TypeCompose/Versions| version history]].--> |
== Type composition == |
== Type composition == |
||
| Line 35: | 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 49: | 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
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.
Type composition
The Control.Compose module includes
- Various type compositions (unary/unary, binary/unary, etc). Most are from Applicative Programming with Effects. In particular,
g `O` fcomposes 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. - 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
Flip (->) o, for(-> o). - Constructor in pairs:
(f a, g a). - Constructor in arrows/functions:
f a ~> g a.
Other features
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.
The Data.Bijection module is inspired by There and Back Again: Arrows for Invertible Programming, though done here in a less general setting.
Pair- & function-like types
The Data.Zip and Data.Lambda patterns emerged while working on DeepArrow and Eros. Data.Zip generalizes zip and unzip from [] to other functors. It also provides variants of type f a -> f (a,b) and f a -> f (a,b). Data.Lambda is similar with classes for lambda-like constructions.
For example uses of Pair and Lambda, see TV and Eros.
References
Monads with references. Direct rip-off from Global Variables in Haskell.
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.
Partial values
A monoid of partial values. See the teaser and solution blog posts.
Context-dependent monoids
Bit of an oddball also. Data.CxMonoid defines a sort of meta-monoid, that can be supplied dynamically with choices of mempty and mappend. Used in Phooey (starting with version 1.3) so that layout could be a monoid but still vary in style.