Packages

object Stream

Source
Stream.scala
Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Stream
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. implicit final class PipeOps [F[_], I, O] extends AnyVal

    Provides operations on effectful pipes for syntactic convenience.

  2. implicit final class PurePipeOps [I, O] extends AnyVal

    Provides operations on pure pipes for syntactic convenience.

  3. implicit final class StreamInvariantOps [F[_], O] extends AnyVal
  4. implicit final class StreamOptionOps [F[_], O] extends AnyVal
  5. implicit final class StreamPureOps [+O] extends AnyVal

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. def apply[F[_], A](a: A*): Stream[F, A]
  5. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  6. def attemptEval[F[_], A](fa: F[A]): Stream[F, Attempt[A]]
  7. def bracket[F[_], R, A](r: F[R])(use: (R) ⇒ Stream[F, A], release: (R) ⇒ F[Unit]): Stream[F, A]
  8. def chunk[F[_], A](as: Chunk[A]): Stream[F, A]
  9. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  10. def cons[F[_], O](h: Stream[F, O])(c: Chunk[O]): Stream[F, O]
  11. def constant[F[_], A](a: A, chunkSize: Int = 1): Stream[F, A]

    The infinite Stream, always emits a.

    The infinite Stream, always emits a. If for performance reasons it is good to emit a in chunks, specify size of chunk by chunkSize parameter

  12. implicit def covaryPure[F[_], O](s: Stream[Pure, O]): Stream[F, O]
  13. implicit def covaryPurePipe[F[_], I, O](p: Pipe[Pure, I, O]): Pipe[F, I, O]
  14. implicit def covaryPurePipe2[F[_], I, I2, O](p: Pipe2[Pure, I, I2, O]): Pipe2[F, I, I2, O]
  15. def emit[F[_], A](a: A): Stream[F, A]
  16. def emits[F[_], A](a: Seq[A]): Stream[F, A]
  17. def empty[F[_], A]: Stream[F, A]
  18. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  19. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  20. def eval[F[_], A](fa: F[A]): Stream[F, A]
  21. def evalScope[F[_], A](fa: Scope[F, A]): Stream[F, A]
  22. def eval_[F[_], A](fa: F[A]): Stream[F, Nothing]
  23. def fail[F[_]](e: Throwable): Stream[F, Nothing]
  24. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  25. def force[F[_], A](f: F[Stream[F, A]]): Stream[F, A]
  26. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
  27. def hashCode(): Int
    Definition Classes
    AnyRef → Any
  28. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  29. def iterate[F[_], A](start: A)(f: (A) ⇒ A): Stream[F, A]

    An infinite Stream that repeatedly applies a given function to a start value.

    An infinite Stream that repeatedly applies a given function to a start value. start is the first value emitted, followed by f(start), then f(f(start)), and so on.

  30. def iterateEval[F[_], A](start: A)(f: (A) ⇒ F[A]): Stream[F, A]

    Like iterate, but takes an effectful function for producing the next state.

    Like iterate, but takes an effectful function for producing the next state. start is the first value emitted.

  31. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  32. final def notify(): Unit
    Definition Classes
    AnyRef
  33. final def notifyAll(): Unit
    Definition Classes
    AnyRef
  34. def pure[A](a: A*): Stream[Pure, A]
  35. def range[F[_]](start: Int, stopExclusive: Int, by: Int = 1): Stream[F, Int]

    Lazily produce the range [start, stopExclusive).

    Lazily produce the range [start, stopExclusive). If you want to produce the sequence in one chunk, instead of lazily, use emits(start until stopExclusive).

  36. def ranges[F[_]](start: Int, stopExclusive: Int, size: Int): Stream[F, (Int, Int)]

    Lazily produce a sequence of nonoverlapping ranges, where each range contains size integers, assuming the upper bound is exclusive.

    Lazily produce a sequence of nonoverlapping ranges, where each range contains size integers, assuming the upper bound is exclusive. Example: ranges(0, 1000, 10) results in the pairs (0, 10), (10, 20), (20, 30) ... (990, 1000)

    Note: The last emitted range may be truncated at stopExclusive. For instance, ranges(0,5,4) results in (0,4), (4,5).

    Exceptions thrown

    scala.IllegalArgumentException if size <= 0

  37. def repeatEval[F[_], A](a: F[A]): Stream[F, A]
  38. implicit def streamCatchableInstance[F[_]]: Catchable[[a]Stream[F, a]]
  39. def suspend[F[_], A](s: ⇒ Stream[F, A]): Stream[F, A]
  40. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  41. def toString(): String
    Definition Classes
    AnyRef → Any
  42. def unfold[F[_], S, A](s0: S)(f: (S) ⇒ Option[(A, S)]): Stream[F, A]

    Produce a (potentially infinite) stream from an unfold.

  43. def unfoldEval[F[_], S, A](s0: S)(f: (S) ⇒ F[Option[(A, S)]]): Stream[F, A]

    Like unfold, but takes an effectful function.

  44. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  45. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  46. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

Inherited from AnyRef

Inherited from Any

Ungrouped