Stream._consume 

For each or for empty

Calls foreach if there are elements

Executes forEmpty otherwise

Average

Computes average

(10 to 15).all.map(_.toFloat).average  // Returns 12.5

Multi average

Simultaneously computes multiple average values for properties specified by several functions

Returns Seq with values corresponding to the given mappings

For empty pipelines returned Seq will still hold zero numerics, but will test isVoid==true

(1 to 1000).all.averageFew(v => v, _ * 10, _ * 100).all.lp  // Prints ~(500, 5005, 50050)

Find first matching option

The matching element is mapped with the functions

def stream = ~~[Any] + 1 + "ABC" + 22.0 + "DE" + 333F + "F"

// Find length of the first matching string
stream.collectOpt{
  case s: String if (s.length > 1) => s.length
}.lp    // Prints: Opt(3)

Includes check

Returns true if there is element equal to the given value

def all: ~[Char] = 'a' to 'f'

all.contains('c')       // Returns true

all.contains('y')       // Returns false

Copy to buffer

This is potentially the most efficient way to get all Stream elements

Idx.Buffer.Loader provides a trustless way to copy arrays in bulk, so many array based Streams can take advantage of this

Element conditional count

Returns count of elements satisfying the filter

All elements count

Returns count of all elements

('a' to 'z').all.count  // Returns 26

Element count and time

Returns total count and time in seconds it took to pump the pipeline from first to last elements

val (count, seconds) = (1 to 1000).all.peek(_ => Thread.sleep(1)).countAndSeconds

println("Count = " + count + ", done in " + seconds + " secs")

// Output
Count = 1000, done in 1.004261423 secs

Element multi count

Counts elements for several filters at once

Returns Seq, where each Int corresponds to the given filter index

val Seq(total, odd, even) = (1 to 50).all.countFew(_ => true, _ % 2 == 1, _ % 2 == 0)

println("total=" + total + ", odd=" + odd + ", even=" + even)

// Output
total=50, odd=25, even=25

Discharge everything

Calls foreach, discarding all retrieved elements

Even though nothing is done at this point, this method can be run for the benefit of other functions in the pipeline

('A' to 'C').all.peek(v => println("Process " + v)).drain

// Output
Process A
Process B
Process C

Find

Returns the first element satisfying the given filter

Fails if none found

(1 to 1000).all.find(_ > 100)   // Returns 101

Find index

Optionally returns index for the first element satisfying the filter or Opt.Void if none found

(50 to 500).all.findIdxOpt(_ == 400)  // Retuns Opt(350)

Find

Optionally returns the first element satisfying the given filter

(1 to 1000).all.findOpt(_ > 100)   // Returns Opt(101)

Basic fold

Folds elements with a binary function

Returns start value for empty pipeline

// Multiply every element by next

(1 to 10).all.fold(1)(_ * _)   // Returns 3628800

Fold and convert

Folds and converts elements with a binary function

// Calculate sum of first 1000 Ints

(1 to 1000).all.foldAs[Long](0L)(_ + _) // Returns 500500

foldAs

For Stream this method is same as foldAs

Only use it when dealing with Stream.Flow interface

For each

Applies given function for each element

(1 to 3).all.foreach(v => println("Element: " + v))

// Output
Element: 1
Element: 2
Element: 3

For each indexed

Calls foreach with counter

('A' to 'C').all.foreachIdx((i,v) => println("Element " + i + " = " + v), 1)

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

Elements as String

All elements are converted toString

The results are concatenated with possible use of padding and separator

('a' to 'j').all.format()              // Returns abcdefghij

('a' to 'j').all.format("|")           // Returns a|b|c|d|e|f|g|h|i|j

('a' to 'j').all.format(",", "[", "]") // Returns [a],[b],[c],[d],[e],[f],[g],[h],[i],[j]

Any check

Returns true if there is an element satisfying the filter

def all: ~[Int] = 1 to 100

all.isAny(_ > 10)   // Returns true

all.isAny(_ > 100)  // Returns false

Every check

Returns true if every element is satisfying the filter

def all: ~[Int] = 1 to 100

all.isEvery(_ > 10)    // Returns false

all.isEvery(_ > 0)     // Returns true

Last element

Returns the last stream element

Fails if empty

Last element

Optionally returns the last element or Opt.Void

Line print

Is equivalent to:

println(this)

For example:

(1 to 10).all.lp  // Prints ~(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

Largest

Selects maximum element, based on the Ordering

