Various Haskell 2010 stream comonads

Version on this page:3.2@rev:1
LTS Haskell 22.23:3.3.2
Stackage Nightly 2024-05-26:3.3.2
Latest on Hackage:3.3.2

See all snapshots streams appears in

BSD-3-Clause licensed by Edward A. Kmett
Maintained by Edward A. Kmett
This version can be pinned in stack with:streams-3.2@sha256:af489d487dc7cb4b1c778db5ffd29bd60fe97d222f25984fa56d9653dcd42d53,3756

Module documentation for 3.2

  • Data
    • Data.Stream
      • Data.Stream.Future
        • Data.Stream.Future.Skew
      • Data.Stream.Infinite
        • Data.Stream.Infinite.Functional
          • Data.Stream.Infinite.Functional.Zipper
        • Data.Stream.Infinite.Skew
      • Data.Stream.Supply

Various Haskell 2010 stream comonads. * 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.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.

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)
  • Data.Stream.Supply provides a comonadic supply of unique values, which are generated impurely as the tree is explored.



  • Switched to tabulate and index from adjunctions. Note: this reversed the argument order to index.
  • Proper upper bounds on dependencies.


  • Marked modules appropriately Trustworthy


  • Removed intra-package dependency bounds for my packages
  • Build system improvements
  • IRC Buildbot notification


  • Version sync with the rest of my packages


  • “Data.Stream.NonEmpty” renamed to “Data.List.NonEmpty” and pushed upstream into the semigroups package.


  • Removed a redundant UNPACK pragma


  • Data.Stream.Supply added

Since 0.1:

  • A number of strictness issues with ‘NonEmpty’ were fixed
  • More documentation