Difference between revisions of "TypeCompose"

From HaskellWiki
Jump to: navigation, search
(Abstract: out-of-date docs)
m
 
(13 intermediate revisions by 4 users not shown)
Line 1: Line 1:
== Abstract ==
 
  +
[[Category:Applicative Functor]]
  +
[[Category:Libraries]]
  +
[[Category:Packages]]
  +
[[Category:Type-level programming]]
   
''Warning'': The Haddock docs are out of date. I'm trying to get a working haddock 2.0 running (on my windows machine).
 
 
== 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.
   
* Read [http://darcs.haskell.org/packages/TypeCompose/doc/html the Haddock docs] (with source code, additional examples, and Comment/Talk links).
 
  +
Besides this wiki page, here are more ways to find out about TypeCompose:
* Get the code repository: '''<tt>darcs get http://darcs.haskell.org/packages/TypeCompose</tt>''', or
 
  +
* Visit the [http://hackage.haskell.org/cgi-bin/hackage-scripts/package/TypeCompose Hackage page] for library documentation and to download & install.
* Grab a [http://darcs.haskell.org/packages/TypeCompose/dist distribution tarball].
 
  +
* Or install with <tt>cabal install TypeCompose</tt>.
* See the [[TypeCompose/Versions| version history]].
 
  +
* Get the code repository: <tt>git clone git@github.com:conal/TypeCompose.git</tt>.
 
<!--* See the [[TypeCompose/Versions| version history]].-->
   
 
== Type composition ==
 
== Type composition ==
Line 29: Line 33:
 
=== Pair- & function-like types ===
 
=== Pair- & function-like types ===
   
The <hask>Data.Pair</hask> and <hask>Data.Lambda</hask> patterns emerged while working on [[DeepArrow]] and [[Eros]]. <hask>Data.Pair</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.
+
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 35: Line 39:
 
=== References ===
 
=== References ===
   
Monads with references. Direct rip-off from [http://citeseer.ist.psu.edu/473734.html Global Variables in Haskell].
+
Monads with references. Direct rip-off from [http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.23.145 Global Variables in Haskell].
   
 
=== Titling ===
 
=== Titling ===
Line 43: Line 47:
 
=== Partial values ===
 
=== Partial values ===
   
A monoid of partial values. See the [http://conal-elliott.blogspot.com/2007/07/type-for-partial-values.html teaser] and [http://conal-elliott.blogspot.com/2007/07/implementing-type-for-partial-values.html solution] blog
+
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.
   

Latest revision as of 22:44, 29 June 2021


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: git clone git@github.com:conal/TypeCompose.git.

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` f 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.
  • 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.