object IterableUtil

Linear Supertypes
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. IterableUtil
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Value Members

  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
  4. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  5. def assertAtMostOne[T](objects: Seq[T], objName: String)(implicit loggingContext: ErrorLoggingContext): Option[T]

    Exceptions thrown

    java.lang.IllegalArgumentException If objects contains more than one distinct element

  6. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native() @IntrinsicCandidate()
  7. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  8. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  9. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @IntrinsicCandidate()
  10. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @IntrinsicCandidate()
  11. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  12. def mapReducePar[A, B](parallelism: PositiveNumeric[Int], xs: Seq[A])(f: (A) => B)(g: (B, B) => B)(implicit ec: ExecutionContext): Future[Option[B]]

    Map the function f over a sequence and reduce the result with function g, mapping and reducing is done in parallel given the desired parallelism.

    Map the function f over a sequence and reduce the result with function g, mapping and reducing is done in parallel given the desired parallelism.

    This method works best if the amount of work for computing f and g is roughly constant-time, i.e., independent of the data that is being processed, because then each chunk to process takes about the same time.

    parallelism

    Determines the number of chunks that are created for parallel processing.

    f

    The mapping function.

    g

    The reducing function. Must be associative.

    returns

    The result of xs.map(f).reduceOption(g). If f or g throw exceptions, the returned future contains such an exception, but it is not guaranteed that the returned exception is the "first" such exception in a fixed sequential execution order.

    Annotations
    @SuppressWarnings()
  13. def maxList[A](xs: Iterable[A])(implicit order: Ordering[A]): List[A]

    Calculates the largest possible list ys of elements in an input iterable xs such that: For all y in ys.

    Calculates the largest possible list ys of elements in an input iterable xs such that: For all y in ys. y >= x for all x in xs.

    Informally, this gives the list of all highest elements of xs.

    See TraversableUtilTest for an example.

  14. def minList[A](xs: Iterable[A])(implicit order: Ordering[A]): List[A]

    Calculates the largest possible list ys of elements in an input iterable xs such that: For all y in ys.

    Calculates the largest possible list ys of elements in an input iterable xs such that: For all y in ys. y <= x for all x in xs.

    Informally, this gives the list of all lowest elements of xs.

  15. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  16. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @IntrinsicCandidate()
  17. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @IntrinsicCandidate()
  18. def spansBy[A, CC[X] <: Iterable[X], C, B](iterable: IterableOps[A, CC, C with Iterable[A]])(f: (A) => B): LazyList[(B, NonEmpty[CC[A]])]

    Split an iterable into a lazy Stream of consecutive elements with the same value of f(element).

  19. def subzipBy[A, B, C](elems: Iterator[A], seq: Iterator[B])(by: (A, B) => Option[C]): Seq[C]

    Returns the zipping of elems with seq where members y of seq are skipped if !by(x, y) for the current member x from elems.

    Returns the zipping of elems with seq where members y of seq are skipped if !by(x, y) for the current member x from elems. Zipping stops when there are no more elements in elems or seq

  20. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  21. def toString(): String
    Definition Classes
    AnyRef → Any
  22. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  23. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  24. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  25. def zipAllOption[A, B](xs: Seq[A], ys: Iterable[B]): Seq[(Option[A], Option[B])]

Deprecated Value Members

  1. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable]) @Deprecated @Deprecated
    Deprecated

Inherited from AnyRef

Inherited from Any

Ungrouped