TypeCompose

From HaskellWiki

Revision as of 05:34, 9 September 2007 (edit) Conal (Talk | contribs) (→Abstract: out-of-date docs) ← Previous diff		Current revision (17:48, 9 January 2011) (edit) (undo) Lemming (Talk | contribs) (Category:Applicative -> Applicative Functor)
(10 intermediate revisions not shown.)
Line 1:		Line 1:
-	== Abstract ==	+	[[Category:Composition]]
		+	[[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>darcs get http://code.haskell.org/~conal/code/TypeCompose</tt>.
		+	<!--* See the [[TypeCompose/Versions| version history]].-->
	== Type composition ==		== Type composition ==
Line 29:		Line 34:
	=== 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 43:		Line 48:
	=== 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.

---

Current revision

Contents 1 Abstract 2 Type composition 3 Other features 3.1 Composable bijections 3.2 Pair- & function-like types 3.3 References 3.4 Titling 3.5 Partial values 3.6 Context-dependent monoids

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

The 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
  .

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.

The module is inspired by There and Back Again: Arrows for Invertible Programming, though done here in a less general setting.

3.2 Pair- & function-like types

The and patterns emerged while working on DeepArrow and Eros. generalizes and from to other functors. It also provides variants of type and . is similar with classes for lambda-like constructions. For example uses of and , see TV and Eros.

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. defines a sort of meta-monoid, that can be supplied dynamically with choices of and . Used in Phooey (starting with version 1.3) so that layout could be a monoid but still vary in style.

Categories: Composition | Applicative Functor | Libraries | Packages | Type-level programming