Stream.Flow

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.

Value check

Returns true if flow contains given value

All count

Counts all flow elements

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

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}

Pump flow out

Fetches and discards all flow elements

This operation can be usefull for side effects built into pipeline

Reverse filter

Disallows Stream.Flow elements satisfying the given function

Exists check

Returns true if there is an elemnet satisfying given predicate

Find value

Finds value accepted by given predicate

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

Find optional any value

Finds any value or returns void option if not found

Find optional value

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

Flat map

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

Fold

Folds elements with a binary function

Fold and convert

Folds and converts elements with a binary function

Process flow

Applies given function to each flow element

Forall check

Returns true if every single element satisfies the given predicate

Parallel check

Returns true if this Parallel is parallel

Simple map

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

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

Maximum

Computes maximum value

Fails for empty streams

Maximum by property

Computes maximum value based on given function

Fails for empty streams

Optional maximum by property

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

Optional maximum

Computes maximum value or returns void option for empty streams

Minimum

Computes minimum value

Fails for empty streams

Minimum by property

Computes minimum value based on given function

Fails for empty streams

Optional minimum by property

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

Optional minimum

Computes minimum value or returns void option for empty streams

Inspect

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

Indexed peek

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

Range

Computes value range

Fails for empty streams

Optional range

Computes value value or returns void option for empty streams

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

Optional reduce

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

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)

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)

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

Sum

Calculates sum of all values

For empty stream returns zero

Filter

Only allow Stream.Flow elements satisfying the given function

Type filter

Only lets elements of specified type