Stream.Flow

abstract class Flow[A] extends _build[A] with _use[A] with _metadata[A]

Stream Flow

Flow is similar to stream, but without sequence specific methods.

Elements of Flow can be processed either in parallel or sequentially.

Flow is usually created from stream with ".parallel" method.

  val flow: Stream.Flow[Int] = (1 <> 10).stream.parallel
Source
__.scala
trait _metadata[Stream.Flow.A]
trait _use[Stream.Flow.A]
trait _build[Stream.Flow.A]
class java.lang.Object
trait scala.Matchable
class Any
class Stream.Custom.Pipeline.ParallelFlow[Stream.Custom.Pipeline.ParallelFlow.A]

Def

def collect[B](f: scala.PartialFunction[A, B]): Stream.Flow[B]

Partial map

Partial map

Creates a new Stream.Flow by applying a partial function to all elements of current Stream.Flow on which the function is defined.

Inherited from
_build
Source
_build.scala
def contains[B >: A](value: B): Boolean

Value check

Value check

Returns true if flow contains given value

Inherited from
_use
Source
_use.scala
def count: Int

All count

All count

Counts all flow elements

Inherited from
_use
Source
_use.scala

Count and time

Count and time

Returns all elements count and Time.Length it took to pump the flow

  val (cnt,time) = (1 <> 1000).stream.parallel.peek(_ => J.sleep(1.Millis)).countAndTime

  ("" + cnt + " elements processed in " + time.tag).tp

  // Output
  1000 elements processed in 0.040820901 sec

Note. Only massively parallel execution allowed to process the above example in 0.04 seconds

Inherited from
_use
Source
_use.scala

Tree description

Tree description

Returns a tree describing all flow trasformations

 ('a' <> 'z').stream
    .take(_ > 'X')
    .map(_.toUpper)
    .parallel
    .docTree.tp

 // Output
  scalqa.val.stream.z.flow.parallel.JavaStreamParallelFlow@ncwo{}
    scalqa.lang.char.g.stream.z.map$Chars@uru4{raw=Char,fromRaw=Char}
      scalqa.lang.char.g.Stream$TakeStream$2@56u4{raw=Char,fromRaw=Char}
        scalqa.lang.char.g.stream.Z$Stream_fromRange@cq06{raw=Char,size=26,from=a,step=1}
Inherited from
_metadata
Source
_metadata.scala
def drain: Unit

Pump flow out

Pump flow out

Fetches and discards all flow elements

This operation can be usefull for side effects built into pipeline

Inherited from
_use
Source
_use.scala
def drop(f: A => Boolean): Stream.Flow[A]

Reverse filter

Reverse filter

Disallows Stream.Flow elements satisfying the given function

Inherited from
_build
Source
_build.scala
def exists(f: A => Boolean): Boolean

Exists check

Exists check

Returns true if there is an elemnet satisfying given predicate

Inherited from
_use
Source
_use.scala
def find(f: A => Boolean): A

Find value

Find value

Finds value accepted by given predicate

Note: If value is not found operation fails, use findOpt in most cases

Inherited from
_use
Source
_use.scala
def findAnyOpt: Opt[A]

Find optional any value

Find optional any value

Finds any value or returns void option if not found

Inherited from
_use
Source
_use.scala
def findOpt(f: A => Boolean): Opt[A]

Find optional value

Find optional value

Finds value accepted by given predicate or returns void option if not found

Inherited from
_use
Source
_use.scala
def flatMap[B](f: A => Stream[B]): Stream.Flow[B]

Flat map

Flat map

Creates a new Stream.Flow by applying given function to all elements of current Stream.Flow and concatenating the results

Inherited from
_build
Source
_build.scala
def fold(start: A)(bf: (A, A) => A): A

Fold

Fold

Folds elements with a binary function

Value Params
f

binary function to fold elements with

start

seed value to start with

Inherited from
_use
Source
_use.scala
def foldAs[B](start: B)(bf: (B, A) => B, cf: (B, B) => B): B

Fold and convert

Fold and convert

Folds and converts elements with a binary function

Value Params
f

binary function to fold elements with

start

seed value to start with

Inherited from
_use
Source
_use.scala
def foreach[U](f: A => U): Unit

Process flow

Process flow

Applies given function to each flow element

Inherited from
_use
Source
_use.scala
def isEvery(f: A => Boolean): Boolean

Forall check

Forall check

Returns true if every single element satisfies the given predicate

Inherited from
_use
Source
_use.scala
def isParallel: Boolean

Parallel check

Parallel check

Returns true if this Parallel is parallel

Inherited from
_metadata
Source
_metadata.scala
def map[B](f: A => B): Stream.Flow[B]

Simple map

Simple map

Creates a new Stream.Flow where each element is a result of applying given function to current Stream.Flow elements

