trait
Streams[Stream[+_[_], +_]] extends AnyRef
Type Members
-
-
-
abstract
type
Handle[+F[_], +_]
-
abstract
type
Pull[+F[_], +R, +O]
Abstract Value Members
-
abstract
def
Pull: Pulls[Pull]
-
abstract
def
append[F[_], A](a: Stream[F, A], b: ⇒ Stream[F, A]): Stream[F, A]
-
abstract
def
attemptEval[F[_], A](fa: F[A]): Stream[F, Attempt[A]]
-
-
abstract
def
awaitAsync[F[_], A](h: Handle[F, A])(implicit F: Async[F]): Pull[F, Nothing, AsyncStep[F, A]]
-
abstract
def
bracket[F[_], R, A](acquire: F[R])(use: (R) ⇒ Stream[F, A], release: (R) ⇒ F[Unit]): Stream[F, A]
-
abstract
def
chunk[F[_], A](as: Chunk[A]): Stream[F, A]
-
abstract
def
cons[F[_], A](h: Stream[F, A])(c: Chunk[A]): Stream[F, A]
-
abstract
def
fail[F[_]](e: Throwable): Stream[F, Nothing]
-
abstract
def
flatMap[F[_], A, B](a: Stream[F, A])(f: (A) ⇒ Stream[F, B]): Stream[F, B]
-
abstract
def
onError[F[_], A](s: Stream[F, A])(handle: (Throwable) ⇒ Stream[F, A]): Stream[F, A]
-
abstract
def
open[F[_], A](s: Stream[F, A]): Pull[F, Nothing, Handle[F, A]]
-
abstract
def
push[F[_], A](h: Handle[F, A])(c: Chunk[A]): Handle[F, A]
-
abstract
def
runFoldFree[F[_], A, B](s: Stream[F, A], z: B)(f: (B, A) ⇒ B): Free[F, B]
-
abstract
def
runFoldTraceFree[F[_], A, B](t: Trace)(s: Stream[F, A], z: B)(f: (B, A) ⇒ B): Free[F, B]
-
abstract
def
translate[F[_], G[_], A](s: Stream[F, A])(u: ~>[F, G]): Stream[G, A]
Concrete Value Members
-
final
def
!=(arg0: Any): Boolean
-
final
def
##(): Int
-
def
+(other: String): String
-
def
->[B](y: B): (Streams[Stream], B)
-
final
def
==(arg0: Any): Boolean
-
final
def
asInstanceOf[T0]: T0
-
def
clone(): AnyRef
-
def
empty[F[_], A]: Stream[F, A]
-
def
ensuring(cond: (Streams[Stream]) ⇒ Boolean, msg: ⇒ Any): Streams[Stream]
-
def
ensuring(cond: (Streams[Stream]) ⇒ Boolean): Streams[Stream]
-
def
ensuring(cond: Boolean, msg: ⇒ Any): Streams[Stream]
-
def
ensuring(cond: Boolean): Streams[Stream]
-
-
-
def
finalize(): Unit
-
def
formatted(fmtstr: String): String
-
final
def
getClass(): Class[_]
-
def
hashCode(): Int
-
final
def
isInstanceOf[T0]: Boolean
-
-
final
def
notify(): Unit
-
final
def
notifyAll(): Unit
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
-
def
toString(): String
-
final
def
wait(): Unit
-
final
def
wait(arg0: Long, arg1: Int): Unit
-
final
def
wait(arg0: Long): Unit
-
def
→[B](y: B): (Streams[Stream], B)
Inherited by implicit conversion any2stringadd from
Streams[Stream] to any2stringadd[Streams[Stream]]
Inherited by implicit conversion StringFormat from
Streams[Stream] to StringFormat[Streams[Stream]]
Inherited by implicit conversion Ensuring from
Streams[Stream] to Ensuring[Streams[Stream]]
Inherited by implicit conversion ArrowAssoc from
Streams[Stream] to ArrowAssoc[Streams[Stream]]
Laws (using infix syntax):
append
forms a monoid in conjunction withempty
:empty append s == s
ands append empty == s
.(s1 append s2) append s3 == s1 append (s2 append s3)
And
push
is consistent with usingappend
to prepend a single chunk:push(c)(s) == chunk(c) append s
fail
propagates until being caught byonError
:fail(e) onError h == h(e)
fail(e) append s == fail(e)
fail(e) flatMap f == fail(e)
Stream
forms a monad withemit
andflatMap
:emit >=> f == f
f >=> emit == f
(f >=> g) >=> h == f >=> (g >=> h)
whereemit(a)
is defined aschunk(Chunk.singleton(a)) and
f >=> gis defined as
a => a flatMap f flatMap gThe monad is the list-style sequencing monad:
(a append b) flatMap f == (a flatMap f) append (b flatMap f)
empty flatMap f == empty