Stream.Flow 

Filter and converter

Only lets elements for which given PartialFinction is defined

The elements are converted to returned type

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

all.lp                                     // Prints ~(ABC, 1, 22.0, DE, 333.0, F)

all.collect{
    case s: String if (s.length > 1) => s
}.lp                                       // Prints ~(ABC, DE)

Note. collect always requires double evaluation for each element, so letMap is preferred in many cases

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

Reversed filter

Discards all the elements satisfying the filter

(1 to 10).all.drop(_ % 2 == 0).lp // Prints: ~(1, 3, 5, 7, 9)

Find

Returns the first element satisfying the given filter

Fails if none found

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

Find

Optionally returns the first element satisfying the given filter

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

Map multiplier

For every existing element, a mapped stream of elements is inserted into the pipeline

Note. The mapping can return an empty stream, in which case total number of elements might even be reduced

~~(1, 2, 3).flatMap(i => Seq(i * 10, i * 100, i * 1000)).lp

// Output
~(10, 100, 1000, 20, 200, 2000, 30, 300, 3000)

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.

Returns start value for empty pipeline

For each

Applies given function for each element

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

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

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

Parallel check

Returns true if this Flow is parallel

Main filter

Only lets elements satisfying the filter

let is the main filtering method ('filter' is supported for compatibility only)

(1 to 10).all.let(_ % 2 == 0).lp // Prints: ~(2, 4, 6, 8, 10)

Filter and converter

Only lets elements for which given function returns non empty Opt

The elements are converted to the new type

def all = "ABC" ~+ "1" + "22" + "D" + "333" + "E"

all.letMap(v => if (v.length < 2) \/ else v).lp // Prints: ~(ABC, 22, 333)

all.letMap({
  case s if (s.length >= 2) => s
  case _                    => \/
}).lp                                           // Prints: ~(ABC, 22, 333)

Note: letMap is often a faster alternative to collect with PartialFunction, because it is evaluated just once for each element

Filter and type converter

Only lets elements, which are instances of the given type

Note, the result is mapped to the specified type

def all = ~~[Any] + "1" + 2 + 3.0 + 4l + "5"

all.lp                  // Prints ~(1, 2, 3.0, 4, 5)

all.letType[String].lp  // Prints ~(1, 5)

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)

Element conversion

Converts every element in the pipeline with given function

(1 to 5).all.map( _ / 2.0).lp  // Prints ~(0.5, 1.0, 1.5, 2.0, 2.5)

Element cast

Casts the pipeline elements into the type specified

def all: ~[Any] = ~~[Any] + 1 + 2 + 3

all.mapCast[Int].lp   // Prints: ~(1, 2, 3)

Note. The cast will not fail immediately, and if there is a problem, it will come up later during pumping action

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 access

Provides access to passing pipeline elements

This method does not change pipeline type or composition in any way

('A' to 'C').all.peek(v => println("Passing: " + v)).count  // Returns 3

// Output
Passing: A
Passing: B
Passing: C

Indexed element access

Provides access to passing pipeline elements with their index in sequence

('A' to 'C').all.peekIdx((i, v) => println("Peek " + i + " = " + v), 1).count // Returns 3

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

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

Restore Flow to Stream

Restores potentially parallel Flow back to Stream

If this is already a Stream, the operation is instant, returning this

Otherwise the operation is quite expensive

In many cases it is advisable to consume pipeline as Flow instead of converting to Stream

val (count, millis) = (1 to 1000).all
  .parallel                           // Switching to parallel Stream.Flow
  .peek(_ => Thread.sleep(1))         // Expensive operation
  .sequential                         // Back to Stream
  .countAndMillis

println("Count = " + count + ", done in " + millis / 1000F + " secs")

// Output
Count = 1000, done in 0.224 secs

// Note: We have 1000 elements each pausing for 1 millis.
//       Without parallel processing total time would be over 1 second

Size if known

Stream elements count if known for granted

sizeOpt must be trusted

For example, if sizeOpt returns 0, processing logic should not even attempt to confirm that pipeline is empty

Sum

Computes sum value of all elements

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

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

Metadata as String

val info = ('a' to 'z').all.map(_.toUpper).toInfo

println(info)  // Prints scalqa.Stream.Z.extend.map.map$rawRaw$9{type=Chars,size=26}

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
- -

Data type if known

Stream elements type if known for granted