--- /dev/null
+<!doctype html>
+<html>
+ <head>
+ <meta charset="utf-8">
+ <title>CodeMirror: C-like mode</title>
+ <link rel="stylesheet" href="../../lib/codemirror.css">
+ <link rel="stylesheet" href="../../theme/ambiance.css">
+ <script src="../../lib/codemirror.js"></script>
+ <script src="../../addon/edit/matchbrackets.js"></script>
+ <script src="clike.js"></script>
+ <link rel="stylesheet" href="../../doc/docs.css">
+ <style>
+ body
+ {
+ margin: 0;
+ padding: 0;
+ max-width:inherit;
+ height: 100%;
+ }
+ html, form, .CodeMirror, .CodeMirror-scroll
+ {
+ height: 100%;
+ }
+ </style>
+ </head>
+ <body>
+<form>
+<textarea id="code" name="code">
+
+ /* __ *\
+ ** ________ ___ / / ___ Scala API **
+ ** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL **
+ ** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **
+ ** /____/\___/_/ |_/____/_/ | | **
+ ** |/ **
+ \* */
+
+ package scala.collection
+
+ import generic._
+ import mutable.{ Builder, ListBuffer }
+ import annotation.{tailrec, migration, bridge}
+ import annotation.unchecked.{ uncheckedVariance => uV }
+ import parallel.ParIterable
+
+ /** A template trait for traversable collections of type `Traversable[A]`.
+ *
+ * $traversableInfo
+ * @define mutability
+ * @define traversableInfo
+ * This is a base trait of all kinds of $mutability Scala collections. It
+ * implements the behavior common to all collections, in terms of a method
+ * `foreach` with signature:
+ * {{{
+ * def foreach[U](f: Elem => U): Unit
+ * }}}
+ * Collection classes mixing in this trait provide a concrete
+ * `foreach` method which traverses all the
+ * elements contained in the collection, applying a given function to each.
+ * They also need to provide a method `newBuilder`
+ * which creates a builder for collections of the same kind.
+ *
+ * A traversable class might or might not have two properties: strictness
+ * and orderedness. Neither is represented as a type.
+ *
+ * The instances of a strict collection class have all their elements
+ * computed before they can be used as values. By contrast, instances of
+ * a non-strict collection class may defer computation of some of their
+ * elements until after the instance is available as a value.
+ * A typical example of a non-strict collection class is a
+ * <a href="../immutable/Stream.html" target="ContentFrame">
+ * `scala.collection.immutable.Stream`</a>.
+ * A more general class of examples are `TraversableViews`.
+ *
+ * If a collection is an instance of an ordered collection class, traversing
+ * its elements with `foreach` will always visit elements in the
+ * same order, even for different runs of the program. If the class is not
+ * ordered, `foreach` can visit elements in different orders for
+ * different runs (but it will keep the same order in the same run).'
+ *
+ * A typical example of a collection class which is not ordered is a
+ * `HashMap` of objects. The traversal order for hash maps will
+ * depend on the hash codes of its elements, and these hash codes might
+ * differ from one run to the next. By contrast, a `LinkedHashMap`
+ * is ordered because it's `foreach` method visits elements in the
+ * order they were inserted into the `HashMap`.
+ *
+ * @author Martin Odersky
+ * @version 2.8
+ * @since 2.8
+ * @tparam A the element type of the collection
+ * @tparam Repr the type of the actual collection containing the elements.
+ *
+ * @define Coll Traversable
+ * @define coll traversable collection
+ */
+ trait TraversableLike[+A, +Repr] extends HasNewBuilder[A, Repr]
+ with FilterMonadic[A, Repr]
+ with TraversableOnce[A]
+ with GenTraversableLike[A, Repr]
+ with Parallelizable[A, ParIterable[A]]
+ {
+ self =>
+
+ import Traversable.breaks._
+
+ /** The type implementing this traversable */
+ protected type Self = Repr
+
+ /** The collection of type $coll underlying this `TraversableLike` object.
+ * By default this is implemented as the `TraversableLike` object itself,
+ * but this can be overridden.
+ */
+ def repr: Repr = this.asInstanceOf[Repr]
+
+ /** The underlying collection seen as an instance of `$Coll`.
+ * By default this is implemented as the current collection object itself,
+ * but this can be overridden.
+ */
+ protected[this] def thisCollection: Traversable[A] = this.asInstanceOf[Traversable[A]]
+
+ /** A conversion from collections of type `Repr` to `$Coll` objects.
+ * By default this is implemented as just a cast, but this can be overridden.
+ */
+ protected[this] def toCollection(repr: Repr): Traversable[A] = repr.asInstanceOf[Traversable[A]]
+
+ /** Creates a new builder for this collection type.
+ */
+ protected[this] def newBuilder: Builder[A, Repr]
+
+ protected[this] def parCombiner = ParIterable.newCombiner[A]
+
+ /** Applies a function `f` to all elements of this $coll.
+ *
+ * Note: this method underlies the implementation of most other bulk operations.
+ * It's important to implement this method in an efficient way.
+ *
+ *
+ * @param f the function that is applied for its side-effect to every element.
+ * The result of function `f` is discarded.
+ *
+ * @tparam U the type parameter describing the result of function `f`.
+ * This result will always be ignored. Typically `U` is `Unit`,
+ * but this is not necessary.
+ *
+ * @usecase def foreach(f: A => Unit): Unit
+ */
+ def foreach[U](f: A => U): Unit
+
+ /** Tests whether this $coll is empty.
+ *
+ * @return `true` if the $coll contain no elements, `false` otherwise.
+ */
+ def isEmpty: Boolean = {
+ var result = true
+ breakable {
+ for (x <- this) {
+ result = false
+ break
+ }
+ }
+ result
+ }
+
+ /** Tests whether this $coll is known to have a finite size.
+ * All strict collections are known to have finite size. For a non-strict collection
+ * such as `Stream`, the predicate returns `true` if all elements have been computed.
+ * It returns `false` if the stream is not yet evaluated to the end.
+ *
+ * Note: many collection methods will not work on collections of infinite sizes.
+ *
+ * @return `true` if this collection is known to have finite size, `false` otherwise.
+ */
+ def hasDefiniteSize = true
+
+ def ++[B >: A, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = {
+ val b = bf(repr)
+ if (that.isInstanceOf[IndexedSeqLike[_, _]]) b.sizeHint(this, that.seq.size)
+ b ++= thisCollection
+ b ++= that.seq
+ b.result
+ }
+
+ @bridge
+ def ++[B >: A, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That =
+ ++(that: GenTraversableOnce[B])(bf)
+
+ /** Concatenates this $coll with the elements of a traversable collection.
+ * It differs from ++ in that the right operand determines the type of the
+ * resulting collection rather than the left one.
+ *
+ * @param that the traversable to append.
+ * @tparam B the element type of the returned collection.
+ * @tparam That $thatinfo
+ * @param bf $bfinfo
+ * @return a new collection of type `That` which contains all elements
+ * of this $coll followed by all elements of `that`.
+ *
+ * @usecase def ++:[B](that: TraversableOnce[B]): $Coll[B]
+ *
+ * @return a new $coll which contains all elements of this $coll
+ * followed by all elements of `that`.
+ */
+ def ++:[B >: A, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = {
+ val b = bf(repr)
+ if (that.isInstanceOf[IndexedSeqLike[_, _]]) b.sizeHint(this, that.size)
+ b ++= that
+ b ++= thisCollection
+ b.result
+ }
+
+ /** This overload exists because: for the implementation of ++: we should reuse
+ * that of ++ because many collections override it with more efficient versions.
+ * Since TraversableOnce has no '++' method, we have to implement that directly,
+ * but Traversable and down can use the overload.
+ */
+ def ++:[B >: A, That](that: Traversable[B])(implicit bf: CanBuildFrom[Repr, B, That]): That =
+ (that ++ seq)(breakOut)
+
+ def map[B, That](f: A => B)(implicit bf: CanBuildFrom[Repr, B, That]): That = {
+ val b = bf(repr)
+ b.sizeHint(this)
+ for (x <- this) b += f(x)
+ b.result
+ }
+
+ def flatMap[B, That](f: A => GenTraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = {
+ val b = bf(repr)
+ for (x <- this) b ++= f(x).seq
+ b.result
+ }
+
+ /** Selects all elements of this $coll which satisfy a predicate.
+ *
+ * @param p the predicate used to test elements.
+ * @return a new $coll consisting of all elements of this $coll that satisfy the given
+ * predicate `p`. The order of the elements is preserved.
+ */
+ def filter(p: A => Boolean): Repr = {
+ val b = newBuilder
+ for (x <- this)
+ if (p(x)) b += x
+ b.result
+ }
+
+ /** Selects all elements of this $coll which do not satisfy a predicate.
+ *
+ * @param p the predicate used to test elements.
+ * @return a new $coll consisting of all elements of this $coll that do not satisfy the given
+ * predicate `p`. The order of the elements is preserved.
+ */
+ def filterNot(p: A => Boolean): Repr = filter(!p(_))
+
+ def collect[B, That](pf: PartialFunction[A, B])(implicit bf: CanBuildFrom[Repr, B, That]): That = {
+ val b = bf(repr)
+ for (x <- this) if (pf.isDefinedAt(x)) b += pf(x)
+ b.result
+ }
+
+ /** Builds a new collection by applying an option-valued function to all
+ * elements of this $coll on which the function is defined.
+ *
+ * @param f the option-valued function which filters and maps the $coll.
+ * @tparam B the element type of the returned collection.
+ * @tparam That $thatinfo
+ * @param bf $bfinfo
+ * @return a new collection of type `That` resulting from applying the option-valued function
+ * `f` to each element and collecting all defined results.
+ * The order of the elements is preserved.
+ *
+ * @usecase def filterMap[B](f: A => Option[B]): $Coll[B]
+ *
+ * @param pf the partial function which filters and maps the $coll.
+ * @return a new $coll resulting from applying the given option-valued function
+ * `f` to each element and collecting all defined results.
+ * The order of the elements is preserved.
+ def filterMap[B, That](f: A => Option[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = {
+ val b = bf(repr)
+ for (x <- this)
+ f(x) match {
+ case Some(y) => b += y
+ case _ =>
+ }
+ b.result
+ }
+ */
+
+ /** Partitions this $coll in two ${coll}s according to a predicate.
+ *
+ * @param p the predicate on which to partition.
+ * @return a pair of ${coll}s: the first $coll consists of all elements that
+ * satisfy the predicate `p` and the second $coll consists of all elements
+ * that don't. The relative order of the elements in the resulting ${coll}s
+ * is the same as in the original $coll.
+ */
+ def partition(p: A => Boolean): (Repr, Repr) = {
+ val l, r = newBuilder
+ for (x <- this) (if (p(x)) l else r) += x
+ (l.result, r.result)
+ }
+
+ def groupBy[K](f: A => K): immutable.Map[K, Repr] = {
+ val m = mutable.Map.empty[K, Builder[A, Repr]]
+ for (elem <- this) {
+ val key = f(elem)
+ val bldr = m.getOrElseUpdate(key, newBuilder)
+ bldr += elem
+ }
+ val b = immutable.Map.newBuilder[K, Repr]
+ for ((k, v) <- m)
+ b += ((k, v.result))
+
+ b.result
+ }
+
+ /** Tests whether a predicate holds for all elements of this $coll.
+ *
+ * $mayNotTerminateInf
+ *
+ * @param p the predicate used to test elements.
+ * @return `true` if the given predicate `p` holds for all elements
+ * of this $coll, otherwise `false`.
+ */
+ def forall(p: A => Boolean): Boolean = {
+ var result = true
+ breakable {
+ for (x <- this)
+ if (!p(x)) { result = false; break }
+ }
+ result
+ }
+
+ /** Tests whether a predicate holds for some of the elements of this $coll.
+ *
+ * $mayNotTerminateInf
+ *
+ * @param p the predicate used to test elements.
+ * @return `true` if the given predicate `p` holds for some of the
+ * elements of this $coll, otherwise `false`.
+ */
+ def exists(p: A => Boolean): Boolean = {
+ var result = false
+ breakable {
+ for (x <- this)
+ if (p(x)) { result = true; break }
+ }
+ result
+ }
+
+ /** Finds the first element of the $coll satisfying a predicate, if any.
+ *
+ * $mayNotTerminateInf
+ * $orderDependent
+ *
+ * @param p the predicate used to test elements.
+ * @return an option value containing the first element in the $coll
+ * that satisfies `p`, or `None` if none exists.
+ */
+ def find(p: A => Boolean): Option[A] = {
+ var result: Option[A] = None
+ breakable {
+ for (x <- this)
+ if (p(x)) { result = Some(x); break }
+ }
+ result
+ }
+
+ def scan[B >: A, That](z: B)(op: (B, B) => B)(implicit cbf: CanBuildFrom[Repr, B, That]): That = scanLeft(z)(op)
+
+ def scanLeft[B, That](z: B)(op: (B, A) => B)(implicit bf: CanBuildFrom[Repr, B, That]): That = {
+ val b = bf(repr)
+ b.sizeHint(this, 1)
+ var acc = z
+ b += acc
+ for (x <- this) { acc = op(acc, x); b += acc }
+ b.result
+ }
+
+ @migration(2, 9,
+ "This scanRight definition has changed in 2.9.\n" +
+ "The previous behavior can be reproduced with scanRight.reverse."
+ )
+ def scanRight[B, That](z: B)(op: (A, B) => B)(implicit bf: CanBuildFrom[Repr, B, That]): That = {
+ var scanned = List(z)
+ var acc = z
+ for (x <- reversed) {
+ acc = op(x, acc)
+ scanned ::= acc
+ }
+ val b = bf(repr)
+ for (elem <- scanned) b += elem
+ b.result
+ }
+
+ /** Selects the first element of this $coll.
+ * $orderDependent
+ * @return the first element of this $coll.
+ * @throws `NoSuchElementException` if the $coll is empty.
+ */
+ def head: A = {
+ var result: () => A = () => throw new NoSuchElementException
+ breakable {
+ for (x <- this) {
+ result = () => x
+ break
+ }
+ }
+ result()
+ }
+
+ /** Optionally selects the first element.
+ * $orderDependent
+ * @return the first element of this $coll if it is nonempty, `None` if it is empty.
+ */
+ def headOption: Option[A] = if (isEmpty) None else Some(head)
+
+ /** Selects all elements except the first.
+ * $orderDependent
+ * @return a $coll consisting of all elements of this $coll
+ * except the first one.
+ * @throws `UnsupportedOperationException` if the $coll is empty.
+ */
+ override def tail: Repr = {
+ if (isEmpty) throw new UnsupportedOperationException("empty.tail")
+ drop(1)
+ }
+
+ /** Selects the last element.
+ * $orderDependent
+ * @return The last element of this $coll.
+ * @throws NoSuchElementException If the $coll is empty.
+ */
+ def last: A = {
+ var lst = head
+ for (x <- this)
+ lst = x
+ lst
+ }
+
+ /** Optionally selects the last element.
+ * $orderDependent
+ * @return the last element of this $coll$ if it is nonempty, `None` if it is empty.
+ */
+ def lastOption: Option[A] = if (isEmpty) None else Some(last)
+
+ /** Selects all elements except the last.
+ * $orderDependent
+ * @return a $coll consisting of all elements of this $coll
+ * except the last one.
+ * @throws `UnsupportedOperationException` if the $coll is empty.
+ */
+ def init: Repr = {
+ if (isEmpty) throw new UnsupportedOperationException("empty.init")
+ var lst = head
+ var follow = false
+ val b = newBuilder
+ b.sizeHint(this, -1)
+ for (x <- this.seq) {
+ if (follow) b += lst
+ else follow = true
+ lst = x
+ }
+ b.result
+ }
+
+ def take(n: Int): Repr = slice(0, n)
+
+ def drop(n: Int): Repr =
+ if (n <= 0) {
+ val b = newBuilder
+ b.sizeHint(this)
+ b ++= thisCollection result
+ }
+ else sliceWithKnownDelta(n, Int.MaxValue, -n)
+
+ def slice(from: Int, until: Int): Repr = sliceWithKnownBound(math.max(from, 0), until)
+
+ // Precondition: from >= 0, until > 0, builder already configured for building.
+ private[this] def sliceInternal(from: Int, until: Int, b: Builder[A, Repr]): Repr = {
+ var i = 0
+ breakable {
+ for (x <- this.seq) {
+ if (i >= from) b += x
+ i += 1
+ if (i >= until) break
+ }
+ }
+ b.result
+ }
+ // Precondition: from >= 0
+ private[scala] def sliceWithKnownDelta(from: Int, until: Int, delta: Int): Repr = {
+ val b = newBuilder
+ if (until <= from) b.result
+ else {
+ b.sizeHint(this, delta)
+ sliceInternal(from, until, b)
+ }
+ }
+ // Precondition: from >= 0
+ private[scala] def sliceWithKnownBound(from: Int, until: Int): Repr = {
+ val b = newBuilder
+ if (until <= from) b.result
+ else {
+ b.sizeHintBounded(until - from, this)
+ sliceInternal(from, until, b)
+ }
+ }
+
+ def takeWhile(p: A => Boolean): Repr = {
+ val b = newBuilder
+ breakable {
+ for (x <- this) {
+ if (!p(x)) break
+ b += x
+ }
+ }
+ b.result
+ }
+
+ def dropWhile(p: A => Boolean): Repr = {
+ val b = newBuilder
+ var go = false
+ for (x <- this) {
+ if (!p(x)) go = true
+ if (go) b += x
+ }
+ b.result
+ }
+
+ def span(p: A => Boolean): (Repr, Repr) = {
+ val l, r = newBuilder
+ var toLeft = true
+ for (x <- this) {
+ toLeft = toLeft && p(x)
+ (if (toLeft) l else r) += x
+ }
+ (l.result, r.result)
+ }
+
+ def splitAt(n: Int): (Repr, Repr) = {
+ val l, r = newBuilder
+ l.sizeHintBounded(n, this)
+ if (n >= 0) r.sizeHint(this, -n)
+ var i = 0
+ for (x <- this) {
+ (if (i < n) l else r) += x
+ i += 1
+ }
+ (l.result, r.result)
+ }
+
+ /** Iterates over the tails of this $coll. The first value will be this
+ * $coll and the final one will be an empty $coll, with the intervening
+ * values the results of successive applications of `tail`.
+ *
+ * @return an iterator over all the tails of this $coll
+ * @example `List(1,2,3).tails = Iterator(List(1,2,3), List(2,3), List(3), Nil)`
+ */
+ def tails: Iterator[Repr] = iterateUntilEmpty(_.tail)
+
+ /** Iterates over the inits of this $coll. The first value will be this
+ * $coll and the final one will be an empty $coll, with the intervening
+ * values the results of successive applications of `init`.
+ *
+ * @return an iterator over all the inits of this $coll
+ * @example `List(1,2,3).inits = Iterator(List(1,2,3), List(1,2), List(1), Nil)`
+ */
+ def inits: Iterator[Repr] = iterateUntilEmpty(_.init)
+
+ /** Copies elements of this $coll to an array.
+ * Fills the given array `xs` with at most `len` elements of
+ * this $coll, starting at position `start`.
+ * Copying will stop once either the end of the current $coll is reached,
+ * or the end of the array is reached, or `len` elements have been copied.
+ *
+ * $willNotTerminateInf
+ *
+ * @param xs the array to fill.
+ * @param start the starting index.
+ * @param len the maximal number of elements to copy.
+ * @tparam B the type of the elements of the array.
+ *
+ *
+ * @usecase def copyToArray(xs: Array[A], start: Int, len: Int): Unit
+ */
+ def copyToArray[B >: A](xs: Array[B], start: Int, len: Int) {
+ var i = start
+ val end = (start + len) min xs.length
+ breakable {
+ for (x <- this) {
+ if (i >= end) break
+ xs(i) = x
+ i += 1
+ }
+ }
+ }
+
+ def toTraversable: Traversable[A] = thisCollection
+ def toIterator: Iterator[A] = toStream.iterator
+ def toStream: Stream[A] = toBuffer.toStream
+
+ /** Converts this $coll to a string.
+ *
+ * @return a string representation of this collection. By default this
+ * string consists of the `stringPrefix` of this $coll,
+ * followed by all elements separated by commas and enclosed in parentheses.
+ */
+ override def toString = mkString(stringPrefix + "(", ", ", ")")
+
+ /** Defines the prefix of this object's `toString` representation.
+ *
+ * @return a string representation which starts the result of `toString`
+ * applied to this $coll. By default the string prefix is the
+ * simple name of the collection class $coll.
+ */
+ def stringPrefix : String = {
+ var string = repr.asInstanceOf[AnyRef].getClass.getName
+ val idx1 = string.lastIndexOf('.' : Int)
+ if (idx1 != -1) string = string.substring(idx1 + 1)
+ val idx2 = string.indexOf('$')
+ if (idx2 != -1) string = string.substring(0, idx2)
+ string
+ }
+
+ /** Creates a non-strict view of this $coll.
+ *
+ * @return a non-strict view of this $coll.
+ */
+ def view = new TraversableView[A, Repr] {
+ protected lazy val underlying = self.repr
+ override def foreach[U](f: A => U) = self foreach f
+ }
+
+ /** Creates a non-strict view of a slice of this $coll.
+ *
+ * Note: the difference between `view` and `slice` is that `view` produces
+ * a view of the current $coll, whereas `slice` produces a new $coll.
+ *
+ * Note: `view(from, to)` is equivalent to `view.slice(from, to)`
+ * $orderDependent
+ *
+ * @param from the index of the first element of the view
+ * @param until the index of the element following the view
+ * @return a non-strict view of a slice of this $coll, starting at index `from`
+ * and extending up to (but not including) index `until`.
+ */
+ def view(from: Int, until: Int): TraversableView[A, Repr] = view.slice(from, until)
+
+ /** Creates a non-strict filter of this $coll.
+ *
+ * Note: the difference between `c filter p` and `c withFilter p` is that
+ * the former creates a new collection, whereas the latter only
+ * restricts the domain of subsequent `map`, `flatMap`, `foreach`,
+ * and `withFilter` operations.
+ * $orderDependent
+ *
+ * @param p the predicate used to test elements.
+ * @return an object of class `WithFilter`, which supports
+ * `map`, `flatMap`, `foreach`, and `withFilter` operations.
+ * All these operations apply to those elements of this $coll which
+ * satisfy the predicate `p`.
+ */
+ def withFilter(p: A => Boolean): FilterMonadic[A, Repr] = new WithFilter(p)
+
+ /** A class supporting filtered operations. Instances of this class are
+ * returned by method `withFilter`.
+ */
+ class WithFilter(p: A => Boolean) extends FilterMonadic[A, Repr] {
+
+ /** Builds a new collection by applying a function to all elements of the
+ * outer $coll containing this `WithFilter` instance that satisfy predicate `p`.
+ *
+ * @param f the function to apply to each element.
+ * @tparam B the element type of the returned collection.
+ * @tparam That $thatinfo
+ * @param bf $bfinfo
+ * @return a new collection of type `That` resulting from applying
+ * the given function `f` to each element of the outer $coll
+ * that satisfies predicate `p` and collecting the results.
+ *
+ * @usecase def map[B](f: A => B): $Coll[B]
+ *
+ * @return a new $coll resulting from applying the given function
+ * `f` to each element of the outer $coll that satisfies
+ * predicate `p` and collecting the results.
+ */
+ def map[B, That](f: A => B)(implicit bf: CanBuildFrom[Repr, B, That]): That = {
+ val b = bf(repr)
+ for (x <- self)
+ if (p(x)) b += f(x)
+ b.result
+ }
+
+ /** Builds a new collection by applying a function to all elements of the
+ * outer $coll containing this `WithFilter` instance that satisfy
+ * predicate `p` and concatenating the results.
+ *
+ * @param f the function to apply to each element.
+ * @tparam B the element type of the returned collection.
+ * @tparam That $thatinfo
+ * @param bf $bfinfo
+ * @return a new collection of type `That` resulting from applying
+ * the given collection-valued function `f` to each element
+ * of the outer $coll that satisfies predicate `p` and
+ * concatenating the results.
+ *
+ * @usecase def flatMap[B](f: A => TraversableOnce[B]): $Coll[B]
+ *
+ * @return a new $coll resulting from applying the given collection-valued function
+ * `f` to each element of the outer $coll that satisfies predicate `p` and concatenating the results.
+ */
+ def flatMap[B, That](f: A => GenTraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = {
+ val b = bf(repr)
+ for (x <- self)
+ if (p(x)) b ++= f(x).seq
+ b.result
+ }
+
+ /** Applies a function `f` to all elements of the outer $coll containing
+ * this `WithFilter` instance that satisfy predicate `p`.
+ *
+ * @param f the function that is applied for its side-effect to every element.
+ * The result of function `f` is discarded.
+ *
+ * @tparam U the type parameter describing the result of function `f`.
+ * This result will always be ignored. Typically `U` is `Unit`,
+ * but this is not necessary.
+ *
+ * @usecase def foreach(f: A => Unit): Unit
+ */
+ def foreach[U](f: A => U): Unit =
+ for (x <- self)
+ if (p(x)) f(x)
+
+ /** Further refines the filter for this $coll.
+ *
+ * @param q the predicate used to test elements.
+ * @return an object of class `WithFilter`, which supports
+ * `map`, `flatMap`, `foreach`, and `withFilter` operations.
+ * All these operations apply to those elements of this $coll which
+ * satisfy the predicate `q` in addition to the predicate `p`.
+ */
+ def withFilter(q: A => Boolean): WithFilter =
+ new WithFilter(x => p(x) && q(x))
+ }
+
+ // A helper for tails and inits.
+ private def iterateUntilEmpty(f: Traversable[A @uV] => Traversable[A @uV]): Iterator[Repr] = {
+ val it = Iterator.iterate(thisCollection)(f) takeWhile (x => !x.isEmpty)
+ it ++ Iterator(Nil) map (newBuilder ++= _ result)
+ }
+ }
+
+
+</textarea>
+</form>
+
+ <script>
+ var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
+ lineNumbers: true,
+ matchBrackets: true,
+ theme: "ambiance",
+ mode: "text/x-scala"
+ });
+ </script>
+ </body>
+</html>
git://git.onelab.eu / myslice.git / blobdiff