t

Stream.Flow._consume._evaluate

trait _evaluate[A] extends AnyRef

Evaluate Interface

Self Type
Stream.Flow[A]
Ordering
  1. Alphabetic
Inherited
  1. Flow._consume._evaluate
  2. scala.AnyRef
  3. scala.Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Method

  1. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  2. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  3. 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
  4. def count(f: Filter[A]): Int

    Element conditional count

    Element conditional count

    Returns count of elements satisfying the filter

    Definition Classes
    _evaluate
  5. abstract def count: Int

    All elements count

    All elements count

    Returns count of all elements

    ('a' <> 'z').all.count.lp  // Prints: 26
    Definition Classes
    _evaluate
  6. 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
  7. 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
    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
  8. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  9. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  10. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  11. 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
  12. abstract def findAnyOpt: Opt[A]
    Attributes
    protected
    Definition Classes
    _evaluate
  13. 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
  14. def hashCode(): Int
    Definition Classes
    AnyRef → Any
  15. 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
  16. 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
  17. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  18. 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
  19. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  20. final def notify(): Unit
    Definition Classes
    AnyRef
  21. final def notifyAll(): Unit
    Definition Classes
    AnyRef
  22. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  23. def toString(): String
    Definition Classes
    AnyRef → Any
  24. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  25. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  26. 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