Personal tools

TypeCompose

From HaskellWiki

(Difference between revisions)
Jump to: navigation, search
m (Type composition)
(Category:Applicative -> Applicative Functor)
 
(19 intermediate revisions by 2 users not shown)
Line 1: Line 1:
  +
[[Category:Composition]]
  +
[[Category:Applicative Functor]]
  +
[[Category:Libraries]]
  +
[[Category:Packages]]
  +
[[Category:Type-level programming]]
  +
 
== Abstract ==
 
== Abstract ==
   
'''TypeCompose''' provides some classes & instances for forms of type composition. It also includes a very simple implementation of data-driven computation.
+
'''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 [http://darcs.haskell.org/packages/TypeCompose/CHANGES version changes].
+
* Get the code repository: <tt>darcs get http://code.haskell.org/~conal/code/TypeCompose</tt>.
+
<!--* See the [[TypeCompose/Versions| version history]].-->
TypeCompose is used in [[Phooey]], a functional GUI library.
 
   
 
== Type composition ==
 
== Type composition ==
   
For now, see the [http://darcs.haskell.org/packages/TypeCompose/doc/html/Control-Compose.html Haddock docs].
+
The <hask>Control.Compose</hask> module includes
  +
* Various type compositions (unary/unary, binary/unary, etc). Most are from [http://www.soi.city.ac.uk/~ross/papers/Applicative.html Applicative Programming with Effects]. In particular, <hask>g `O` f</hask> 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 <hask>Flip (->) o</hask>, for <hask>(-> o)</hask>.
  +
* Constructor in pairs: <hask>(f a, g a)</hask>.
  +
* Constructor in arrows/functions: <hask>f a ~> g a</hask>.
  +
  +
== 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 <hask>Data.Bijection</hask> module is inspired by [http://citeseer.ist.psu.edu/alimarine05there.html There and Back Again: Arrows for Invertible Programming], though done here in a less general setting.
  +
  +
=== Pair- & function-like types ===
  +
  +
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]].
  +
  +
=== References ===
  +
  +
Monads with references. Direct rip-off from [http://citeseer.ist.psu.edu/473734.html 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 [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.
  +
  +
=== Context-dependent monoids ===
   
== Data-driven computation ==
+
Bit of an oddball also. <hask>Data.CxMonoid</hask> defines a sort of meta-monoid, that can be supplied dynamically with choices of <hask>mempty</hask> and <hask>mappend</hask>. Used in [[Phooey]] (starting with version 1.3) so that layout could be a monoid but still vary in style.

Latest revision as of 17:48, 9 January 2011


Contents

[edit] 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:

[edit] 2 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
    .

[edit] 3 Other features

[edit] 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
Data.Bijection
module is inspired by There and Back Again: Arrows for Invertible Programming, though done here in a less general setting.

[edit] 3.2 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.

[edit] 3.3 References

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

[edit] 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.

[edit] 3.5 Partial values

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

[edit] 3.6 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.