t

Stream._consume

trait _Trait[A] extends Stream.Flow._consume[A] with _aggregate[A] with _convert[A] with _evaluate[A] with _foreach[A]

Self Type
Stream[A]
Ordering
  1. Alphabetic
Inherited
  1. Stream._consume
  2. Stream._consume._foreach
  3. Stream._consume._evaluate
  4. Stream._consume._convert
  5. Stream._consume._aggregate
  6. Stream.Flow._consume
  7. Stream.Flow._consume._foreach
  8. Stream.Flow._consume._evaluate
  9. Stream.Flow._consume._convert
  10. Any.Able.ToText
  11. Stream.Flow._consume._aggregate
  12. scala.AnyRef
  13. scala.Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Method

  1. def apply(c: Consumer[A], forEmpty: ⇒ Any = \/): Unit

    For each or for empty

    For each or for empty

    Calls foreach if there are elements

    Executes forEmpty otherwise

    Definition Classes
    _foreach
  2. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  3. def average(implicit n: Numeric[A]): A

    Average

    Average

    Computes average

    (10.0 <> 15.0).all.average.lp // Prints: 12.5
    Definition Classes
    _aggregate
  4. def averageFew[B](f: Mapping[A, B]*)(implicit arg0: Numeric[B]): Idx[B]

    Multi average

    Multi average

    Simultaneously computes multiple average values for properties specified by several functions

    Returns Idx with values corresponding to the given mappings

    For empty pipelines returned Idx will still hold zero numerics, but will test isVoid positive

    def average3(stream: ~[Int]): Idx[Int] = stream.averageFew(AS_IS, _ * 10, _ * 100)
    
    average3(1 <> 10).all lp   // Prints: ~(5, 55, 550)
    
    average3(\/).all lp        // Prints: ~(0, 0, 0)
    
    average3(\/).I.Opt lp      // Prints: Opt.Void

    Note: Currently this method is not specialized and will auto box primitives

    Definition Classes
    _aggregate
  5. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  6. def contains[B >: A](value: B): Boolean

    Includes check

    Includes check

    Returns true if there is element equal to the given value

    def all = ('a' <> 'f').all
    
    all.contains('c').lp       // Prints: true
    
    all.contains('y').lp       // Prints: false
    Definition Classes
    _evaluate_evaluate
  7. def copyTo(b: Idx.Array.Buffer.Loader[A]): Unit

    Copy to buffer

    Copy to buffer

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

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

    Definition Classes
    _convert
  8. def count(f: Filter[A]): Int

    Element conditional count

    Element conditional count

    Returns count of elements satisfying the filter

    Definition Classes
    _evaluate_evaluate
  9. def count: Int

    All elements count

    All elements count

    Returns count of all elements

    ('a' <> 'z').all.count.lp  // Prints: 26
    Definition Classes
    _evaluate_evaluate
  10. def countAndTime: (Int, Duration)

    Element count and time

    Element count and time

    Returns count of all elements and the Duration it took to pump the pipeline

    (1 <> 1000).all.peek(_ => App.pause(1.Millis)).countAndTime.lp // Prints: (1000,1.004 sec)
    Definition Classes
    _evaluate_evaluate
  11. def countFew(f: Filter[A]*): Idx[Int]

    Element multi count

    Element multi count

    Counts elements for several filters at once

    Returns Idx[Int], where each Int corresponds to the given filter index

    If the pipeline is empty, the resulting Idx will still hold 0 in each position, but will test isVoid positive

    f

    several filters

    Definition Classes
    _evaluate_evaluate
    Example:
    1. val (all, odd, even) = (1 <> 50).all.countFew(ANY, _ % 2 == 1, _ % 2 == 0).toTuple3
      
      "all=" + all lp;    // Prints: all=50
      "odd=" + odd lp;    // Prints: odd=25
      "even=" + even lp;  // Prints: even=25
      
       // ----------------------------------------------------------------------------------
      
      def count(stream: ~[Int]): Idx[Int] = stream.countFew(_ < 10, _ > 20, 30 <> 60)
      
      count(1 <> 50).all lp  // Prints: ~(9, 30, 21)
      
      count(\/).all lp       // Prints: ~(0, 0, 0)
      
      count(\/).Opt lp       // Prints: Opt.Void
  12. def drain: Unit

    Discharge everything

    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' <> 'C').all.peek("Process " + _ lp).drain
    
    // Output
    Process A
    Process B
    Process C
    Definition Classes
    _foreach
  13. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  14. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  15. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  16. def find(f: Filter[A]): A

    Find

    Find

    Returns the first element satisfying the given filter

    Fails if none found

    (1 <> 1000).all.find(_ > 100).lp  // Prints: 101
    Definition Classes
    _evaluate_evaluate
  17. def findAnyOpt: Opt[A]
    Attributes
    protected
    Definition Classes
    _evaluate_evaluate
  18. def findIdxOpt(f: Filter[A]): Opt.Int

    Find index

    Find index

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

    (50 <> 500).all.findIdxOpt(_ == 400).lp // Prints: Opt(350)
    Definition Classes
    _evaluate
  19. def findOpt(f: Filter[A]): Opt[A]

    Find

    Find

    Optionally returns the first element satisfying the given filter

    (1 <> 1000).all.findOpt(_ > 100).lp  // Prints: Opt(101)
    Definition Classes
    _evaluate_evaluate
  20. def fold(start: A)(op: Folding[A]): A

    Basic fold

    Basic fold

    Folds elements with a binary function

    Returns start value for empty pipeline

    start

    seed value to start with

    Definition Classes
    _aggregate_aggregate
    Example:
    1. // Multiply every element by next
      
      (1 <> 10).all.fold(1, _ * _).lp   // Prints: 3628800
  21. def foldAs[B](start: B)(op: Folding.As[B, A])(implicit arg0: Ilk[B]): B

    Fold and convert

    Fold and convert

    Folds and converts elements with a binary function

    // Calculate sum of first 1000 Ints
    
    (1 <> 1000).all.foldAs[Long](0L, _ + _).lp // Prints: 500500
    start

    seed value to start with

    Definition Classes
    _aggregate
  22. def foldFlowAs[B](start: B)(op: Folding.As[B, A], cf: Folding[B] = null)(implicit arg0: Ilk[B]): B

    foldAs

    foldAs

    For Stream this method is same as foldAs

    Only use it when dealing with Stream.Flow interface

    start

    seed value to start with

    cf

    collect function to put together results of parallel computations. It is not required and ignored for Stream

    Definition Classes
    _aggregate_aggregate
  23. abstract def foreach(f: Consumer[A]): Unit

    For each

    For each

    Applies given function for each element

    (1 <> 3).all.foreach("Element: " + _ lp)
    
    // Output
    Element: 1
    Element: 2
    Element: 3
    Definition Classes
    _foreach
  24. def foreachIdx(f: Consumer.Idx[A], start: Int = 0): Unit

    For each indexed

    For each indexed

    Calls foreach with counter

    start

    starting value for the index in the f function

    ('A' <> 'C').all.foreachIdx("Element " + _ + " = " + _ lp, 1)
    
    // Output
    Element 1 = A
    Element 2 = B
    Element 3 = C
    Definition Classes
    _foreach
  25. def foreachSynchronized(f: Consumer[A]): Unit

    Calls foreach

    Calls foreach

    foreachSynchronized is inherited from Stream.Flow, which could be parallel

    Stream is sequential by itself, so foreachSynchronized is same as regular foreach

    Definition Classes
    _foreach_foreach
  26. def format(separator: Opt[String] = \/, padBefore: Opt[String] = \/, padAfter: Opt[String] = \/, converter: Opt[(A) ⇒ String] = \/): String

    Elements as String

    Elements as String

    All elements are converted toString

    The results are concatenated with possible use of padding and separator

    separator

    optional string between elements

    padBefore

    optional string before each element

    padAfter

    optional string after each element

    converter

    custom element to String function

    Definition Classes
    _convert
    Example:
    1. ('a' <> 'z').all.format().lp
      ('a' <> 'z').all.format("|").lp
      ('a' <> 'z').all.format(",", "[", "]").lp
      
      // Output
      abcdefghijklmnopqrstuvwxyz
      
      a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z
      
      [a],[b],[c],[d],[e],[f],[g],[h],[i],[j],[k],[l],[m],[n],[o],[p],[q],[r],[s],[t],[u],[v],[w],[x],[y],[z]
  27. def hashCode(): Int
    Definition Classes
    AnyRef → Any
  28. def isAny(f: Filter[A]): Boolean

    Any check

    Any check

    Returns true if there is an element satisfying the filter

    def all = (1 <> 100).all
    
    all.isAny(_ > 10).lp   // Prints: true
    
    all.isAny(_ > 100).lp  // Prints: false
    Definition Classes
    _evaluate_evaluate
  29. def isEvery(f: Filter[A]): Boolean

    Every check

    Every check

    Returns true if every element is satisfying the filter

    def all = (1 <> 100).all
    
    all.isEvery(_ > 10).lp   // Prints: false
    
    all.isEvery(_ > 0).lp    // Prints: true
    Definition Classes
    _evaluate_evaluate
  30. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  31. def last: A

    Last element

    Last element

    Returns the last data element

    Fails if no data

    Definition Classes
    _evaluate
  32. def lastOpt: Opt[A]

    Last element

    Last element

    Optionally returns the last element or Opt.Void

    Definition Classes
    _evaluate
  33. def lookupOpt[B](f: PartialFunction[A, B]): Opt[B]

    Find first matching option

    Find first matching option

    The matching element is mapped with the functions

    def stream = ~[Any] + "ABC" + 1 + 22.0 + "DE" + 333F + "F"
    
    // Find length of the first matching string
    stream.lookupOpt{
      case s: String if (s.length > 1) => s.length
    }.lp    // Prints: Opt(3)
    Definition Classes
    _evaluate_evaluate
  34. def max(implicit o: Ordering[A]): A

    Largest

    Largest

    Selects maximum element, based on the Ordering

    Fails for empty stream

    ~.*(4, 3, 12, 7).maxOpt.lp // Prints: 12
    Definition Classes
    _aggregate
  35. def maxBy[B](f: Mapping[A, B])(implicit o: Ordering[B]): A

    Largest by property

    Largest by property

    Selects maximum element, based on mapping

    Fails for empty stream

    ("AA" ~+ "B" + "CCCC" + "DDD").maxBy(_.length).lp // Prints: CCCC
    Definition Classes
    _aggregate
  36. def maxByOpt[B](f: Mapping[A, B])(implicit o: Ordering[B]): Opt[A]

    Largest by property option

    Largest by property option

    Selects maximum element, based on mapping

    ("AA" ~+ "B" + "CCCC" + "DDD").maxBy(_.length).lp // Prints: Opt(CCCC)
    Definition Classes
    _aggregate_aggregate
  37. def maxOpt(implicit c: Ordering[A]): Opt[A]

    Largest

    Largest

    Selects maximum element, based on the Ordering

    ~.*(4, 3, 12, 7).maxOpt.lp // Prints: Opt(12)
    Definition Classes
    _aggregate_aggregate
  38. def min(implicit o: Ordering[A]): A

    Smallest

    Smallest

    Selects minimal element, based on the Ordering

    Fails for empty stream

    (4 ~+ 3 + 12 + 7).minOpt.lp // Prints: 3
    Definition Classes
    _aggregate
  39. def minBy[B](f: Mapping[A, B])(implicit o: Ordering[B]): A

    Smallest by property

    Smallest by property

    Selects minimal element, based on mapping

    Fails for empty stream

    ("AA" ~+ "B" + "CCCC" + "DDD").minBy(_.length).lp // Prints: B
    Definition Classes
    _aggregate
  40. def minByOpt[B](f: Mapping[A, B])(implicit o: Ordering[B]): Opt[A]

    Smallest by property option

    Smallest by property option

    Selects minimal element, based on mapping

    ("AA" ~+ "B" + "CCCC" + "DDD").minBy(_.length).lp // Prints: Opt(B)
    Definition Classes
    _aggregate_aggregate
  41. def minOpt(implicit c: Ordering[A]): Opt[A]

    Smallest

    Smallest

    Selects minimal element, based on the Ordering

    (4 ~+ 3 + 12 + 7).minOpt.lp // Prints: Opt(3)
    Definition Classes
    _aggregate_aggregate
  42. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  43. final def notify(): Unit
    Definition Classes
    AnyRef
  44. final def notifyAll(): Unit
    Definition Classes
    AnyRef
  45. def range(implicit c: Ordering[A]): Range[A]

    Element Range

    Element Range

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

    Note. Range is void for empty pipelines.

    (4 ~+ 1 + 12 + 7).range.lp
    
    // Output
    1 <> 12
    Definition Classes
    _aggregate_aggregate
  46. def reduce(op: Folding[A]): A

    Reduces elements with a Folding functions

    Reduces elements with a Folding functions

    Will fail for empty Stream

    Definition Classes
    _aggregate_aggregate
  47. def reduceOpt(op: Folding[A]): Opt[A]

    Reduces elements with a Folding functions

    Reduces elements with a Folding functions

    Returns Opt.Void for for empty Stream

    Definition Classes
    _aggregate_aggregate
  48. def sum(implicit n: Numeric[A]): A

    Sum

    Sum

    Computes sum value of all elements

    (0 <> 1000).all.sum.lp // Prints: 500500
    Definition Classes
    _aggregate_aggregate
  49. def sumFew[B](f: Mapping[A, B]*)(implicit arg0: Numeric[B]): Idx[B]

    Multi sum

    Multi sum

    Simultaneously computes multiple sum values for properties specified by several functions

    Returns Idx, with values corresponding to the given mappings

    For empty pipelines returned Idx will still hold zero numerics, but will test isVoid positive

    def sum3(stream: ~[Int]): Idx[Int] = stream.sumFew(AS_IS, _ * 10, _ * 100)
    
    sum3(1.I repeat 10).all lp  // Prints: ~(10, 100, 1000)
    
    sum3(\/).all lp             // Prints: ~(0, 0, 0)
    
    sum3(\/).I.Opt lp           // Prints: Opt.Void

    Note: Currently this method is not specialized and will auto box primitives

    Definition Classes
    _aggregate
  50. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  51. def to[TRGT[_]](implicit cnv: Stream.Interface.To.Converter[TRGT]): TRGT[A]

    Convert to type

    Convert to type

    Converts pipeline elements to the specified target type

    Available targets are defined in Stream.Interface.To$

    • Idx
    • Idx.M
    • Idx.OM
    • Idx.I
    • 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.I]  // Returns: Idx.I[String]
    
    ('A' <> 'D').all.to[List]        // Returns: scala.List[Char]
    
    (1 <> 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$.Converter

    Definition Classes
    _convert
  52. def toArray(implicit ct: ClassTag[A]): Array[A]

    Convert to Array

    Convert to Array

    Concert stream to array

    val a : Array[Int] =  (1<>10).all.toArray
    Definition Classes
    _convert
  53. def toBuffer: Stream[A]

    New buffered stream

    New buffered stream

    Buffers all elements from the source and returns them as new Stream

    Definition Classes
    _convert
  54. def toLookup[KEY](key: (A) ⇒ KEY): Lookup[KEY, A]

    New Lookup

    New Lookup

    Creates a Lookup collection out of Stream elements

    Definition Classes
    _convert
  55. def toLookup[KEY, VAL](implicit ev: <:<[A, (KEY, VAL)]): Lookup[KEY, VAL]

    New Lookup

    New Lookup

    This Stream must contain tuples of keys and values

    Definition Classes
    _convert
  56. def toRaw[TRGT](implicit c: Stream.Interface.To.Primitive.Converter[A, TRGT]): TRGT

    Convert to immutable collection

    Convert to immutable collection

    Converts pipeline to the specified immutable collection

    The types of collection and Stream must match

    Available targets are:

    (1 <> 10).all.toRaw[Ints]
    
    ('A' <> 'D').all.toRaw[Chars]
    Definition Classes
    _convert
  57. def toString(): String

    Elements as String

    Elements as String

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

    (1 <> 5).all.toString.lp
    
    // Output
    ~(1, 2, 3, 4, 5)
    Definition Classes
    _convert → AnyRef → Any
  58. def toString(name: String): String

    Elements as String

    Elements as String

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

    (1 <> 5).all.toString("My Ints").lp
    
    // Output
    My Ints(1, 2, 3, 4, 5)
    Definition Classes
    _convert
  59. def toText: String

    Elements as multi-line String

    Elements as multi-line String

    Returns all elements as String formatted table

    If elements implement Any.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' <> 'e').all.map(c => (c + "1", c + "2", c + "3", c + "4", c + "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
    -- -- -- -- --
    Definition Classes
    _convertToText
  60. def toVals(implicit c: Any.Datum.Setup[A]): Vals[A]

    Convert to Vals

    Convert to Vals

    Stores all elements as Vals immutable collection

    Only works if Stream holds Any.Datum type

    Definition Classes
    _convert
  61. def unequalOpt(that: ~[A], check: (A, A) ⇒ Boolean = _ == _): Opt[String]

    Unequal check

    Unequal check

    Pumps both streams and compares all corresponding elements

    When first not equal pair is found, message is returned

    If all are equal, Opt.Void is returned

    (0 <> 10).all unequalOpt (0 <> 10) lp        // Prints: Opt.Void
    
    (0 <> 10).all unequalOpt (0 <>> 10) lp       // Prints: Opt(First has more elements)
    
    (0 <> 5).all + 7 + 8 unequalOpt (0 <> 10) lp // Prints: Opt(Fail at index 6: 7 != 6)
    check

    is the function to compare two elements

    Definition Classes
    _evaluate
  62. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  63. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  64. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

Operator

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any