Hackage :: [Package]

streams: Various Haskell 2010 stream comonads

[ bsd3, comonads, control, library ] [ Propose Tags ] [ Report a vulnerability ]

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 Zipper a = !Integer :~ (Integer -> a)
  • Data.Stream.Supply provides a comonadic supply of unique values, which are generated impurely as the tree is explored.
 
 [Skip to Readme] 
   
 
Downloads
 
 
 
Maintainer's Corner
 
Package maintainers
  
For package maintainers and hackage trustees
  
Candidates
 
     
  •  No Candidates 
    •  
 
 
 
 
  
 Versions [RSS] 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, 3.2.1, 3.3, 3.3.1, 3.3.2, 3.3.3 
 
 Change log CHANGELOG.markdown 
 
 Dependencies adjunctions (>=4.0.1 && <5), base (>=4.9 && <5), boring (>=0.2 && <0.3), comonad (>=4 && <6), distributive (>=0.2.1 && <1), semigroupoids (>=4 && <7) [details] 
 
 Tested with  ghc ==8.0.2, ghc ==8.2.2, ghc ==8.4.4, ghc ==8.6.5, ghc ==8.8.4, ghc ==8.10.7, ghc ==9.0.2, ghc ==9.2.8, ghc ==9.4.8, ghc ==9.6.6, ghc ==9.8.4, ghc ==9.10.1, ghc ==9.12.1  
 
 License BSD-3-Clause 
 
 Copyright Copyright 2011-2013 Edward Kmett Copyright 2010 Tony Morris, Oliver Taylor, Eelis van der Weegen Copyright 2007-2010 Wouter Swierstra, Bas van Dijk Copyright 2008 Iavor S. Diatchki 
 
 Author Edward A. Kmett 
 
 Maintainer Edward A. Kmett <ekmett@gmail.com> 
 
 Category Control, Comonads 
 
 Home page  http://github.com/ekmett/streams  
 
 Bug tracker  http://github.com/ekmett/streams/issues  
 
 Source repo head: git clone git://github.com/ekmett/streams.git 
 
 Uploaded by ryanglscott at 2024-12-06T11:06:53Z 
 
 Distributions Arch:3.3.3, LTSHaskell:3.3.3, NixOS:3.3.3, Stackage:3.3.3 
 
 Reverse Dependencies 9 direct, 8189 indirect  [details] 
 
 Downloads 29698 total (110 in the last 30 days) 
 
  Rating 2.0 (votes: 1) [estimated by Bayesian average] 
 
 Your Rating  
     
  • λ
    •  
  • λ
    •  
  • λ
    •  
 		 
 
 Status Docs available [build log]
Last success reported on 2024-12-06 [all 1 reports]		 
  
 
 
 
 
 
Readme for streams-3.3.3
 [back to package description] 
-- currently implemented * Data.Stream.Supply data Supply a = Supply a (Supply a) (Supply a) * Data.Stream.Branching data Stream f a = a :< f (Stream a) * Data.Stream.NonEmpty data NonEmpty a = a :| [a] * Data.Stream.Future data Future a = Last a | a :< Future a * Data.Stream.Future.Skew data Future a = Last a | !(Complete a) :< Future a * Data.Stream.Infinite data Future a = a :< Future a * Data.Stream.Infinite.Skew data Future a = !(Complete a) :< Future a * Data.Stream.Infinite.Functional.Zipper data Zipper a = Zipper !(Integer -> a) !Integer -- TODO: refactor the existing Functional.Zipper to have a lower bound and add a Symmetric variant -- Data.Stream.Infinite.Functional.Zipper data Zipper a = Zipper !(Integer -> a) !Integer !Integer -- can seek arbitrarily Data.Stream.Causal data Causal a = First a | Causal a :> a Data.Stream.Causal.Infinite data Causal a = Causal a :> a Data.Stream.Causal.Finite data Causal a = First a | !(Causal a) :> a Data.Stream.Causal.Skew data Causal a = First a | Causal a :> !(Complete a) Data.Stream.Causal.Infinite.Skew data Causal a = Causal a :> !(Complete a) Data.Stream.Future.Finite data Future a = Last a | a :< !(Future a) Data.Stream.Zipper data Zipper a = Now !(Finite.Causal a) | !(Finite.Causal a) :| (Future a) Data.Stream.Zipper.Symmetric data Zipper a = Now !(Causal a) | !(Causal a) :| (Future a) Data.Stream.Zipper.Infinite data Zipper a = !(Finite.Causal a) :| Infinite.Future a Data.Stream.Zipper.Infinite.Symmetric data Zipper a = {- #UNPACK #-} !(Infinite.Causal a) :| Infinite.Future a Data.Stream.Zipper.Finite data Zipper a = Now !(Finite.Causal a) | !(Finite.Causal a) :| !(Finite.Future a) Data.Stream.Zipper.Skew data Zipper a = Zipper !(Seq a) !(Seq a) !(Skew.Future a) Data.Stream.Zipper.Skew.Symmetric data Zipper a = Zipper !(S.Causal a) !(Seq a) !(Seq a) !(Skew.Future a) Data.Stream.Zipper.Infinite.Skew data Zipper a = Zipper !(S.Causal a) !(Seq a) !(Seq a) !(IS.Future a) Data.Stream.Zipper.Infinite.Skew.Symmetric data Zipper a = Zipper !(IS.Causal a) !(Seq a) !(Seq a) !(IS.Future a) Data.Stream.Infinite.Functional.Future data Future a = Future !(Integer -> a) !Integer -- increment only Data.Stream.Infinite.Functional.Causal data Causal a = Causal !(Integer -> a) !Integer -- decrement only Data.Sequence.Future data Future a = Future !(Int# -> a) Int# Int# Data.Sequence.Causal data Causal a = Causal !(Int# -> a) Int# Int# Data.Sequence.Zipper data Zipper a = Zipper !(Int# -> a) Int# Int# Int# Data.Tensors data Tensors f a = Last a | a :- Tensors f (f a) Data.Tensors.Infinite data Tensors f a = a :- Tensors f (f a) Data.Tensors.Finite data Tensors f a = Last a | a :- !(Tensors f (f a))