Inherited from
_build
Source
_build.scala
def mapOpt[B](f: A => Opt[B]): Stream.Flow[B]

Optional map

Optional map

Creates a new Stream.Flow where each element is a result of applying given function to current Stream.Flow elements

It the function returns void option, the elements are dropped

Inherited from
_build
Source
_build.scala
def max(using Ordering[A]): A

Maximum

Maximum

Computes maximum value

Fails for empty streams

Inherited from
_use
Source
_use.scala
def maxBy[B](f: A => B)(using Ordering[B]): A

Maximum by property

Maximum by property

Computes maximum value based on given function

Fails for empty streams

Inherited from
_use
Source
_use.scala
def maxByOpt[B](f: A => B)(using Ordering[B]): Opt[A]

Optional maximum by property

Optional maximum by property

Computes maximum value based on given function or returns void option for empty streams

Inherited from
_use
Source
_use.scala
def maxOpt(using Ordering[A]): Opt[A]

Optional maximum

Optional maximum

Computes maximum value or returns void option for empty streams

Inherited from
_use
Source
_use.scala
def min(using Ordering[A]): A

Minimum

Minimum

Computes minimum value

Fails for empty streams

Inherited from
_use
Source
_use.scala
def minBy[B](f: A => B)(using Ordering[B]): A

Minimum by property

Minimum by property

Computes minimum value based on given function

Fails for empty streams

Inherited from
_use
Source
_use.scala
def minByOpt[B](f: A => B)(using Ordering[B]): Opt[A]

Optional minimum by property

Optional minimum by property

Computes minimum value based on given function or returns void option for empty streams

Inherited from
_use
Source
_use.scala
def minOpt(using Ordering[A]): Opt[A]

Optional minimum

Optional minimum

Computes minimum value or returns void option for empty streams

Inherited from
_use
Source
_use.scala
def peek(c: A => Unit): Stream.Flow[A]

Inspect

Inspect

The given function will be run for every passing stream flow element.

Inherited from
_build
Source
_build.scala
def peekIndexed[U](c: (Int, A) => U, start: Int): Stream.Flow[A]

Indexed peek

Indexed peek

The given function will be executed for every passing element and its index.

Inherited from
_build
Source
_build.scala
def range(using Ordering[A]): Range[A]

Range

Range

Computes value range

Fails for empty streams

Inherited from
_use
Source
_use.scala
def rangeOpt(using Ordering[A]): Opt[Range[A]]

Optional range

Optional range

Computes value value or returns void option for empty streams

Inherited from
_use
Source
_use.scala
def reduce(bf: (A, A) => A): A

Reduce

Reduce

Folds elements with a binary function

Note. Threre is no default value, and if flow is empty, operation fails. Use reduceOpt as a safer option

Value Params
f

binary function to fold elements with

Inherited from
_use
Source
_use.scala
def reduceOpt(bf: (A, A) => A): Opt[A]

Optional reduce

Optional reduce

Folds elements with a binary function or returns empty option when stream is empty

Value Params
f

binary function to fold elements with

Inherited from
_use
Source
_use.scala

Optional long size

Optional long size

Many streams can return their current element count. If the information is not available, void option is returned

var s = (Int.min.Long <> Int.max.toLong).stream

s.sizeLongOpt.tp    // Prints Long.Opt(4294967296)

s = s.take(_ > 10)  // static sizing is lost

s.sizeLongOpt.tp    // Prints Long.Opt(VOID)
Inherited from
_metadata
Source
_metadata.scala

Optional size

Optional size

Many streams can return their current element count. If the information is not available, void option is returned

Note: If size is known, but exceeds integer range, void option is returned. For theses cases use sizeLongOpt

 var s = ('a' <> 'z').stream

 s.sizeOpt.tp         // Prints Int.Opt(26)

 s = s.take(_ > 10)   // static sizing is lost

 s.sizeOpt.tp         // Prints Int.Opt(VOID)
Inherited from
_metadata
Source
_metadata.scala
def stream: Stream[A]

Convert to stream

Convert to stream

Wraps Stream.Flow into regular stream.

If Stream.Flow is parallel, then this convertion can be very costly, and it is always prefferable to consume Stream.Flow without going back to Stream

Inherited from
_build
Source
_build.scala
def sum(using Math.Sum[A]): A

Sum

Sum

Calculates sum of all values

For empty stream returns zero

Inherited from
_use
Source
_use.scala
def take(f: A => Boolean): Stream.Flow[A]

Filter

Filter

Only allow Stream.Flow elements satisfying the given function

Inherited from
_build
Source
_build.scala
def takeType[B](`evidence$1`: scala.reflect.ClassTag[B]): Stream.Flow[B]

Type filter

Type filter

Only lets elements of specified type

Inherited from
_build
Source
_build.scala