scala.html (28518B)
1 <!doctype html> 2 3 <title>CodeMirror: Scala mode</title> 4 <meta charset="utf-8"/> 5 <link rel=stylesheet href="../../doc/docs.css"> 6 7 <link rel="stylesheet" href="../../lib/codemirror.css"> 8 <link rel="stylesheet" href="../../theme/ambiance.css"> 9 <script src="../../lib/codemirror.js"></script> 10 <script src="../../addon/edit/matchbrackets.js"></script> 11 <script src="clike.js"></script> 12 <div id=nav> 13 <a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a> 14 15 <ul> 16 <li><a href="../../index.html">Home</a> 17 <li><a href="../../doc/manual.html">Manual</a> 18 <li><a href="https://github.com/codemirror/codemirror">Code</a> 19 </ul> 20 <ul> 21 <li><a href="../index.html">Language modes</a> 22 <li><a class=active href="#">Scala</a> 23 </ul> 24 </div> 25 26 <article> 27 <h2>Scala mode</h2> 28 <form> 29 <textarea id="code" name="code"> 30 31 /* __ *\ 32 ** ________ ___ / / ___ Scala API ** 33 ** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** 34 ** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** 35 ** /____/\___/_/ |_/____/_/ | | ** 36 ** |/ ** 37 \* */ 38 39 package scala.collection 40 41 import generic._ 42 import mutable.{ Builder, ListBuffer } 43 import annotation.{tailrec, migration, bridge} 44 import annotation.unchecked.{ uncheckedVariance => uV } 45 import parallel.ParIterable 46 47 /** A template trait for traversable collections of type `Traversable[A]`. 48 * 49 * $traversableInfo 50 * @define mutability 51 * @define traversableInfo 52 * This is a base trait of all kinds of $mutability Scala collections. It 53 * implements the behavior common to all collections, in terms of a method 54 * `foreach` with signature: 55 * {{{ 56 * def foreach[U](f: Elem => U): Unit 57 * }}} 58 * Collection classes mixing in this trait provide a concrete 59 * `foreach` method which traverses all the 60 * elements contained in the collection, applying a given function to each. 61 * They also need to provide a method `newBuilder` 62 * which creates a builder for collections of the same kind. 63 * 64 * A traversable class might or might not have two properties: strictness 65 * and orderedness. Neither is represented as a type. 66 * 67 * The instances of a strict collection class have all their elements 68 * computed before they can be used as values. By contrast, instances of 69 * a non-strict collection class may defer computation of some of their 70 * elements until after the instance is available as a value. 71 * A typical example of a non-strict collection class is a 72 * <a href="../immutable/Stream.html" target="ContentFrame"> 73 * `scala.collection.immutable.Stream`</a>. 74 * A more general class of examples are `TraversableViews`. 75 * 76 * If a collection is an instance of an ordered collection class, traversing 77 * its elements with `foreach` will always visit elements in the 78 * same order, even for different runs of the program. If the class is not 79 * ordered, `foreach` can visit elements in different orders for 80 * different runs (but it will keep the same order in the same run).' 81 * 82 * A typical example of a collection class which is not ordered is a 83 * `HashMap` of objects. The traversal order for hash maps will 84 * depend on the hash codes of its elements, and these hash codes might 85 * differ from one run to the next. By contrast, a `LinkedHashMap` 86 * is ordered because it's `foreach` method visits elements in the 87 * order they were inserted into the `HashMap`. 88 * 89 * @author Martin Odersky 90 * @version 2.8 91 * @since 2.8 92 * @tparam A the element type of the collection 93 * @tparam Repr the type of the actual collection containing the elements. 94 * 95 * @define Coll Traversable 96 * @define coll traversable collection 97 */ 98 trait TraversableLike[+A, +Repr] extends HasNewBuilder[A, Repr] 99 with FilterMonadic[A, Repr] 100 with TraversableOnce[A] 101 with GenTraversableLike[A, Repr] 102 with Parallelizable[A, ParIterable[A]] 103 { 104 self => 105 106 import Traversable.breaks._ 107 108 /** The type implementing this traversable */ 109 protected type Self = Repr 110 111 /** The collection of type $coll underlying this `TraversableLike` object. 112 * By default this is implemented as the `TraversableLike` object itself, 113 * but this can be overridden. 114 */ 115 def repr: Repr = this.asInstanceOf[Repr] 116 117 /** The underlying collection seen as an instance of `$Coll`. 118 * By default this is implemented as the current collection object itself, 119 * but this can be overridden. 120 */ 121 protected[this] def thisCollection: Traversable[A] = this.asInstanceOf[Traversable[A]] 122 123 /** A conversion from collections of type `Repr` to `$Coll` objects. 124 * By default this is implemented as just a cast, but this can be overridden. 125 */ 126 protected[this] def toCollection(repr: Repr): Traversable[A] = repr.asInstanceOf[Traversable[A]] 127 128 /** Creates a new builder for this collection type. 129 */ 130 protected[this] def newBuilder: Builder[A, Repr] 131 132 protected[this] def parCombiner = ParIterable.newCombiner[A] 133 134 /** Applies a function `f` to all elements of this $coll. 135 * 136 * Note: this method underlies the implementation of most other bulk operations. 137 * It's important to implement this method in an efficient way. 138 * 139 * 140 * @param f the function that is applied for its side-effect to every element. 141 * The result of function `f` is discarded. 142 * 143 * @tparam U the type parameter describing the result of function `f`. 144 * This result will always be ignored. Typically `U` is `Unit`, 145 * but this is not necessary. 146 * 147 * @usecase def foreach(f: A => Unit): Unit 148 */ 149 def foreach[U](f: A => U): Unit 150 151 /** Tests whether this $coll is empty. 152 * 153 * @return `true` if the $coll contain no elements, `false` otherwise. 154 */ 155 def isEmpty: Boolean = { 156 var result = true 157 breakable { 158 for (x <- this) { 159 result = false 160 break 161 } 162 } 163 result 164 } 165 166 /** Tests whether this $coll is known to have a finite size. 167 * All strict collections are known to have finite size. For a non-strict collection 168 * such as `Stream`, the predicate returns `true` if all elements have been computed. 169 * It returns `false` if the stream is not yet evaluated to the end. 170 * 171 * Note: many collection methods will not work on collections of infinite sizes. 172 * 173 * @return `true` if this collection is known to have finite size, `false` otherwise. 174 */ 175 def hasDefiniteSize = true 176 177 def ++[B >: A, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = { 178 val b = bf(repr) 179 if (that.isInstanceOf[IndexedSeqLike[_, _]]) b.sizeHint(this, that.seq.size) 180 b ++= thisCollection 181 b ++= that.seq 182 b.result 183 } 184 185 @bridge 186 def ++[B >: A, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = 187 ++(that: GenTraversableOnce[B])(bf) 188 189 /** Concatenates this $coll with the elements of a traversable collection. 190 * It differs from ++ in that the right operand determines the type of the 191 * resulting collection rather than the left one. 192 * 193 * @param that the traversable to append. 194 * @tparam B the element type of the returned collection. 195 * @tparam That $thatinfo 196 * @param bf $bfinfo 197 * @return a new collection of type `That` which contains all elements 198 * of this $coll followed by all elements of `that`. 199 * 200 * @usecase def ++:[B](that: TraversableOnce[B]): $Coll[B] 201 * 202 * @return a new $coll which contains all elements of this $coll 203 * followed by all elements of `that`. 204 */ 205 def ++:[B >: A, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = { 206 val b = bf(repr) 207 if (that.isInstanceOf[IndexedSeqLike[_, _]]) b.sizeHint(this, that.size) 208 b ++= that 209 b ++= thisCollection 210 b.result 211 } 212 213 /** This overload exists because: for the implementation of ++: we should reuse 214 * that of ++ because many collections override it with more efficient versions. 215 * Since TraversableOnce has no '++' method, we have to implement that directly, 216 * but Traversable and down can use the overload. 217 */ 218 def ++:[B >: A, That](that: Traversable[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = 219 (that ++ seq)(breakOut) 220 221 def map[B, That](f: A => B)(implicit bf: CanBuildFrom[Repr, B, That]): That = { 222 val b = bf(repr) 223 b.sizeHint(this) 224 for (x <- this) b += f(x) 225 b.result 226 } 227 228 def flatMap[B, That](f: A => GenTraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = { 229 val b = bf(repr) 230 for (x <- this) b ++= f(x).seq 231 b.result 232 } 233 234 /** Selects all elements of this $coll which satisfy a predicate. 235 * 236 * @param p the predicate used to test elements. 237 * @return a new $coll consisting of all elements of this $coll that satisfy the given 238 * predicate `p`. The order of the elements is preserved. 239 */ 240 def filter(p: A => Boolean): Repr = { 241 val b = newBuilder 242 for (x <- this) 243 if (p(x)) b += x 244 b.result 245 } 246 247 /** Selects all elements of this $coll which do not satisfy a predicate. 248 * 249 * @param p the predicate used to test elements. 250 * @return a new $coll consisting of all elements of this $coll that do not satisfy the given 251 * predicate `p`. The order of the elements is preserved. 252 */ 253 def filterNot(p: A => Boolean): Repr = filter(!p(_)) 254 255 def collect[B, That](pf: PartialFunction[A, B])(implicit bf: CanBuildFrom[Repr, B, That]): That = { 256 val b = bf(repr) 257 for (x <- this) if (pf.isDefinedAt(x)) b += pf(x) 258 b.result 259 } 260 261 /** Builds a new collection by applying an option-valued function to all 262 * elements of this $coll on which the function is defined. 263 * 264 * @param f the option-valued function which filters and maps the $coll. 265 * @tparam B the element type of the returned collection. 266 * @tparam That $thatinfo 267 * @param bf $bfinfo 268 * @return a new collection of type `That` resulting from applying the option-valued function 269 * `f` to each element and collecting all defined results. 270 * The order of the elements is preserved. 271 * 272 * @usecase def filterMap[B](f: A => Option[B]): $Coll[B] 273 * 274 * @param pf the partial function which filters and maps the $coll. 275 * @return a new $coll resulting from applying the given option-valued function 276 * `f` to each element and collecting all defined results. 277 * The order of the elements is preserved. 278 def filterMap[B, That](f: A => Option[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = { 279 val b = bf(repr) 280 for (x <- this) 281 f(x) match { 282 case Some(y) => b += y 283 case _ => 284 } 285 b.result 286 } 287 */ 288 289 /** Partitions this $coll in two ${coll}s according to a predicate. 290 * 291 * @param p the predicate on which to partition. 292 * @return a pair of ${coll}s: the first $coll consists of all elements that 293 * satisfy the predicate `p` and the second $coll consists of all elements 294 * that don't. The relative order of the elements in the resulting ${coll}s 295 * is the same as in the original $coll. 296 */ 297 def partition(p: A => Boolean): (Repr, Repr) = { 298 val l, r = newBuilder 299 for (x <- this) (if (p(x)) l else r) += x 300 (l.result, r.result) 301 } 302 303 def groupBy[K](f: A => K): immutable.Map[K, Repr] = { 304 val m = mutable.Map.empty[K, Builder[A, Repr]] 305 for (elem <- this) { 306 val key = f(elem) 307 val bldr = m.getOrElseUpdate(key, newBuilder) 308 bldr += elem 309 } 310 val b = immutable.Map.newBuilder[K, Repr] 311 for ((k, v) <- m) 312 b += ((k, v.result)) 313 314 b.result 315 } 316 317 /** Tests whether a predicate holds for all elements of this $coll. 318 * 319 * $mayNotTerminateInf 320 * 321 * @param p the predicate used to test elements. 322 * @return `true` if the given predicate `p` holds for all elements 323 * of this $coll, otherwise `false`. 324 */ 325 def forall(p: A => Boolean): Boolean = { 326 var result = true 327 breakable { 328 for (x <- this) 329 if (!p(x)) { result = false; break } 330 } 331 result 332 } 333 334 /** Tests whether a predicate holds for some of the elements of this $coll. 335 * 336 * $mayNotTerminateInf 337 * 338 * @param p the predicate used to test elements. 339 * @return `true` if the given predicate `p` holds for some of the 340 * elements of this $coll, otherwise `false`. 341 */ 342 def exists(p: A => Boolean): Boolean = { 343 var result = false 344 breakable { 345 for (x <- this) 346 if (p(x)) { result = true; break } 347 } 348 result 349 } 350 351 /** Finds the first element of the $coll satisfying a predicate, if any. 352 * 353 * $mayNotTerminateInf 354 * $orderDependent 355 * 356 * @param p the predicate used to test elements. 357 * @return an option value containing the first element in the $coll 358 * that satisfies `p`, or `None` if none exists. 359 */ 360 def find(p: A => Boolean): Option[A] = { 361 var result: Option[A] = None 362 breakable { 363 for (x <- this) 364 if (p(x)) { result = Some(x); break } 365 } 366 result 367 } 368 369 def scan[B >: A, That](z: B)(op: (B, B) => B)(implicit cbf: CanBuildFrom[Repr, B, That]): That = scanLeft(z)(op) 370 371 def scanLeft[B, That](z: B)(op: (B, A) => B)(implicit bf: CanBuildFrom[Repr, B, That]): That = { 372 val b = bf(repr) 373 b.sizeHint(this, 1) 374 var acc = z 375 b += acc 376 for (x <- this) { acc = op(acc, x); b += acc } 377 b.result 378 } 379 380 @migration(2, 9, 381 "This scanRight definition has changed in 2.9.\n" + 382 "The previous behavior can be reproduced with scanRight.reverse." 383 ) 384 def scanRight[B, That](z: B)(op: (A, B) => B)(implicit bf: CanBuildFrom[Repr, B, That]): That = { 385 var scanned = List(z) 386 var acc = z 387 for (x <- reversed) { 388 acc = op(x, acc) 389 scanned ::= acc 390 } 391 val b = bf(repr) 392 for (elem <- scanned) b += elem 393 b.result 394 } 395 396 /** Selects the first element of this $coll. 397 * $orderDependent 398 * @return the first element of this $coll. 399 * @throws `NoSuchElementException` if the $coll is empty. 400 */ 401 def head: A = { 402 var result: () => A = () => throw new NoSuchElementException 403 breakable { 404 for (x <- this) { 405 result = () => x 406 break 407 } 408 } 409 result() 410 } 411 412 /** Optionally selects the first element. 413 * $orderDependent 414 * @return the first element of this $coll if it is nonempty, `None` if it is empty. 415 */ 416 def headOption: Option[A] = if (isEmpty) None else Some(head) 417 418 /** Selects all elements except the first. 419 * $orderDependent 420 * @return a $coll consisting of all elements of this $coll 421 * except the first one. 422 * @throws `UnsupportedOperationException` if the $coll is empty. 423 */ 424 override def tail: Repr = { 425 if (isEmpty) throw new UnsupportedOperationException("empty.tail") 426 drop(1) 427 } 428 429 /** Selects the last element. 430 * $orderDependent 431 * @return The last element of this $coll. 432 * @throws NoSuchElementException If the $coll is empty. 433 */ 434 def last: A = { 435 var lst = head 436 for (x <- this) 437 lst = x 438 lst 439 } 440 441 /** Optionally selects the last element. 442 * $orderDependent 443 * @return the last element of this $coll$ if it is nonempty, `None` if it is empty. 444 */ 445 def lastOption: Option[A] = if (isEmpty) None else Some(last) 446 447 /** Selects all elements except the last. 448 * $orderDependent 449 * @return a $coll consisting of all elements of this $coll 450 * except the last one. 451 * @throws `UnsupportedOperationException` if the $coll is empty. 452 */ 453 def init: Repr = { 454 if (isEmpty) throw new UnsupportedOperationException("empty.init") 455 var lst = head 456 var follow = false 457 val b = newBuilder 458 b.sizeHint(this, -1) 459 for (x <- this.seq) { 460 if (follow) b += lst 461 else follow = true 462 lst = x 463 } 464 b.result 465 } 466 467 def take(n: Int): Repr = slice(0, n) 468 469 def drop(n: Int): Repr = 470 if (n <= 0) { 471 val b = newBuilder 472 b.sizeHint(this) 473 b ++= thisCollection result 474 } 475 else sliceWithKnownDelta(n, Int.MaxValue, -n) 476 477 def slice(from: Int, until: Int): Repr = sliceWithKnownBound(math.max(from, 0), until) 478 479 // Precondition: from >= 0, until > 0, builder already configured for building. 480 private[this] def sliceInternal(from: Int, until: Int, b: Builder[A, Repr]): Repr = { 481 var i = 0 482 breakable { 483 for (x <- this.seq) { 484 if (i >= from) b += x 485 i += 1 486 if (i >= until) break 487 } 488 } 489 b.result 490 } 491 // Precondition: from >= 0 492 private[scala] def sliceWithKnownDelta(from: Int, until: Int, delta: Int): Repr = { 493 val b = newBuilder 494 if (until <= from) b.result 495 else { 496 b.sizeHint(this, delta) 497 sliceInternal(from, until, b) 498 } 499 } 500 // Precondition: from >= 0 501 private[scala] def sliceWithKnownBound(from: Int, until: Int): Repr = { 502 val b = newBuilder 503 if (until <= from) b.result 504 else { 505 b.sizeHintBounded(until - from, this) 506 sliceInternal(from, until, b) 507 } 508 } 509 510 def takeWhile(p: A => Boolean): Repr = { 511 val b = newBuilder 512 breakable { 513 for (x <- this) { 514 if (!p(x)) break 515 b += x 516 } 517 } 518 b.result 519 } 520 521 def dropWhile(p: A => Boolean): Repr = { 522 val b = newBuilder 523 var go = false 524 for (x <- this) { 525 if (!p(x)) go = true 526 if (go) b += x 527 } 528 b.result 529 } 530 531 def span(p: A => Boolean): (Repr, Repr) = { 532 val l, r = newBuilder 533 var toLeft = true 534 for (x <- this) { 535 toLeft = toLeft && p(x) 536 (if (toLeft) l else r) += x 537 } 538 (l.result, r.result) 539 } 540 541 def splitAt(n: Int): (Repr, Repr) = { 542 val l, r = newBuilder 543 l.sizeHintBounded(n, this) 544 if (n >= 0) r.sizeHint(this, -n) 545 var i = 0 546 for (x <- this) { 547 (if (i < n) l else r) += x 548 i += 1 549 } 550 (l.result, r.result) 551 } 552 553 /** Iterates over the tails of this $coll. The first value will be this 554 * $coll and the final one will be an empty $coll, with the intervening 555 * values the results of successive applications of `tail`. 556 * 557 * @return an iterator over all the tails of this $coll 558 * @example `List(1,2,3).tails = Iterator(List(1,2,3), List(2,3), List(3), Nil)` 559 */ 560 def tails: Iterator[Repr] = iterateUntilEmpty(_.tail) 561 562 /** Iterates over the inits of this $coll. The first value will be this 563 * $coll and the final one will be an empty $coll, with the intervening 564 * values the results of successive applications of `init`. 565 * 566 * @return an iterator over all the inits of this $coll 567 * @example `List(1,2,3).inits = Iterator(List(1,2,3), List(1,2), List(1), Nil)` 568 */ 569 def inits: Iterator[Repr] = iterateUntilEmpty(_.init) 570 571 /** Copies elements of this $coll to an array. 572 * Fills the given array `xs` with at most `len` elements of 573 * this $coll, starting at position `start`. 574 * Copying will stop once either the end of the current $coll is reached, 575 * or the end of the array is reached, or `len` elements have been copied. 576 * 577 * $willNotTerminateInf 578 * 579 * @param xs the array to fill. 580 * @param start the starting index. 581 * @param len the maximal number of elements to copy. 582 * @tparam B the type of the elements of the array. 583 * 584 * 585 * @usecase def copyToArray(xs: Array[A], start: Int, len: Int): Unit 586 */ 587 def copyToArray[B >: A](xs: Array[B], start: Int, len: Int) { 588 var i = start 589 val end = (start + len) min xs.length 590 breakable { 591 for (x <- this) { 592 if (i >= end) break 593 xs(i) = x 594 i += 1 595 } 596 } 597 } 598 599 def toTraversable: Traversable[A] = thisCollection 600 def toIterator: Iterator[A] = toStream.iterator 601 def toStream: Stream[A] = toBuffer.toStream 602 603 /** Converts this $coll to a string. 604 * 605 * @return a string representation of this collection. By default this 606 * string consists of the `stringPrefix` of this $coll, 607 * followed by all elements separated by commas and enclosed in parentheses. 608 */ 609 override def toString = mkString(stringPrefix + "(", ", ", ")") 610 611 /** Defines the prefix of this object's `toString` representation. 612 * 613 * @return a string representation which starts the result of `toString` 614 * applied to this $coll. By default the string prefix is the 615 * simple name of the collection class $coll. 616 */ 617 def stringPrefix : String = { 618 var string = repr.asInstanceOf[AnyRef].getClass.getName 619 val idx1 = string.lastIndexOf('.' : Int) 620 if (idx1 != -1) string = string.substring(idx1 + 1) 621 val idx2 = string.indexOf('$') 622 if (idx2 != -1) string = string.substring(0, idx2) 623 string 624 } 625 626 /** Creates a non-strict view of this $coll. 627 * 628 * @return a non-strict view of this $coll. 629 */ 630 def view = new TraversableView[A, Repr] { 631 protected lazy val underlying = self.repr 632 override def foreach[U](f: A => U) = self foreach f 633 } 634 635 /** Creates a non-strict view of a slice of this $coll. 636 * 637 * Note: the difference between `view` and `slice` is that `view` produces 638 * a view of the current $coll, whereas `slice` produces a new $coll. 639 * 640 * Note: `view(from, to)` is equivalent to `view.slice(from, to)` 641 * $orderDependent 642 * 643 * @param from the index of the first element of the view 644 * @param until the index of the element following the view 645 * @return a non-strict view of a slice of this $coll, starting at index `from` 646 * and extending up to (but not including) index `until`. 647 */ 648 def view(from: Int, until: Int): TraversableView[A, Repr] = view.slice(from, until) 649 650 /** Creates a non-strict filter of this $coll. 651 * 652 * Note: the difference between `c filter p` and `c withFilter p` is that 653 * the former creates a new collection, whereas the latter only 654 * restricts the domain of subsequent `map`, `flatMap`, `foreach`, 655 * and `withFilter` operations. 656 * $orderDependent 657 * 658 * @param p the predicate used to test elements. 659 * @return an object of class `WithFilter`, which supports 660 * `map`, `flatMap`, `foreach`, and `withFilter` operations. 661 * All these operations apply to those elements of this $coll which 662 * satisfy the predicate `p`. 663 */ 664 def withFilter(p: A => Boolean): FilterMonadic[A, Repr] = new WithFilter(p) 665 666 /** A class supporting filtered operations. Instances of this class are 667 * returned by method `withFilter`. 668 */ 669 class WithFilter(p: A => Boolean) extends FilterMonadic[A, Repr] { 670 671 /** Builds a new collection by applying a function to all elements of the 672 * outer $coll containing this `WithFilter` instance that satisfy predicate `p`. 673 * 674 * @param f the function to apply to each element. 675 * @tparam B the element type of the returned collection. 676 * @tparam That $thatinfo 677 * @param bf $bfinfo 678 * @return a new collection of type `That` resulting from applying 679 * the given function `f` to each element of the outer $coll 680 * that satisfies predicate `p` and collecting the results. 681 * 682 * @usecase def map[B](f: A => B): $Coll[B] 683 * 684 * @return a new $coll resulting from applying the given function 685 * `f` to each element of the outer $coll that satisfies 686 * predicate `p` and collecting the results. 687 */ 688 def map[B, That](f: A => B)(implicit bf: CanBuildFrom[Repr, B, That]): That = { 689 val b = bf(repr) 690 for (x <- self) 691 if (p(x)) b += f(x) 692 b.result 693 } 694 695 /** Builds a new collection by applying a function to all elements of the 696 * outer $coll containing this `WithFilter` instance that satisfy 697 * predicate `p` and concatenating the results. 698 * 699 * @param f the function to apply to each element. 700 * @tparam B the element type of the returned collection. 701 * @tparam That $thatinfo 702 * @param bf $bfinfo 703 * @return a new collection of type `That` resulting from applying 704 * the given collection-valued function `f` to each element 705 * of the outer $coll that satisfies predicate `p` and 706 * concatenating the results. 707 * 708 * @usecase def flatMap[B](f: A => TraversableOnce[B]): $Coll[B] 709 * 710 * @return a new $coll resulting from applying the given collection-valued function 711 * `f` to each element of the outer $coll that satisfies predicate `p` and concatenating the results. 712 */ 713 def flatMap[B, That](f: A => GenTraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = { 714 val b = bf(repr) 715 for (x <- self) 716 if (p(x)) b ++= f(x).seq 717 b.result 718 } 719 720 /** Applies a function `f` to all elements of the outer $coll containing 721 * this `WithFilter` instance that satisfy predicate `p`. 722 * 723 * @param f the function that is applied for its side-effect to every element. 724 * The result of function `f` is discarded. 725 * 726 * @tparam U the type parameter describing the result of function `f`. 727 * This result will always be ignored. Typically `U` is `Unit`, 728 * but this is not necessary. 729 * 730 * @usecase def foreach(f: A => Unit): Unit 731 */ 732 def foreach[U](f: A => U): Unit = 733 for (x <- self) 734 if (p(x)) f(x) 735 736 /** Further refines the filter for this $coll. 737 * 738 * @param q the predicate used to test elements. 739 * @return an object of class `WithFilter`, which supports 740 * `map`, `flatMap`, `foreach`, and `withFilter` operations. 741 * All these operations apply to those elements of this $coll which 742 * satisfy the predicate `q` in addition to the predicate `p`. 743 */ 744 def withFilter(q: A => Boolean): WithFilter = 745 new WithFilter(x => p(x) && q(x)) 746 } 747 748 // A helper for tails and inits. 749 private def iterateUntilEmpty(f: Traversable[A @uV] => Traversable[A @uV]): Iterator[Repr] = { 750 val it = Iterator.iterate(thisCollection)(f) takeWhile (x => !x.isEmpty) 751 it ++ Iterator(Nil) map (newBuilder ++= _ result) 752 } 753 } 754 755 756 </textarea> 757 </form> 758 759 <script> 760 var editor = CodeMirror.fromTextArea(document.getElementById("code"), { 761 lineNumbers: true, 762 matchBrackets: true, 763 theme: "ambiance", 764 mode: "text/x-scala" 765 }); 766 </script> 767 </article>