Fails for empty stream

~~(4, 3, 12, 7).max // Returns 12

Largest by property

Selects maximum element, based on mapping

Fails for empty stream

~~("AA", "B", "CCCC", "DDD").maxBy(_.length) // Returns CCCC

Largest by property option

Selects maximum element, based on mapping

~~("AA", "B", "CCCC", "DDD").maxByOpt(_.length).lp // Returns Opt(CCCC)

Largest

Selects maximum element, based on the Ordering

~~(4, 3, 12, 7).maxOpt // Returns Opt(12)

Smallest

Selects minimal element, based on the Ordering

Fails for empty stream

~~(4, 3, 12, 7).min  // Returns 3

Smallest by property

Selects minimal element, based on mapping

Fails for empty stream

~~("AA", "B", "CCCC", "DDD").minBy(_.length) // Returns B

Smallest by property option

Selects minimal element, based on mapping

~~("AA", "B", "CCCC", "DDD").minByOpt(_.length) // Returns Opt(B)

Smallest

Selects minimal element, based on the Ordering

~~(4, 3, 12, 7).minOpt  // Returns Opt(3)

Element Range

Selects min and max elements (according to the Ordering ), and returns result as Util.Range

Note. Range is void for empty pipelines.

(~~[Int] + 4 + 1 + 12 + 7).range  // Returns range from 1 to 12

Reduces elements with a Folding functions

Will fail for empty Stream

Reduces elements with a Folding functions

Returns Opt.Void for for empty Stream

Sum

Computes sum value of all elements

(0 to 1000).all.sum  // Returns: 500500

Multi sum

Simultaneously computes multiple sum values for properties specified by several functions

Returns Seq, with values corresponding to the given mappings

For empty pipelines returned Seq will still hold zero numerics, but will test isVoid==true

(1 to 1000).all.sumFew(v => v, _ * 10, _ * 100).all.lp  // Prints ~(500500, 5005000, 50050000)

Convert to type

Converts pipeline elements to the specified target type

Available targets are defined in Stream.Interface.To$

• Idx
• Idx.Immutable
• Idx.Buffer
• Refs
• scala.List
• scala.Seq
• scala.IndexedSeq
• scala.Iterator
• scala.Vector
• scala.collection.mutable.Buffer
• java.util.Collection
• java.util.List
• java.util.Iterator
• java.util.Spliterator
• java.util.stream.Stream

~~("1", "2", "3").to[Idx]       // Returns: Idx[String]

('A' to 'D').all.to[List]        // Returns: scala.List[Char]

(1 to 5).all.to[java.util.List]  // Returns: java.util.List[Int]

New target conversions can be implemented by creating implicit object extending Stream.Interface.To

Convert to Array

Converts stream to array

val a : Array[Int] =  (1 to 10).all.toArray

New buffered stream

Loads all elements from source into memory and returns them as new Stream

Convert to immutable collection

Converts pipeline to the specified immutable collection

The types of collection and Stream must match

Available targets are:

• Booleans
• Bytes
• Chars
• Shorts
• Ints
• Longs
• Floats
• Doubles

(1 to 10).all.toRaw[Ints]

('A' to 'D').all.toRaw[Chars]

Elements as String

Returns String starting with ~( and containing all elements separated by comma

(1 to 5).all.toString  //  Returns ~(1, 2, 3, 4, 5)

Elements as String

Returns String starting with given name and containing all elements separated by ", "

(1 to 5).all.toString("My Ints")  // Returns My Ints(1, 2, 3, 4, 5)

Elements as multi-line String

Returns all elements as String formatted table

If elements implement Util.Able.ToInfo, each 'info' 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' to 'e').all.map(v => (v + "1", v + "2", v + "3", v + "4", v + "5")) 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
-- -- -- -- --

Text print

Is equivalent to:

println(this.toText)

For example:

('a' to 'd').all.zipIdx.tp

// Output
- -
? ?
- -
0 a
1 b
2 c
3 d
- -

Unequal check

Pumps both streams and compares all corresponding elements

When first not equal pair is found, message is returned

If all elements are equal, Opt.Void is returned

(0 to 10).all unequalOpt (0 to 10)         // Prints: Opt.Void

(0 to 10).all unequalOpt (0 until 10)      // Prints: Opt(First has more elements)

(0 to 5).all + 7 + 8 unequalOpt (0 to 10)  // Prints: Opt(Fail at index 6: 7 != 6)