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[_]]: Apply[F]

   Returns an IterantBuilders instance for the specified F monadic type that can be used to build Iterant instances.

   Returns an IterantBuilders instance for the specified F monadic type that can be used to build Iterant instances.

   This is used to achieve the Partially-Applied Type technique.

   Example:

   import monix.eval.Task
   
   Iterant[Task].range(0, 10)

5.  final def asInstanceOf[T0]: T0

   Definition Classes

   Any

6.  implicit def catsSyncInstances[F[_]](implicit F: Sync[F]): CatsSyncInstances[F]

   Provides the cats.effect.Sync instance for Iterant.

   Provides the cats.effect.Sync instance for Iterant.

   Definition Classes

   IterantInstances

7.  def channel[F[_], A](bufferCapacity: BufferCapacity = Bounded(recommendedBufferChunkSize), maxBatchSize: Int = recommendedBufferChunkSize, producerType: ProducerSide = MultiProducer)(implicit F: Concurrent[F], cs: ContextShift[F]): F[(Producer[F, A], Iterant[F, A])]

   Returns a ProducerF instance, along with an Iterant connected to it.

   Returns a ProducerF instance, along with an Iterant connected to it.

   Internally a ConcurrentChannel is used, the paired Iterant acting as a ConsumerF, connecting via ConcurrentChannel.consume.

   bufferCapacity

   is the capacity of the internal buffer being created per evaluated Iterant stream

   maxBatchSize

   is the maximum size of the Iterant.NextBatch nodes being emitted; this determines the maximum number of events being processed at any one time

   producerType

   (UNSAFE) specifies if there are multiple concurrent producers that will push events on the channel, or not; MultiProducer is the sane, default choice; only use SingleProducer for optimization purposes, for when you know what you're doing

8.  def clone(): AnyRef

   Attributes

   protected[lang]

   Definition Classes

   AnyRef

   Annotations

   @throws(classOf[java.lang.CloneNotSupportedException]) @native()

9.  def concat[F[_], A](xs: Iterant[F, A]*)(implicit F: Sync[F]): Iterant[F, A]

   Concatenates list of Iterants into a single stream

10.  def concatS[F[_], A](lh: F[Iterant[F, A]], rh: F[Iterant[F, A]]): Iterant[F, A]

    Builds a stream state equivalent with Iterant.Concat.

    Builds a stream state equivalent with Iterant.Concat.

    The Concat state of the Iterant represents a state that specifies the concatenation of two streams.

    lh

    is the left hand side of the concatenation, to be processed before the right-hand side

    rh

    is the rest of the stream, to be processed after the left-hand side is

11.  def defer[F[_], A](fa: => Iterant[F, A])(implicit F: Sync[F]): Iterant[F, A]

    Alias for suspend.

    Alias for suspend.

    Promote a non-strict value representing a stream to a stream of the same type, effectively delaying its initialisation.

    fa

    is the by-name parameter that will generate the stream when evaluated

12.  def delay[F[_], A](a: => A)(implicit F: Sync[F]): Iterant[F, A]

    Alias for eval.

13.  def empty[F[_], A]: Iterant[F, A]

    Returns an empty stream.

