trait
Streams[Stream[+_[_], +_]] extends AnyRef
Type Members
-
type
AsyncStep[F[_], A] = Future[F, Pull[F, Nothing, Step[Chunk[A], Handle[F, A]]]]
-
type
AsyncStep1[F[_], A] = Future[F, Pull[F, Nothing, Step[Option[A], Handle[F, A]]]]
-
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, Either[Throwable, A]]
-
abstract
def
await[F[_], A](h: Handle[F, A]): Pull[F, Nothing, Step[Chunk[A], Handle[F, 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](p: 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](p: Stream[F, A], z: B)(f: (B, A) ⇒ B): Free[F, B]
-
abstract
def
runFoldTraceFree[F[_], A, B](t: Trace)(p: 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]
-
final
def
eq(arg0: AnyRef): Boolean
-
def
equals(arg0: Any): Boolean
-
def
finalize(): Unit
-
def
formatted(fmtstr: String): String
-
final
def
getClass(): Class[_]
-
def
hashCode(): Int
-
final
def
isInstanceOf[T0]: Boolean
-
final
def
ne(arg0: AnyRef): 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 from AnyRef
Inherited from Any
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):
appendforms a monoid in conjunction withempty:empty append p == pandp append empty == p.(p1 append p2) append p3 == p1 append (p2 append p3)And
pushis consistent with usingappendto prepend a single chunk:push(c)(s) == chunk(c) append sfailpropagates until being caught byonError:fail(e) onError h == h(e)fail(e) append s == fail(e)fail(e) flatMap f == fail(e)Streamforms a monad withemitandflatMap:emit >=> f == ff >=> emit == f(f >=> g) >=> h == f >=> (g >=> h)whereemit(a)is defined aschunk(Chunk.singleton(a)) andf >=> gis defined asa => 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