_use

Average

Computes average

For empty Stream returns zero value

   (10 <> 15).stream.map(_.toFloat).average  // Returns 12.5

Note: average is available for types providing given Math.Average implementations, which are by default Double, Float and opaque numerals based on Double and Float

Multi average

Simultaneously computes up to 5 average values for properties specified by functions

Returns tuple of appropriate size with values corresponding to the given mappings

For empty Stream returned tuple will hold zeros

   (1 <> 1000).stream.averageFew(_ * 10F, _ * 100F).tp  // Prints (5005, 50050)

    val (first, second, third) = (1 <> 1000).stream.averageFew(v => v.toDouble, _ * 10.0, _ * 100.0)

    first.tp     // Prints 500.5
    second.tp    // Prints 5005.0
    third.tp     // Prints 50050.0

Note: Averages areavailable for types providing given Stream.Custom.Average implementations, which are by default Double, Float and opaque numerals based on Double and Float

Average option

Computes average or returns void option for empty stream

   (10 <> 15).stream.map(_.toFloat).averageOpt  // Returns Opt(12.5)

Note: averageOpt is available for types providing given Math.Average implementations, which are by default Double, Float and opaque numerals based on Double and Float

Value check

Returns true if stream contains given value.

Sequence check

Returns true if stream contains given sequence of values.

Conditional count

Counts all stream elements, which satisfy given predicate

All count

Counts all stream elements

Count and time

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

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

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

  // Output
  1000 elements processed in 1.488880500 sec

Multi count

Simultaneously counts values for up to 5 different predicates

Returns tuple of appropriate size with values corresponding to the given mappings

For empty Stream returned tuple will hold zeros

val (large, odd, even) = (1 <>> 1000).stream.countFew(_ > 100, _ % 2 == 0, _ % 2 == 1)

large.tp    // Prints 899
odd.tp      // Prints 499
even.tp     // Prints 500

Doc Tree description

Returns a tree describing all stream trasformations

('a' <> 'z').stream
 .map(_.toInt)
 .take(_ % 2 == 0)
 .docTree.tp

// Output
scalqa.lang.int.g.Stream$TakeStream$2@4ds1{raw=Int}
 scalqa.lang.char.z.stream.map$Ints@j38c{raw=Int,fromRaw=Char,size=26}
   scalqa.lang.char.Z$Stream_fromRange@gw1k{raw=Char,size=26,from=a,step=1}

Pump stream out

Fetches and discards all stream elements

This operation can be usefull for side effects built into streaming pipeline

 ('A' <> 'C').stream.peek(_.tp).drain

 // Output
 A
 B
 C

Equal check

Iterates both streams and compares all corresponding elements