14.  final def eq(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

15.  def equals(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef → Any

16.  def eval[F[_], A](a: => A)(implicit F: Sync[F]): Iterant[F, A]

    Lifts a non-strict value into the stream context, returning a stream of one element that is lazily evaluated.

17.  def finalize(): Unit

    Attributes

    protected[lang]

    Definition Classes

    AnyRef

    Annotations

    @throws(classOf[java.lang.Throwable])

18.  def fromArray[F[_], A](xs: Array[A])(implicit F: Applicative[F]): Iterant[F, A]

    Converts any standard Array into a stream.

19.  def fromBatch[F[_], A](xs: Batch[A])(implicit F: Applicative[F]): Iterant[F, A]

    Converts a Batch into a stream.

20.  def fromBatchCursor[F[_], A](xs: BatchCursor[A])(implicit F: Applicative[F]): Iterant[F, A]

    Converts a BatchCursor into a stream.

21.  def fromChannel[F[_], A](channel: Channel[F, A], bufferCapacity: BufferCapacity = Bounded(recommendedBufferChunkSize), maxBatchSize: Int = recommendedBufferChunkSize)(implicit F: Async[F]): Iterant[F, A]

    Transforms any monix.catnap.ChannelF into an Iterant stream.

    Transforms any monix.catnap.ChannelF into an Iterant stream.

    This allows for example consuming from a ConcurrentChannel.

    channel

    is the monix.catnap.ChannelF value from which the created stream will consume events

    bufferCapacity

    is the capacity of the internal buffer being created; it can be either of limited capacity or unbounded

    maxBatchSize

    is the maximum size of the emitted Iterant.NextBatch nodes, effectively specifying how many items can be pulled from the queue and processed in batches

22.  def fromConsumer[F[_], A](consumer: Consumer[F, A], maxBatchSize: Int = recommendedBufferChunkSize)(implicit F: Async[F]): Iterant[F, A]

    Transforms any monix.catnap.ConsumerF into an Iterant stream.

    Transforms any monix.catnap.ConsumerF into an Iterant stream.

    This allows for example consuming from a ConcurrentChannel.

    consumer

    is the monix.catnap.ConsumerF value to transform into an Iterant

    maxBatchSize

    is the maximum size of the emitted Iterant.NextBatch nodes, effectively specifying how many items can be pulled from the queue and processed in batches

23.  def fromIndexedSeq[F[_], A](xs: IndexedSeq[A])(implicit F: Applicative[F]): Iterant[F, A]

    Converts any Scala collection.IndexedSeq into a stream (e.g.

    Converts any Scala collection.IndexedSeq into a stream (e.g. Vector).

24.  def fromIterable[F[_], A](xs: Iterable[A])(implicit F: Applicative[F]): Iterant[F, A]

    Converts a scala.collection.Iterable into a stream.

25.  def fromIterator[F[_], A](xs: Iterator[A])(implicit F: Applicative[F]): Iterant[F, A]

    Converts a scala.collection.Iterator into a stream.

26.  def fromLazyStateAction[F[_], S, A](f: (S) => F[(A, S)])(seed: => F[S])(implicit F: Sync[F]): Iterant[F, A]

    Given an initial state and a generator function that produces the next state and the next element in the sequence in F[_] context, creates an Iterant that keeps generating Next items produced by our generator function.

    Given an initial state and a generator function that produces the next state and the next element in the sequence in F[_] context, creates an Iterant that keeps generating Next items produced by our generator function.

    Example:

    import monix.eval.Task
    
    val f = (x: Int) => Task((x + 1, x * 2))
    val seed = Task.pure(1)
    val stream = Iterant.fromLazyStateAction[Task, Int, Int](f)(seed)
    
    // Yields 2, 3, 5, 9
    stream.take(5)

    See also

    fromStateAction for version without F[_] context which generates NextBatch items

27.  def fromList[F[_], A](xs: LinearSeq[A])(implicit F: Applicative[F]): Iterant[F, A]

    Converts any Scala collection.immutable.LinearSeq into a stream.

28.  def fromReactivePublisher[F[_], A](publisher: Publisher[A], requestCount: Int = recommendedBufferChunkSize, eagerBuffer: Boolean = true)(implicit F: Async[F]): Iterant[F, A]

    Given an org.reactivestreams.Publisher, converts it into an Iterant.

    Given an org.reactivestreams.Publisher, converts it into an Iterant.

    publisher

    is the org.reactivestreams.Publisher reference to wrap into an Iterant

    requestCount

    a strictly positive number, representing the size of the buffer used and the number of elements requested on each cycle when communicating demand, compliant with the reactive streams specification. If Int.MaxValue is given, then no back-pressuring logic will be applied (e.g. an unbounded buffer is used and the source has a license to stream as many events as it wants)

    eagerBuffer

    can activate or deactivate the "eager buffer" mode in which the buffer gets pre-filled before the Iterant's consumer is ready to process it — this prevents having pauses due to back-pressuring the Subscription.request(n) calls

    See also

    Iterant.toReactivePublisher for converting an Iterant to a reactive publisher.

29.  def fromResource[F[_], A](r: Resource[F, A])(implicit F: Sync[F]): Iterant[F, A]

    Transforms any cats.effect.Resource into an Iterant.

    Transforms any cats.effect.Resource into an Iterant.

    See the documentation for Resource.

    import cats.effect.Resource
    import cats.effect.IO
    import java.io._
    
    def openFileAsResource(file: File): Resource[IO, FileInputStream] =
      Resource.make(IO(new FileInputStream(file)))(h => IO(h.close()))
    
    def openFileAsStream(file: File): Iterant[IO, FileInputStream] =
      Iterant[IO].fromResource(openFileAsResource(file))

    This example would be equivalent with usage of Iterant.resource:

    def openFileAsResource2(file: File): Iterant[IO, FileInputStream] = {
      Iterant.resource(IO(new FileInputStream(file)))(h => IO(h.close()))
    }

    This means that flatMap is safe to use:

    def readLines(file: File): Iterant[IO, String] =
      openFileAsStream(file).flatMap { in =>
        val buf = new BufferedReader(new InputStreamReader(in, "utf-8"))
        Iterant[IO].repeatEval(buf.readLine())
          .takeWhile(_ != null)
      }

30.  def fromSeq[F[_], A](xs: Seq[A])(implicit F: Applicative[F]): Iterant[F, A]

    Converts any scala.collection.Seq into a stream.

31.  def fromStateAction[F[_], S, A](f: (S) => (A, S))(seed: => S)(implicit F: Sync[F]): Iterant[F, A]

    Given an initial state and a generator function that produces the next state and the next element in the sequence, creates an Iterant that keeps generating NextBatch items produced by our generator function with default recommendedBatchSize.

    Given an initial state and a generator function that produces the next state and the next element in the sequence, creates an Iterant that keeps generating NextBatch items produced by our generator function with default recommendedBatchSize.

    Example:

    import monix.eval.Task
    
    val f = (x: Int) => (x + 1, x * 2)
    val seed = 1
    val stream = Iterant.fromStateAction[Task, Int, Int](f)(seed)
    
    // Yields 2, 3, 5, 9
    stream.take(5)

    See also

    fromLazyStateAction for version supporting F[_] in result of generator function and seed element

32.  final def getClass(): Class[_ <: AnyRef]

    Definition Classes

    AnyRef → Any

    Annotations

    @native()

33.  def haltS[F[_], A](e: Option[Throwable]): Iterant[F, A]

    Data constructor for building a Iterant.Halt value.

    Data constructor for building a Iterant.Halt value.

    The Halt state of the Iterant represents the completion state of a stream, with an optional exception if an error happened.

    Halt is received as a final state in the iteration process. This state cannot be followed by any other element and represents the end of the stream.

    e

    is an error to signal at the end of the stream, or None in case the stream has completed normally

34.  def hashCode(): Int

    Definition Classes

    AnyRef → Any

    Annotations

    @native()

35.  def intervalAtFixedRate[F[_]](initialDelay: FiniteDuration, period: FiniteDuration)(implicit F: Async[F], timer: Timer[F]): Iterant[F, Long]

    Creates an iterant that emits auto-incremented natural numbers (longs).

    Creates an iterant that emits auto-incremented natural numbers (longs). at a fixed rate, as given by the specified period. The amount of time it takes to process an incoming value gets subtracted from provided period, thus created iterant tries to emit events spaced by the given time interval, regardless of how long further processing takes

    This version of the intervalAtFixedRate allows specifying an initialDelay before first value is emitted

    initialDelay

    initial delay before emitting the first value

    period

    period between 2 successive emitted values

    timer

    is the timer implementation used to generate delays and to fetch the current time

36.  def intervalAtFixedRate[F[_]](period: FiniteDuration)(implicit F: Async[F], timer: Timer[F]): Iterant[F, Long]

    Creates an iterant that emits auto-incremented natural numbers (longs).

    Creates an iterant that emits auto-incremented natural numbers (longs). at a fixed rate, as given by the specified period. The amount of time it takes to process an incoming value gets subtracted from provided period, thus created iterant tries to emit events spaced by the given time interval, regardless of how long further processing takes

    period

    period between 2 successive emitted values

    timer

    is the timer implementation used to generate delays and to fetch the current time

37.  def intervalWithFixedDelay[F[_]](initialDelay: FiniteDuration, delay: FiniteDuration)(implicit F: Async[F], timer: Timer[F]): Iterant[F, Long]

    Creates an iterant that emits auto-incremented natural numbers (longs) spaced by a given time interval.

    Creates an iterant that emits auto-incremented natural numbers (longs) spaced by a given time interval. Starts from 0 with no delay, after which it emits incremented numbers spaced by the period of time. The given period of time acts as a fixed delay between successive events.

    initialDelay

    is the delay to wait before emitting the first event

    delay

    the time to wait between 2 successive events

    timer

    is the timer implementation used to generate delays and to fetch the current time

38.  def intervalWithFixedDelay[F[_]](delay: FiniteDuration)(implicit F: Async[F], timer: Timer[F]): Iterant[F, Long]

    Creates an iterant that emits auto-incremented natural numbers (longs) spaced by a given time interval.

    Creates an iterant that emits auto-incremented natural numbers (longs) spaced by a given time interval. Starts from 0 with no delay, after which it emits incremented numbers spaced by the period of time. The given period of time acts as a fixed delay between successive events.

    Without having an initial delay specified, this overload will immediately emit the first item, without any delays.

    delay

    the time to wait between 2 successive events

    timer

    is the timer implementation used to generate delays and to fetch the current time

39.  final def isInstanceOf[T0]: Boolean

    Definition Classes

    Any

40.  def lastS[F[_], A](item: A): Iterant[F, A]

    Builds a stream state equivalent with Iterant.Last.

    Builds a stream state equivalent with Iterant.Last.

    The Last state of the Iterant represents a completion state as an alternative to Halt(None), describing one last element.

    It is introduced as an optimization, being equivalent to Next(item, F.pure(Halt(None)), F.unit), to avoid extra processing in the monadic F[_] and to short-circuit operations such as concatenation and flatMap.

    item

    is the last element being signaled, after which the consumer can stop the iteration

41.  def liftF[F[_], A](fa: F[A])(implicit F: Functor[F]): Iterant[F, A]

    Lifts a value from monadic context into the stream context, returning a stream of one element

42.  final def ne(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

43.  def never[F[_], A](implicit F: Async[F]): Iterant[F, A]

    Returns a stream that never emits any event and never completes.

44.  def nextBatchS[F[_], A](items: Batch[A], rest: F[Iterant[F, A]]): Iterant[F, A]

    Data constructor for building a Iterant.NextBatch value.

    Data constructor for building a Iterant.NextBatch value.

    The NextBatch state of the Iterant represents an batch / rest cons pair, where batch is an Iterable type that can generate a whole batch of elements.

    items

    is a Iterable type that can generate elements by traversing a collection, a standard array or any Iterable

    rest

    is the next state in the sequence that will produce the rest of the stream when evaluated

45.  def nextCursorS[F[_], A](items: BatchCursor[A], rest: F[Iterant[F, A]]): Iterant[F, A]

    Data constructor for building a Iterant.NextCursor value.

    Data constructor for building a Iterant.NextCursor value.

    The NextCursor state of the Iterant represents an batch / rest cons pair, where batch is an Iterator type that can generate a whole batch of elements.

    Useful for doing buffering, or by giving it an empty iterator, useful to postpone the evaluation of the next element.

    items

    is an Iterator type that can generate elements by traversing a collection, a standard array or any Iterator

    rest

    is the next state in the sequence that will produce the rest of the stream when evaluated

46.  def nextS[F[_], A](item: A, rest: F[Iterant[F, A]]): Iterant[F, A]

    Data constructor for building a Iterant.Next value.

    Data constructor for building a Iterant.Next value.

    The Next state of the Iterant represents a item / rest cons pair, where the head item is a strict value.

    Note that item being a strict value means that it is already known, whereas the rest is meant to be lazy and can have asynchronous behavior as well, depending on the F type used.

    See NextCursor for a state where the head is a strict immutable list.

    item

    is the current element to be signaled

    rest

    is the next state in the sequence that will produce the rest of the stream when evaluated

47.  final def notify(): Unit

    Definition Classes

    AnyRef

    Annotations

    @native()

48.  final def notifyAll(): Unit

    Definition Classes

    AnyRef

    Annotations

    @native()

49.  def now[F[_], A](a: A): Iterant[F, A]

    Lifts a strict value into the stream context, returning a stream of one element.

50.  def pure[F[_], A](a: A): Iterant[F, A]

    Alias for now.

51.  def raiseError[F[_], A](ex: Throwable): Iterant[F, A]

    Returns an empty stream that ends with an error.

52.  def range[F[_]](from: Int, until: Int, step: Int = 1)(implicit F: Applicative[F]): Iterant[F, Int]

    Builds a stream that on evaluation will produce equally spaced values in some integer interval.

    Builds a stream that on evaluation will produce equally spaced values in some integer interval.

    from

    the start value of the stream

    until

    the end value of the stream (exclusive from the stream)

    step

    the increment value of the tail (must be positive or negative)

    returns

    the tail producing values from, from + step, ... up to, but excluding until

53.  def repeat[F[_], A](elems: A*)(implicit F: Sync[F]): Iterant[F, A]

    Builds a stream that repeats the items provided in argument.

    Builds a stream that repeats the items provided in argument.

    It terminates either on error or if the source is empty.

54.  def repeatEval[F[_], A](thunk: => A)(implicit F: Sync[F]): Iterant[F, A]

    Builds a stream that suspends provided thunk and evaluates it indefinitely on-demand.

    Builds a stream that suspends provided thunk and evaluates it indefinitely on-demand.

    The stream will only terminate if evaluation throws an exception

    Referentially transparent alternative to Iterator.continually

    Example: infinite sequence of random numbers

    import monix.eval.Coeval
    import scala.util.Random
    
    val randomInts = Iterant[Coeval].repeatEval(Random.nextInt())

55.  def repeatEvalF[F[_], A](fa: F[A])(implicit F: Sync[F]): Iterant[F, A]

    Builds a stream that evaluates provided effectful values indefinitely.

    Builds a stream that evaluates provided effectful values indefinitely.

    The stream will only terminate if an error is raised in F context

56.  def resource[F[_], A](acquire: F[A])(release: (A) => F[Unit])(implicit F: Sync[F]): Iterant[F, A]

    Creates a stream that depends on resource allocated by a monadic value, ensuring the resource is released.

    Creates a stream that depends on resource allocated by a monadic value, ensuring the resource is released.

    Typical use-cases are working with files or network sockets

    Example:

    import cats.implicits._
    import cats.effect.IO
    import java.io.PrintWriter
    
    val printer =
      Iterant.resource {
        IO(new PrintWriter("./lines.txt"))
      } { writer =>
        IO(writer.close())
      }
    
    // Safely use the resource, because the release is
    // scheduled to happen afterwards
    val writeLines = printer.flatMap { writer =>
      Iterant[IO]
        .fromIterator(Iterator.from(1))
        .mapEval(i => IO { writer.println(s"Line #$$i") })
    }
    
    // Write 100 numbered lines to the file
    // closing the writer when finished
    writeLines.take(100).completedL

    acquire

    resource to acquire at the start of the stream

    release

    function that releases the acquired resource

57.  def resourceCase[F[_], A](acquire: F[A])(release: (A, ExitCase[Throwable]) => F[Unit])(implicit F: Sync[F]): Iterant[F, A]

    Creates a stream that depends on resource allocated by a monadic value, ensuring the resource is released.

    Creates a stream that depends on resource allocated by a monadic value, ensuring the resource is released.

    Typical use-cases are working with files or network sockets

    Example:

    import cats.effect._
    import java.io.PrintWriter
    
    val printer =
      Iterant.resource {
        IO(new PrintWriter("./lines.txt"))
      } { writer =>
        IO(writer.close())
      }
    
    // Safely use the resource, because the release is
    // scheduled to happen afterwards
    val writeLines = printer.flatMap { writer =>
      Iterant[IO]
        .fromIterator(Iterator.from(1))
        .mapEval(i => IO { writer.println(s"Line #$$i") })
    }
    
    // Write 100 numbered lines to the file
    // closing the writer when finished
    writeLines.take(100).completedL

    acquire

    an effect that acquires an expensive resource

    release

    function that releases the acquired resource

58.  def scopeS[F[_], A, B](acquire: F[A], use: (A) => F[Iterant[F, B]], release: (A, ExitCase[Throwable]) => F[Unit]): Iterant[F, B]

    Builds a stream state equivalent with Iterant.Scope.

    Builds a stream state equivalent with Iterant.Scope.

    The Scope state of the Iterant represents a stream that is able to specify the acquisition and release of a resource, to be used in generating stream events.

    Scope is effectively the encoding of Bracket, necessary for safe handling of resources. The use parameter is supposed to trigger a side effectful action that allocates resources, which are then used via use and released via close.

    Note that this is often used in combination with Suspend and data types like cats.effect.concurrent.Ref in order to communicate the acquired resources between open, use and close.

    acquire

    is an effect that should allocate necessary resources to be used in use and released in close

    use

    is the stream created via this scope

    release

    is an effect that should deallocate acquired resources via open and that will be executed no matter what

59.  def suspend[F[_], A](rest: F[Iterant[F, A]]): Iterant[F, A]

    Defers the stream generation to the underlying evaluation context (e.g.

    Defers the stream generation to the underlying evaluation context (e.g. Task, Coeval, IO, etc), building a reference equivalent with Iterant.Suspend.

    The Suspend state of the Iterant represents a suspended stream to be evaluated in the F context. It is useful to delay the evaluation of a stream by deferring to F.

    rest

    is the next state in the sequence that will produce the rest of the stream when evaluated

60.  def suspend[F[_], A](fa: => Iterant[F, A])(implicit F: Sync[F]): Iterant[F, A]

    Promote a non-strict value representing a stream to a stream of the same type, effectively delaying its initialisation.

    Promote a non-strict value representing a stream to a stream of the same type, effectively delaying its initialisation.

    fa

    is the by-name parameter that will generate the stream when evaluated

61.  def suspendS[F[_], A](rest: F[Iterant[F, A]]): Iterant[F, A]

    Builds a stream state equivalent with Iterant.NextCursor.

    Builds a stream state equivalent with Iterant.NextCursor.

    The Suspend state of the Iterant represents a suspended stream to be evaluated in the F context. It is useful to delay the evaluation of a stream by deferring to F.

    rest

    is the next state in the sequence that will produce the rest of the stream when evaluated

62.  final def synchronized[T0](arg0: => T0): T0

    Definition Classes

    AnyRef

63.  def tailRecM[F[_], A, B](a: A)(f: (A) => Iterant[F, Either[A, B]])(implicit F: Sync[F]): Iterant[F, B]

    Keeps calling f and concatenating the resulting iterants for each scala.util.Left event emitted by the source, concatenating the resulting iterants and generating events out of scala.util.Right[B] values.

    Keeps calling f and concatenating the resulting iterants for each scala.util.Left event emitted by the source, concatenating the resulting iterants and generating events out of scala.util.Right[B] values.

    Based on Phil Freeman's Stack Safety for Free.

64.  def toString(): String

    Definition Classes

    AnyRef → Any

65.  final def wait(): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws(classOf[java.lang.InterruptedException])

66.  final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws(classOf[java.lang.InterruptedException])

67.  final def wait(arg0: Long): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws(classOf[java.lang.InterruptedException]) @native()