# DeepArrow

### From HaskellWiki

(update link to examples from darcs.haskell.org to hackage) |
|||

(22 intermediate revisions by 5 users not shown) | |||

Line 1: | Line 1: | ||

+ | == Abstract == | ||

The '''DeepArrow''' library is a framework for composable "editors" of pure values. | The '''DeepArrow''' library is a framework for composable "editors" of pure values. | ||

− | * | + | Besides this wiki page, here are more ways to learn about DeepArrow: |

− | * [http:// | + | * See the documentation [http://hackage.haskell.org/package/DeepArrow on Hackage]. |

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

+ | * Or grab a [http://code.haskell.org/~conal/code/DeepArrow/dist distribution tarball]. | ||

+ | * See the use of DeepArrow in [[TV]] and [[Eros]]. | ||

+ | |||

+ | Please leave comments at the [[Talk:DeepArrow|Talk page]]. | ||

== Introduction == | == Introduction == | ||

Line 9: | Line 15: | ||

If you've fooled around with arrows, you might guess that the arrow methods <hask>first</hask> and <hask>second</hask> having something to do with this game, and you'd be right. The main idea of DeepArrow is to play with compositions of <hask>first</hask> and <hask>second</hask> and of an analogous third combinator called <hask>result</hask>. I was stunned to realize that arbitrarily complex value editors can be made by stringing together compositions of these three combinators and delighted to find that the composition chains directly spell out the paths to the value subpart to be edited. | If you've fooled around with arrows, you might guess that the arrow methods <hask>first</hask> and <hask>second</hask> having something to do with this game, and you'd be right. The main idea of DeepArrow is to play with compositions of <hask>first</hask> and <hask>second</hask> and of an analogous third combinator called <hask>result</hask>. I was stunned to realize that arbitrarily complex value editors can be made by stringing together compositions of these three combinators and delighted to find that the composition chains directly spell out the paths to the value subpart to be edited. | ||

− | The DeepArrow library is about "deep function application" in two senses. First, compositions of <hask>first</hask>, <hask>second</hask>, and <hask>result</hask> apply functions deeply inside of values. | + | The DeepArrow library is about "deep function application" in two senses. First, compositions of <hask>first</hask>, <hask>second</hask>, and <hask>result</hask> apply functions deeply inside of values. Second, another set of combinators extract "deep functions" so they can be applied. Combining these two abilities allows a buried function to be applied to a buried argument, with the two contexts being carried along. |

+ | |||

+ | == Examples == | ||

+ | |||

+ | See [http://hackage.haskell.org/packages/archive/DeepArrow/latest/doc/html/src/Control-Arrow-DeepArrow-Examples.html example docs] in the library documentation. | ||

== Background == | == Background == | ||

Line 16: | Line 26: | ||

Eros was more complicated than I like, so I started splitting it into pieces: | Eros was more complicated than I like, so I started splitting it into pieces: | ||

− | * [http:// | + | * [http://haskell.org/haskellwiki/phooey Phooey] is a functional GUI library that has much of Eros's GUI implementation techniques, but much more carefully structured than in the Eros paper. |

* [http://haskell.org/haskellwiki/DeepArrow DeepArrow] has the general notion of "deep application". | * [http://haskell.org/haskellwiki/DeepArrow DeepArrow] has the general notion of "deep application". | ||

* [http://haskell.org/haskellwiki/TV TV] has the algebra of ''composable interfaces'', or visualizations of pure values, and it has ''tangible values'', which are separable combinations of interface and value. It uses Phooey to generate GUIs very simply from interfaces. | * [http://haskell.org/haskellwiki/TV TV] has the algebra of ''composable interfaces'', or visualizations of pure values, and it has ''tangible values'', which are separable combinations of interface and value. It uses Phooey to generate GUIs very simply from interfaces. | ||

+ | |||

+ | -- [[User:Conal|Conal Elliott]] | ||

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

+ | [[Category:Arrow]] | ||

+ | [[Category:Combinators]] |

## Latest revision as of 14:04, 26 September 2010

## Contents |

## [edit] 1 Abstract

The **DeepArrow** library is a framework for composable "editors" of pure values.

Besides this wiki page, here are more ways to learn about DeepArrow:

- See the documentation on Hackage.
- Get the code repository:
`darcs get http://code.haskell.org/~conal/code/DeepArrow` - Or grab a distribution tarball.
- See the use of DeepArrow in TV and Eros.

Please leave comments at the Talk page.

## [edit] 2 Introduction

By an "editor", I mean a function that targets a transformation at some part of a value, such as the first half of the second half of a value of type## [edit] 3 Examples

See example docs in the library documentation.

## [edit] 4 Background

The inspiration for value-editing paths came while I was looking for a way for non-programmers to be able to create functional images. I've had a growing intuition over the last fifteen years that media authoring tools can be usefully looked at as environments for functional programming. I'd been wondering how to map a user's gestures into operations on a functional program. Lots of noodling led to ideas of composable interfaces and "tangible values" (term thanks to Sean Seefried) and gestural composition in Eros.

Eros was more complicated than I like, so I started splitting it into pieces:

- Phooey is a functional GUI library that has much of Eros's GUI implementation techniques, but much more carefully structured than in the Eros paper.
- DeepArrow has the general notion of "deep application".
- TV has the algebra of
*composable interfaces*, or visualizations of pure values, and it has*tangible values*, which are separable combinations of interface and value. It uses Phooey to generate GUIs very simply from interfaces.