Stream

korolev.effect.Stream
See theStream companion object
abstract class Stream[F[_], A]

Attributes

Companion:
object
Graph
Supertypes
class Object
trait Matchable
class Any
Known subtypes
class Decoder[F, A]
Self type
Stream[F, A]

Members list

Concise view

Value members

Abstract methods

def cancel(): F[Unit]
def pull(): F[Option[A]]

Concrete methods

def ++(rhs: Stream[F, A]): Stream[F, A]

Attributes

See also:

concat

def buffer(duration: FiniteDuration, maxSize: Int)(implicit scheduler: Scheduler[F], ec: ExecutionContext, reporter: Reporter): Stream[F, Seq[A]]
def collect[B](f: PartialFunction[A, B]): Stream[F, B]
def concat(rhs: Stream[F, A]): Stream[F, A]

Sequently concat two streams

Sequently concat two streams

 Stream(1,2,3) ++ Stream(4,5,6)
 // 1,2,3,4,5,6

Attributes

def flatMap[B](f: A => Stream[F, B]): Stream[F, B]

Attributes

See also:

flatMapConcat

def flatMapAsync[B](f: A => F[Stream[F, B]]): Stream[F, B]
def flatMapConcat[B](f: A => Stream[F, B]): Stream[F, B]

Merges underlying streams to one line.

Merges underlying streams to one line.

 Stream.eval(1, 2, 3) flatMapConcat { x =>
   Stream.eval(x + "a", x + "b", x + "c")
 }
 // 1a,1b,1c,2a,2b,2c,3a,3b,3c

Attributes

def flatMapMerge[B](concurrency: Int)(f: A => Stream[F, B]): Stream[F, B]

Merges underlying streams concurrently.

Merges underlying streams concurrently.

Attributes

concurrency

number of concurrent underlying streams

 Stream.eval(1, 2, 3) flatMapMerge(3) { x =>
   Stream.eval(x + "a", x + "b", x + "c")
 }
 // 1a,2a,3a,1b,2b,3b,1c,2c,3c
def flatMapMergeAsync[B](concurrency: Int)(f: A => F[Stream[F, B]]): Stream[F, B]
def fold[B](default: B)(f: (B, A) => B): F[B]
def foldAsync[B](default: B)(f: (B, A) => F[B]): F[B]
def foreach(f: A => F[Unit]): F[Unit]
def handleConsumed: (F[Unit], Stream[F, A])
def map[B](f: A => B): Stream[F, B]
def mapAsync[B](f: A => F[B]): Stream[F, B]
def over[B](default: B)(f: (B, Option[A]) => F[B]): Stream[F, A]

React on values of the stream keeping it the same. Useful when you want to track progress of downloading.

React on values of the stream keeping it the same. Useful when you want to track progress of downloading.

 file
   .over(0L) {
     case (acc, chunk) =>
       val loaded = chunk.fold(acc)(_.length.toLong + acc)
       showProgress(loaded, file.bytesLength)
   }
   .to(s3bucket("my-large-file"))

Attributes

def sort(numRacks: Int)(f: A => Int): List[Stream[F, A]]

Sort elements of the stream between "racks".

Sort elements of the stream between "racks".

 val List(girls, boys, queers) = persons.sort(3) {
   case person if person.isFemale => 0
   case person if person.isMale => 1
   case person => 2
 }

Attributes

f

Takes element of the stream return number of rack.

numRacks

Number of racks.

Returns:

List of streams appropriate to racks.

def tap[U](f: A => F[U]): Stream[F, A]
def to[U](f: Stream[F, A] => F[U]): F[U]