Returns true if all are equal, `false`` otherwise

Equal check

Iterates both streams and compares all corresponding elements

When first not equal pair is found, the problem result is returned

If all elements are equal, Result[true] is returned

(0 <> 10).stream.equalsAllResult(0 <> 10).tp
// Prints: Result(true)

(0 <> 10).stream.equalsAllResult(0 <>> 10).tp
// Prints: Result(Problem(Second stream has less elements))

((0 <> 5).stream + 7 + 8).equalsAllResult(0 <> 10).tp
// Prints: Result(Problem(Fail at index 6: 7 != 6))

Note: The returned problem contains message with basic description

Exists check

Returns true if there is an elemnet satisfying given predicate

Find value

Finds the first value accepted by given predicate

 (1 <> 1000).stream.find(_ > 100).tp  // Prints 101

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

Optional find value

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

(1 <> 1000).stream.findOpt(_ > 100).tp   // Prints Opt(101)

(1 <> 10).stream.findOpt(_ > 100).tp     // Prints Opt(VOID)

Find index

Optionally returns index for the first element satisfying the predicate or Int.Opt(VOID) if none found

  (50 <> 500).stream.findPositionOpt(_ == 400)  // Retuns Int.Opt(350)

Find start index

Optionally returns index where given stream value sequence matches current stream values

Heavy Fold

Folds elements with a binary function

FOLD is functionally equivalent to fold, but is fully inlined. It makes compiled code larger, but guarantees the best possible performance on large streams.

Fold

Folds elements with a binary function

    // Calculate sum of first 1000 Ints

    (1 <> 1000).stream.fold(0)(_ + _) // Returns 500500

Heavy Fold and convert

Folds and converts elements with a binary function

FOLD_AS is functionally equivalent to foldAs, but is fully inlined. It makes compiled code larger, but guarantees the best possible performance on large streams.

Fold and convert

Folds and converts elements with a binary function

    // Calculate sum of first 1000 Ints

    (1 <> 1000).stream.foldAs(0L)(_ + _) // Returns 500500

Heavy process stream

Applies given function to each stream element

FOREACH is functionally equivalent to foreach, but is fully inlined. It makes compiled code larger, but guarantees the best possible performance on large streams.

Process stream

Applies given function to each stream element

 ('A' <> 'C').stream.foreach(_.tp)

 // Output
 A
 B
 C

For each indexed

Calls given function with counter

 ('A' <> 'C').stream.foreachIndexed((i,v) => "Element " + i + " = " + v tp(), 1)

 // Output
 Element 1 = A
 Element 2 = B
 Element 3 = C

Run for nonexistent value

Runs given function only if stream is empty.

This operation is rarely useful and is provided for consistency.

Use peekEmpty instead, it can be combined with other processing

Forall check

Returns true if every single element satisfies the given predicate

Iterator view

Wraps current stream as scala.collection.Iterator

Last element

Returns the last stream element

Fails if empty

Last element

Optionally returns the last element or Opt(VOID)

Convert to String

The result is a concatenation of all elements with given separator

   ('a' <> 'j').stream.makeString("")            // Returns abcdefghij

   ('a' <> 'j').stream.makeString("|")           // Returns a|b|c|d|e|f|g|h|i|j

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

Pack elements

Returns stream elements as Pack

Print to console

Prints stream elements in a table like structure

Tuples, case classes, products, and Able.Doc object properties are formatted as table columns

('A' <> 'F').stream.map(v => (v.Int, v)).print

// Output
-- --
_1 _2
-- --
65 A
66 B
67 C
68 D
69 E
70 F
-- --

// -----------------------------------------------------
case class Case(int: Int, name: String, odd: Boolean):
    def this(i: Int) = this(i, "Name"+i, i%2==0)

(1 <> 10).stream.map(new Case(_)).print

// Output
--- ------ -----
int name   odd
--- ------ -----
1   Name1  false
2   Name2  true
3   Name3  false
4   Name4  true
5   Name5  false
6   Name6  true
7   Name7  false
8   Name8  true
9   Name9  false
10  Name10 true
--- ------ -----

Print to console with rows numbered

Same as regular print, but with added row number as first column

('A' <> 'F').stream.map(v => (v.Int, v)).print_#

// Output
-- -- --
#  _1 _2
-- -- --
0  65 A
1  66 B
2  67 C
3  68 D
4  69 E
5  70 F
-- -- --

Note: Number is mostly usefull for longer or even infinite streams

Print to console with row id

Same as regular print, but with added first column identifying the object

('A' <> 'F').stream.map(v => (v.Int, v)).print

// Output
----------------- -- --
Id                _1 _2
----------------- -- --
scala.Tuple2@dzkr 65 A
scala.Tuple2@zn1  66 B
scala.Tuple2@71j3 67 C
scala.Tuple2@562u 68 D
scala.Tuple2@c8tt 69 E
scala.Tuple2@p0m8 70 F
----------------- -- --

Process elements or empty case

Applies given function to each stream element or runs second function when stream is empty

 ('A' <>> 'A').stream.process(_.tp, "Empty".tp)

 // Output
 Empty

Range

Computes value range

Fails for empty streams

Optional range

Computes value value or returns void option for empty streams

Next element

Delivers next stream element

 val s : Stream[Char] = 'A' <> 'Z'

 s.read.tp  // Prints A
 s.read.tp  // Prints B
 s.read.tp  // Prints C

Note: If stream is empty, read will fail. So, use a safer readOpt in most cases

Next optional element

Delivers next stream element or void option if stream is empty

 val s : Stream[Char] = 'A' <> 'C'

 s.readOpt.tp  // Prints Opt(A)
 s.readOpt.tp  // Prints Opt(B)
 s.readOpt.tp  // Prints Opt(C)
 s.readOpt.tp  // Prints Opt(VOID)

Read many elements

Immediatelly removes given number of elements from current stream and returns them as a new stream

 val s : Stream[Int] = 1 <> 12

 s.readStream(3).tp  // Prints Stream(1, 2, 3)
 s.readStream(4).tp  // Prints Stream(4, 5, 6, 7)
 s.readStream(7).tp  // Prints Stream(8, 9, 10, 11, 12)
 s.readStream(8).tp  // Prints Stream()

Note: If requested number of elements is not available, the number returned is less (0 if empty)

Reduce

Folds elements with a binary function

   // Calculate sum of first 1000 Ints

   (1 <> 1000).stream.reduce(_ + _) // Returns 500500

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

Heavy reduce

Folds elements with a binary function

REDUCE is functionally equivalent to reduce, but is fully inlined. It makes compiled code larger, but guarantees the best possible performance on large streams.

Heavy optional reduce

Folds elements with a binary function

REDUCE_OPT is functionally equivalent to reduceOpt, but is fully inlined. It makes compiled code larger, but guarantees the best possible performance on large streams.

Optional reduce

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

    // Calculate sum of first 1000 Ints

    (1 <> 1000).stream.reduceOpt(_ + _) // Returns Opt(500500)

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)

Equal start check

Checks if starting elements of two streams (to a point where one stream ends) are equal

Equal start check

Checks if starting elements of two streams (to a point where one stream ends) are equal

(0 <> 10).stream.equalsStartResult(0 <> 1000).tp
// Prints: Result(true)

(0 <> 1000).stream.equalsStartResult(0 <> 10).tp
// Prints: Result(true)

((0 <> 5).stream + 7 + 8).equalsStartResult(0 <> 10).tp
// Prints: Result(Problem(Fail at index 6: 7 != 6))

Note: The returned problem result contains message with basic description

Sum

Calculates sum of all values

For empty stream returns zero

    (1 <> 1000).stream.sum.tp // Prints 500500

Multi sum

Simultaneously computes up to 5 sum values for properties specified by given functions

Returns tuple of appropriate size with values corresponding to the given mappings

For empty Stream returned tuple will hold zeros

 (1 <> 1000).stream.sumFew(_ * 10, _ * 100).tp  // Prints (5005000, 50050000)

 val (first, second, third) = (1 <> 1000).stream.sumFew(v => v, _ * 10, _ * 100)

 first.tp     // Prints 500500
 second.tp    // Prints 5005000
 third.tp     // Prints 50050000

Optional sum

Calculates sum of all values or returns void option for empty streams

    (1 <> 1000).stream.sumOpt.tp // Prints Opt(500500)

Convert to Array

Returns stream elements as Array

 val a : Array[Int] =  (1 <> 10).stream.toArray

Convert to Buffer

Returns stream elements as Buffer

Convert to Idx

Returns stream elements as Idx

Convert to Java Iterator

Wraps current stream as java.util.Iterator

Convert to Java List

Returns stream elements as java.util.List

Convert to Java Spliterator

Wraps current stream as java.util.Spliterator

Convert to Java Stream

Wraps current stream as java.util.stream.Stream

Convert to List

Returns stream elements as scala.collection.immutable.List

Convert to Lookup

Note. This operation is only available for streams holding tuples, like (KEY,VALUE)

Converts a stream of tuples to Lookup

val intLookup : Lookup[Int,Char] = ('A' <> 'F').stream.zipKey(_.toInt).toLookup

intLookup.pairStream.tp   // Prints Stream((69,E), (70,F), (65,A), (66,B), (67,C), (68,D))

val charLookup : Lookup[Char,Int] = ('A' <> 'F').stream.zipValue(_.toInt).toLookup

charLookup.pairStream.tp   // Prints Stream((E,69), (F,70), (A,65), (B,66), (C,67), (D,68))

Convert to Lookup

Converts stream to a Lookup collection, where key is created with provided function

val intLookup : Lookup[Int,Char] = ('A' <> 'F').stream.toLookupBy(_.toInt)

intLookup.pairStream.tp   // Prints Stream((69,E), (70,F), (65,A), (66,B), (67,C), (68,D))

Convert to scala.Map

Note. This operation is only available for streams holding tuples, like (KEY,VALUE)

Converts a stream of tuples to scala.Map

Convert to scala.Map

Converts stream to scala.Map, where key is created with provided function

Convert to Product

Returns stream elements as scala.Product

Convert to Seq

Returns stream elements as scala.collection.immutable.IndexedSeq

Convert to unique collection

Returns stream elements as Set

Elements as multi-line String

Returns all elements as String formatted table

If elements implement Able.Doc, each 'doc' property value is placed in a different column

If elements implement scala.Product (like all Tuples), each Product element is placed in a different column

  ('a' <> 'e').stream.map(v => (v + "1", v + "2", v + "3", v + "4", v + "5")).toText.tp

  // Output
  -- -- -- -- --
  ?  ?  ?  ?  ?
  -- -- -- -- --
  a1 a2 a3 a4 a5
  b1 b2 b3 b4 b5
  c1 c2 c3 c4 c5
  d1 d2 d3 d4 d5
  e1 e2 e3 e4 e5
  -- -- -- -- --

Convert to Vector

Returns stream elements as scala.collection.immutable.Vector

Convert to Tuple10

If Stream has less then 10 elements, the operation will fail.

Convert to Tuple11

If Stream has less then 11 elements, the operation will fail.

Convert to Tuple12

If Stream has less then 12 elements, the operation will fail.

Convert to Tuple13

If Stream has less then 13 elements, the operation will fail.

Convert to Tuple14

If Stream has less then 14 elements, the operation will fail.

Convert to Tuple15

If Stream has less then 15 elements, the operation will fail.

Convert to Tuple16

If Stream has less then 16 elements, the operation will fail.

Convert to Tuple17

If Stream has less then 17 elements, the operation will fail.

Convert to Tuple18

If Stream has less then 18 elements, the operation will fail.

Convert to Tuple19

If Stream has less then 19 elements, the operation will fail.

Convert to Tuple2

If Stream has less then 2 elements, the operation will fail.

Convert to Tuple20

If Stream has less then 20 elements, the operation will fail.

Convert to Tuple21

If Stream has less then 21 elements, the operation will fail.

Convert to Tuple22

If Stream has less then 22 elements, the operation will fail.

Convert to Tuple3

If Stream has less then 3 elements, the operation will fail.

Convert to Tuple4

If Stream has less then 4 elements, the operation will fail.

Convert to Tuple5

If Stream has less then 5 elements, the operation will fail.

Convert to Tuple6

If Stream has less then 6 elements, the operation will fail.

Convert to Tuple7

If Stream has less then 7 elements, the operation will fail.

Convert to Tuple8

If Stream has less then 8 elements, the operation will fail.

Convert to Tuple9

If Stream has less then 9 elements, the operation will fail.