# The streams package

Various Haskell 2010 stream comonads.

`Data.Stream.Branching`provides an "f-Branching Stream" comonad, aka the cofree comonad, or generalized rose tree.

data Stream f a = a :< f (Stream a)

`Data.Stream.Future`provides a coinductive anti-causal stream, or non-empty`ZipList`. The comonad provides access to only the tail of the stream. Like a conventional`ZipList`, this is*not*a monad.

data Future a = Last a | a :< Future a

`Data.Stream.Future.Skew`provides a non-empty skew-binary random-access-list with the semantics of`Data.Stream.Future`. As with`Data.Stream.Future`this stream is not a`Monad`, since the`Applicative`instance zips streams of potentially differing lengths. The random-access-list structure provides a number of operations logarithmic access time, but makes`Data.Stream.Future.Skew.cons`less productive. Where applicable`Data.Stream.Infinite.Skew`may be more efficient, due to a lazier and more efficient`Applicative`instance.

`Data.Stream.NonEmpty`provides a non-empty list comonad where the Applicative and Monad work like those of the`[a]`. Being non-empty, it trades in the`Alternative`and`Monoid`instances of`[a]`for weaker append-based`FunctorAlt`and`Semigroup`instances while becoming a member of`Comonad`and`ComonadApply`. Acting like a list, the semantics of`<*>`and`<.>`take a cross-product of membership from both`NonEmpty`lists rather than zipping like a`Future`

data NonEmpty a = a :| [a]

`Data.Stream.Infinite`provides a coinductive infinite anti-causal stream. The`Comonad`provides access to the tail of the stream and the`Applicative`zips streams together. Unlike`Future`, infinite stream form a`Monad`. The monad diagonalizes the`Stream`, which is consistent with the behavior of the`Applicative`, and the view of a`Stream`as a isomorphic to the reader monad from the natural numbers. Being infinite in length, there is no`Alternative`instance, but instead the`FunctorAlt`instance provides access to the`Semigroup`of interleaving streams.

data Stream a = a :< Stream a

`Data.Stream.Infinite.Skew`provides an infinite skew-binary random-access-list with the semantics of`Data.Stream.Infinite`Since every stream is infinite, the`Applicative`instance can be considerably less strict than the corresponding instance for`Data.Stream.Future.Skew`and performs asymptotically better.

`Data.Stream.Infinite.Functional.Zipper`provides a bi-infinite sequence, represented as a pure function with an accumulating parameter added to optimize moving the current focus.

data Zipper a = !Integer :~ (Integer -> a)

*Changes since 0.1*:

A number of strictness issues with

`NonEmpty`were fixedMore documentation

## Properties

Versions | 0.1.1, 0.2, 0.3, 0.3.1, 0.4, 0.5.0, 0.5.1, 0.5.1.1, 0.5.1.2, 0.6.0, 0.6.0.1, 0.6.1.1, 0.6.1.2, 0.6.3, 0.7.0, 0.7.1, 0.7.2, 0.8.0, 0.8.0.1, 0.8.0.2, 0.8.0.3, 0.8.0.4, 0.8.1, 0.8.2, 3.0, 3.0.0.1, 3.0.1, 3.0.1.1, 3.1, 3.1.1, 3.2 |
---|---|

Change log | None available |

Dependencies | base (>=4 && <4.4), comonad (==0.9.*), distributive (==0.1.*), functor-apply (==0.9.*), semigroups (>=0.3.4 && <0.4) |

License | BSD3 |

Copyright | Copyright 2011 Edward Kmett Copyright 2010 Tony Morris, Oliver Taylor, Eelis van der Weegen Copyright 2007-2010 Wouter Swierstra, Bas van Dijk |

Author | Edward A. Kmett |

Maintainer | Edward A. Kmett <ekmett@gmail.com> |

Stability | provisional |

Category | Control, Comonads |

Home page | http://github.com/ekmett/streams |

Source repository | head: git clone git://github.com/ekmett/streams.git |

Uploaded | Wed Jan 26 03:37:47 UTC 2011 by EdwardKmett |

Distributions | LTSHaskell:3.2, NixOS:3.2 |

Downloads | 3917 total (201 in last 30 days) |

Status | Docs uploaded by user Build status unknown [no reports yet] |

## Modules

[Index]

## Downloads

- streams-0.4.tar.gz [browse] (Cabal source package)
- Package description (included in the package)

#### Maintainers' corner

For package maintainers and hackage trustees