Merged revisions 21492-21512,21516-21518,21520-...

Merged revisions
21492-21512,21516-21518,21520-21525,21527,21529,21531,21535-21537,21539-
21543,21545-21548,21550,21552,21554-21560 via svnmerge from
https://lampsvn.epfl.ch/svn-repos/scala/scala/trunk

........
  r21492 | dubochet | 2010-04-12 19:04:31 +0200 (Mon, 12 Apr 2010) | 1 line

  [scaladoc] Lazy vals are printed as such, no longer as vars. No
review. ........ r21493 | dubochet | 2010-04-12 19:04:47 +0200 (Mon, 12
Apr 2010) | 1 line

  [scaladoc] Signature kind (def, val) needs more space to accommodate
lazy vals and implicit defs. ........ r21494 | dubochet | 2010-04-12
19:05:04 +0200 (Mon, 12 Apr 2010) | 1 line

  [scaladoc] Comment summary (first sentence) is extracted by comment
parser, which is a lot more robust and correct. No review. ........
r21495 | dragos | 2010-04-12 19:19:29 +0200 (Mon, 12 Apr 2010) | 4 lines

  Auto-generate scala.runtime.AbstractFunctionN classes. Moved zipped*
methods in Tuple1/2 in genprod, so that regenerating tuples does not
lose these methods. Added @specialized annotations into genprod for the
same reason. ........ r21496 | dragos | 2010-04-12 19:19:38 +0200 (Mon,
12 Apr 2010) | 5 lines

  Regenerated tuples, products and (Abstract)Functions. We needed to
have separate files for AbstractFunctionN because the compiler may need
their symbol even before their sourcefile is parsed. In such cases it
relies on finding a source file with the right name. ........ r21497 |
dragos | 2010-04-12 19:19:51 +0200 (Mon, 12 Apr 2010) | 1 line

  Don't generate forwarders for specialized methods. no review. ........
r21498 | dragos | 2010-04-12 19:19:59 +0200 (Mon, 12 Apr 2010) | 3 lines

  Companion objects of case classes extend AbstractFunctionN instead
of FunctionN. This saves quite some space, since FunctionN methods are
not re-mixed in for each object. ........ r21499 | dragos | 2010-04-12
19:20:07 +0200 (Mon, 12 Apr 2010) | 5 lines

  Fixed various position issues in specialized members. Removed an
instance where the tree transformer was run twice on the same tree,
resulting in double definition errors. Fixed re-typing of super calls
in constructor arguments for specialized members. No review. ........
r21500 | phaller | 2010-04-12 19:27:14 +0200 (Mon, 12 Apr 2010) | 1 line

  Restored partest behavior to write log files with normalized paths.
For new tests the check file can be copied from the log file. This makes
the behavior of --show-diff exactly the same as diffing the log and
check file. Review by extempore. ........ r21501 | dubochet | 2010-04-12
19:30:24 +0200 (Mon, 12 Apr 2010) | 1 line

  [scaladoc] Inner objects, which according to the compiler are actually
methods, are now printed as objects by Scaladoc. No review. ........
r21502 | phaller | 2010-04-12 21:18:31 +0200 (Mon, 12 Apr 2010) | 1 line

  Reverted r21500 until all test categories work again. ........ r21503
| dubochet | 2010-04-12 21:51:53 +0200 (Mon, 12 Apr 2010) | 1 line

  [scaladoc] Use case symbols have correct owner; inherited filter
works as expected with use cases. Review by odersky. ........ r21504 |
extempore | 2010-04-12 21:57:56 +0200 (Mon, 12 Apr 2010) | 5 lines

  Correct oversight where neg tests didn't demand a checkfile. More
trying to get timeout/interrupted logic so we know when things die
but also don't impede interrupts. Folded precondition logic into test
sequence logic, it's plenty general to cover it. Closes #3282, review by
phaller. ........ r21505 | malayeri | 2010-04-12 21:59:21 +0200 (Mon, 12
Apr 2010) | 7 lines

  [scaladoc] Cosmetic changes:
  - changed link color to underlined and dark purple
  - increased padding in gray lines of method definitions
  - lightened gray lines of method definitions
  - changed dashed and solid lines from black to gray
  - increased size of top template declaration; changed alignment
  Review by dubochet.
........
  r21506 | phaller | 2010-04-12 22:17:13 +0200 (Mon, 12 Apr 2010) | 1 line

  Disabled test that hangs when actors package is compiled with
specialization. Review by dragos. ........ r21507 | phaller | 2010-04-12
22:41:46 +0200 (Mon, 12 Apr 2010) | 1 line

  Another attempt at avoiding partest hang ups when the compiler
crashes. Review by extempore. ........ r21508 | dubochet | 2010-04-12
22:48:42 +0200 (Mon, 12 Apr 2010) | 1 line

  [scaladoc] Members inherited from sourceless files are correctly
printed in documentation. No review. ........ r21509 | malayeri |
2010-04-12 22:53:02 +0200 (Mon, 12 Apr 2010) | 1 line

  Changed the colors for types, value members, and tooltips. Feel free
to revert. Review by dubochet. ........ r21510 | extempore | 2010-04-12
23:36:33 +0200 (Mon, 12 Apr 2010) | 9 lines

  Still working on partest. Added ant targets which can be temporary if
  considered clutter.

    ant test.partest
    ant test.partest-opt

  They run some recently troublesome partest tests with a low timeout.
Logged some more exceptions where the compiler has been dying. Review by
phaller. ........ r21511 | extempore | 2010-04-12 23:45:17 +0200 (Mon,
12 Apr 2010) | 10 lines

  Disabling what I think are the last two failing tests, one each of the
  two leading bugs among those we've seen here today on testing theater:

    "could not find toMap: (x$1: scala.collection.TraversableOnce,x$2:
Predef$<:<)"

  and

    "scala.tools.nsc.symtab.Types$TypeError: method react cannot be
accessed in java.lang.Object with scala.actors.Reactor[Any]

  No review but hey lets' see if we can re-enable these tests soonish.
........ r21512 | prokopec | 2010-04-12 23:53:30 +0200 (Mon, 12 Apr
2010) | 1 line

  Documentation for mutable collections. No review. ........ r21516 |
extempore | 2010-04-13 01:20:03 +0200 (Tue, 13 Apr 2010) | 5 lines

  Noticed that Settings post-set hooks were not being set in the place
where they ought to be, so multiple setting settings (such as -optimise)
were not flipping all the right bits when set programmatically instead
of via command line options. This may be a factor in inlining issues,
though by itself it does not appear to solve anything. No review.
........ r21517 | malayeri | 2010-04-13 06:25:09 +0200 (Tue, 13 Apr
2010) | 1 line

  [scaladoc] Changed comment code and pre tages to not have "font-size:
small" attribute. Review by dubochet. ........ r21518 | plocinic |
2010-04-13 10:12:05 +0200 (Tue, 13 Apr 2010) | 1 line

  Some clean-ups. Removed old syntax, code duplication etc. No review.
........ r21520 | prokopec | 2010-04-13 12:29:58 +0200 (Tue, 13 Apr
2010) | 1 line

  docs for immutable.A-L*. no review
........
  r21521 | rytz | 2010-04-13 12:31:39 +0200 (Tue, 13 Apr 2010) | 1 line

  fixed most of stability, reviewed by iuli, so no review.
continuations.jar is still failing stability, i'll look at that.
........ r21522 | rompf | 2010-04-13 13:08:12 +0200 (Tue, 13 Apr 2010) |
1 line

  closes #3241 and improves serialization of hash tries. review by
community. ........ r21523 | phaller | 2010-04-13 13:37:42 +0200 (Tue,
13 Apr 2010) | 1 line

  Improved handling of uncaught exceptions in actors. See #711. Review
by community. ........ r21524 | prokopec | 2010-04-13 13:41:54 +0200
(Tue, 13 Apr 2010) | 1 line

  A brace got hurt while documenting. no review.
........
  r21525 | rytz | 2010-04-13 13:53:50 +0200 (Tue, 13 Apr 2010) | 1 line

  fix stability. jar is not stable. no review.
........
  r21527 | dubochet | 2010-04-13 14:08:47 +0200 (Tue, 13 Apr 2010) | 1 line

  [scaladoc] Fixed CSS so that styles from wiki markup are correctly
displayed in comments. No Review. ........ r21529 | prokopec |
2010-04-13 14:15:40 +0200 (Tue, 13 Apr 2010) | 1 line

  Immutable up to Queue docs. no review
........
  r21531 | imaier | 2010-04-13 14:53:21 +0200 (Tue, 13 Apr 2010) | 1 line

  Fixed #3258
........
  r21535 | phaller | 2010-04-13 16:41:02 +0200 (Tue, 13 Apr 2010) | 1 line

  Hardened actor tests. No review.
........
  r21536 | phaller | 2010-04-13 16:59:29 +0200 (Tue, 13 Apr 2010) | 1 line

  Removed obsolete AbstractReactor trait. No review. ........ r21537 |
prokopec | 2010-04-13 17:50:39 +0200 (Tue, 13 Apr 2010) | 1 line

  Docs. no review
........
  r21539 | prokopec | 2010-04-13 18:32:09 +0200 (Tue, 13 Apr 2010) | 1 line

  Documented immutable.*. no review
........
  r21540 | odersky | 2010-04-13 19:36:21 +0200 (Tue, 13 Apr 2010) | 1 line

  more documentation
........
  r21541 | odersky | 2010-04-13 19:36:54 +0200 (Tue, 13 Apr 2010) | 1 line

  fix for usecase in doccomments.
........
  r21542 | odersky | 2010-04-13 19:37:24 +0200 (Tue, 13 Apr 2010) | 1 line

  attempted fix for the TypeSkolem problem under specialize. ........
r21543 | odersky | 2010-04-13 19:42:35 +0200 (Tue, 13 Apr 2010) | 1 line

  Fix for specialized fix.
........
  r21545 | malayeri | 2010-04-13 20:13:53 +0200 (Tue, 13 Apr 2010) | 1 line

  [scaladoc] More cosmetic changes. Objects are a different shade of
blue and classes are green. ........ r21546 | extempore | 2010-04-13
20:24:05 +0200 (Tue, 13 Apr 2010) | 1 line

  A redblack tree scalacheck test contributed by dcsobral. No review.
........ r21547 | extempore | 2010-04-13 20:24:27 +0200 (Tue, 13 Apr
2010) | 2 lines

  A safety improvement for random path generation, and a small change
to Random for a more general interface. Review by community. ........
r21548 | extempore | 2010-04-13 20:24:48 +0200 (Tue, 13 Apr 2010) | 3
lines

  Some mopping up in equality. Found a stack overflow in the way equals
was being handled, and hammered it out. New ==/## tests which covers
all types and values. Review by odersky. ........ r21550 | odersky |
2010-04-13 21:46:21 +0200 (Tue, 13 Apr 2010) | 2 lines

  Removed trace output after having verified that skolems are correctly
identified now. Now review. ........ r21552 | malayeri | 2010-04-13
22:48:50 +0200 (Tue, 13 Apr 2010) | 1 line

  [scaladoc] Tweak so that left pane has a little bit of left padding.
Review by dubochet. ........ r21554 | dchenbecker | 2010-04-13 22:51:44
+0200 (Tue, 13 Apr 2010) | 4 lines

  Fix for #3284. This code should probably be refactored, but in the
interest of not breaking backwards compatibility, the JSON.parse
method has been marked deprecated for now. ........ r21555 | phaller |
2010-04-13 23:48:21 +0200 (Tue, 13 Apr 2010) | 1 line

  Reverted r21523. No review.
........
  r21556 | dragos | 2010-04-14 00:50:37 +0200 (Wed, 14 Apr 2010) | 4 lines

  Fixed deadlocking behavior in actors. This bug deserves a few more
lines. Specialization removed a 'private' modifier on Actor.resumeActor.
Mixin did not mix this method in actor implementations, believing it was
private. At runtime, an AbstractMethodError was thrown, but swallowed by
forkjoin (probably), resulting in an apparent deadlock. It would have
been much faster to find and fix if the stacktrace was printed, as it is
in Java 1.5. No review. ........ r21557 | dragos | 2010-04-14 00:50:52
+0200 (Wed, 14 Apr 2010) | 1 line

  Don't decode symbols in .toString.
........
  r21558 | dragos | 2010-04-14 00:51:04 +0200 (Wed, 14 Apr 2010) | 4 lines

  Made the icode reader more resilient to errors. A non-resolved symbol
does not cause any crashes, but the method using an unknown symbol will
not be used for inlining. Resurrected tests, removed spec-matrix for the
moment. No review. ........ r21559 | dragos | 2010-04-14 00:52:56 +0200
(Wed, 14 Apr 2010) | 2 lines

  Revert "Fix for #3284. This code should probably be refactored,". It
breaks test test/files/run/json.scala, and we need at least one good
nightly before the RC. ........ r21560 | odersky | 2010-04-14 00:54:25
+0200 (Wed, 14 Apr 2010) | 2 lines

  Disabled failing json test.
........

1 files changed, 305 insertions, 8 deletions

diff --git a/src/build/genprod.scala b/src/build/genprod.scala
index 099c24ef20..8217ce3c3b 100644
--- a/src/build/genprod.scala
+++ b/src/build/genprod.scala
@@ -32,7 +32,8 @@ object genprod {
   def productFiles  = arities map Product.make
   def tupleFiles    = arities map Tuple.make
   def functionFiles = (0 :: arities) map Function.make
-  def allfiles      = productFiles ::: tupleFiles ::: functionFiles
+  def absFunctionFiles = (0 :: arities) map AbstractFunction.make
+  def allfiles      = productFiles ::: tupleFiles ::: functionFiles ::: absFunctionFiles
 
   trait Arity extends Group {
     def i: Int    // arity
@@ -48,8 +49,10 @@ object genprod {
     def xdefs           = to map ("x" + _)
     def mdefs           = to map ("_" + _)
     def invariantArgs   = typeArgsString(targs)
-    def covariantArgs   = typeArgsString(targs map ("+" + _))
-    def contraCoArgs    = typeArgsString((targs map ("-" + _)) ::: List("+R"))
+    def covariantArgs   = typeArgsString(targs map (covariantSpecs + "+" + _))
+    def covariantSpecs  = ""
+    def contravariantSpecs = ""
+    def contraCoArgs    = typeArgsString((targs map (contravariantSpecs + "-" + _)) ::: List(covariantSpecs + "+R"))
     def fields          = List.map2(mdefs, targs)(_ + ":" + _) mkString ","
     def funArgs         = List.map2(vdefs, targs)(_ + ":" + _) mkString ","
 
@@ -59,6 +62,8 @@ object genprod {
     def descriptiveComment  = ""
     def withFancy           = if (descriptiveComment.isEmpty) "" else "(with fancy comment)"
     def withMoreMethods     = if (moreMethods.isEmpty) "" else "(with extra methods)"
+    def packageDef          = "scala"
+    def imports             = ""
 
     def header = """
 /*                     __                                               *\
@@ -73,8 +78,9 @@ object genprod {
 
 %s
 
-package scala
-""".trim.format(genprodString) + "\n\n"
+package %s
+%s
+""".trim.format(genprodString, packageDef, imports) + "\n\n"
   }
 
   def main(args: Array[String]) {
@@ -96,7 +102,7 @@ package scala
         w.close
       } catch {
         case e: java.io.IOException =>
-          println(e.getMessage() + ": " + out)
+          println(e.getMessage() + ": " + f)
           exit(-1)
       }
     }
@@ -112,6 +118,7 @@ import genprod._
 zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz */
 
 object FunctionZero extends Function(0) {
+  override def covariantSpecs = "@specialized "
   override def descriptiveComment = functionNTemplate.format("currentSeconds", "anonfun0",
 """ *
  *    <b>val</b> currentSeconds = () => System.currentTimeMillis() / 1000L
@@ -126,6 +133,9 @@ object FunctionZero extends Function(0) {
 }
 
 object FunctionOne extends Function(1) {
+  override def contravariantSpecs = "@specialized(Int, Long, Double) "
+  override def covariantSpecs = "@specialized(Unit, Boolean, Int, Long, Double) "
+
   override def descriptiveComment = functionNTemplate.format("succ", "anonfun1",
 """ *
  *    <b>val</b> succ = (x: Int) => x + 1
@@ -149,6 +159,9 @@ object FunctionOne extends Function(1) {
 }
 
 object FunctionTwo extends Function(2) {
+  override def contravariantSpecs = "@specialized(Int, Long, Double) "
+  override def covariantSpecs = "@specialized(Unit, Boolean, Int, Long, Double) "
+
   override def descriptiveComment = functionNTemplate.format("max", "anonfun2",
 """ *
  *    <b>val</b> max = (x: Int, y: Int) => <b>if</b> (x < y) y <b>else</b> x
@@ -254,16 +267,245 @@ object Tuple
 {
   def make(i: Int) = apply(i)()
   def apply(i: Int) = i match {
+    case 1  => TupleOne
     case 2  => TupleTwo
+    case 3  => TupleThree
     case _  => new Tuple(i)
   }
 }
 
+object TupleOne extends Tuple(1)
+{
+  override def covariantSpecs = "@specialized(Int, Long, Double) "
+}
+
 object TupleTwo extends Tuple(2)
 {
+  override def imports = """
+import scala.collection.{TraversableLike, IterableLike}
+import scala.collection.generic.CanBuildFrom
+"""
+  override def covariantSpecs = "@specialized(Int, Long, Double) "
   override def moreMethods = """
   /** Swap the elements of the tuple */
   def swap: Tuple2[T2,T1] = Tuple2(_2, _1)
+
+  def zip[Repr1, El1, El2, To](implicit w1:   T1 => TraversableLike[El1, Repr1],
+                                        w2:   T2 => Iterable[El2],
+                                        cbf1: CanBuildFrom[Repr1, (El1, El2), To]): To = {
+    val coll1: TraversableLike[El1, Repr1] = _1
+    val coll2: Iterable[El2] = _2
+    val b1 = cbf1(coll1.repr)
+    val elems2 = coll2.iterator
+
+    for(el1 <- coll1)
+      if(elems2.hasNext)
+        b1 += ((el1, elems2.next))
+
+    b1.result
+  }
+
+  /** Wraps a tuple in a `Zipped`, which supports 2-ary generalisations of map, flatMap, filter,...
+   *
+   * @see Zipped
+   * $willNotTerminateInf
+   */
+  def zipped[Repr1, El1, Repr2, El2](implicit w1: T1 => TraversableLike[El1, Repr1], w2: T2 => IterableLike[El2, Repr2]): Zipped[Repr1, El1, Repr2, El2]
+    = new Zipped[Repr1, El1, Repr2, El2](_1, _2)
+
+  class Zipped[+Repr1, +El1, +Repr2, +El2](coll1: TraversableLike[El1, Repr1], coll2: IterableLike[El2, Repr2]) { // coll2: IterableLike for filter
+    def map[B, To](f: (El1, El2) => B)(implicit cbf: CanBuildFrom[Repr1, B, To]): To = {
+      val b = cbf(coll1.repr)
+      val elems2 = coll2.iterator
+
+      for(el1 <- coll1)
+       if(elems2.hasNext)
+         b += f(el1, elems2.next)
+
+      b.result
+    }
+
+    def flatMap[B, To](f: (El1, El2) => Traversable[B])(implicit cbf: CanBuildFrom[Repr1, B, To]): To = {
+      val b = cbf(coll1.repr)
+      val elems2 = coll2.iterator
+
+      for(el1 <- coll1)
+       if(elems2.hasNext)
+         b ++= f(el1, elems2.next)
+
+      b.result
+    }
+
+    def filter[To1, To2](f: (El1, El2) => Boolean)(implicit cbf1: CanBuildFrom[Repr1, El1, To1], cbf2: CanBuildFrom[Repr2, El2, To2]): (To1, To2) = {
+      val b1 = cbf1(coll1.repr)
+      val b2 = cbf2(coll2.repr)
+      val elems2 = coll2.iterator
+
+      for(el1 <- coll1) {
+        if(elems2.hasNext) {
+          val el2 = elems2.next
+          if(f(el1, el2)) {
+            b1 += el1
+            b2 += el2
+          }
+        }
+      }
+
+      (b1.result, b2.result)
+    }
+
+    def exists(f: (El1, El2) => Boolean): Boolean = {
+      var acc = false
+      val elems2 = coll2.iterator
+
+      for(el1 <- coll1)
+       if(!acc && elems2.hasNext)
+         acc = f(el1, elems2.next)
+
+      acc
+    }
+
+    def forall(f: (El1, El2) => Boolean): Boolean = {
+      var acc = true
+      val elems2 = coll2.iterator
+
+      for(el1 <- coll1)
+       if(acc && elems2.hasNext)
+         acc = f(el1, elems2.next)
+
+      acc
+    }
+
+    def foreach[U](f: (El1, El2) => U): Unit = {
+      val elems2 = coll2.iterator
+
+      for(el1 <- coll1)
+       if(elems2.hasNext)
+         f(el1, elems2.next)
+    }
+  }
+"""
+}
+
+object TupleThree extends Tuple(3) {
+  override def imports = """
+import scala.collection.{TraversableLike, IterableLike}
+import scala.collection.generic.CanBuildFrom
+"""
+  override def moreMethods = """
+  def zip[Repr1, El1, El2, El3, To](implicit w1:   T1 => TraversableLike[El1, Repr1],
+                                             w2:   T2 => Iterable[El2],
+                                             w3:   T3 => Iterable[El3],
+                                             cbf1: CanBuildFrom[Repr1, (El1, El2, El3), To]): To = {
+    val coll1: TraversableLike[El1, Repr1] = _1
+    val coll2: Iterable[El2] = _2
+    val coll3: Iterable[El3] = _3
+    val b1 = cbf1(coll1.repr)
+    val elems2 = coll2.iterator
+    val elems3 = coll3.iterator
+
+    for(el1 <- coll1)
+      if(elems2.hasNext && elems3.hasNext)
+        b1 += ((el1, elems2.next, elems3.next))
+
+    b1.result
+  }
+
+  /** Wraps a tuple in a `Zipped`, which supports 3-ary generalisations of map, flatMap, filter,...
+   *
+   * @see Zipped
+   * $willNotTerminateInf
+   */
+  def zipped[Repr1, El1, Repr2, El2, Repr3, El3](implicit w1: T1 => TraversableLike[El1, Repr1],
+                                                          w2: T2 => IterableLike[El2, Repr2],
+                                                          w3: T3 => IterableLike[El3, Repr3]): Zipped[Repr1, El1, Repr2, El2, Repr3, El3]
+    = new Zipped[Repr1, El1, Repr2, El2, Repr3, El3](_1, _2, _3)
+
+  class Zipped[+Repr1, +El1, +Repr2, +El2, +Repr3, +El3](coll1: TraversableLike[El1, Repr1],
+                                                         coll2: IterableLike[El2, Repr2],
+                                                         coll3: IterableLike[El3, Repr3]) {
+    def map[B, To](f: (El1, El2, El3) => B)(implicit cbf: CanBuildFrom[Repr1, B, To]): To = {
+     val b = cbf(coll1.repr)
+     val elems2 = coll2.iterator
+     val elems3 = coll3.iterator
+
+     for(el1 <- coll1)
+       if(elems2.hasNext && elems3.hasNext)
+         b += f(el1, elems2.next, elems3.next)
+
+     b.result
+    }
+
+    def flatMap[B, To](f: (El1, El2, El3) => Traversable[B])(implicit cbf: CanBuildFrom[Repr1, B, To]): To = {
+      val b = cbf(coll1.repr)
+      val elems2 = coll2.iterator
+      val elems3 = coll3.iterator
+
+      for(el1 <- coll1)
+       if(elems2.hasNext && elems3.hasNext)
+         b ++= f(el1, elems2.next, elems3.next)
+
+      b.result
+    }
+
+    def filter[To1, To2, To3](f: (El1, El2, El3) => Boolean)(
+                 implicit cbf1: CanBuildFrom[Repr1, El1, To1],
+                          cbf2: CanBuildFrom[Repr2, El2, To2],
+                          cbf3: CanBuildFrom[Repr3, El3, To3]): (To1, To2, To3) = {
+      val b1 = cbf1(coll1.repr)
+      val b2 = cbf2(coll2.repr)
+      val b3 = cbf3(coll3.repr)
+      val elems2 = coll2.iterator
+      val elems3 = coll3.iterator
+
+      for(el1 <- coll1) {
+        if(elems2.hasNext && elems3.hasNext) {
+          val el2 = elems2.next
+          val el3 = elems3.next
+          if(f(el1, el2, el3)) {
+            b1 += el1
+            b2 += el2
+            b3 += el3
+          }
+        }
+      }
+
+      (b1.result, b2.result, b3.result)
+    }
+
+    def exists(f: (El1, El2, El3) => Boolean): Boolean = {
+      var acc = false
+      val elems2 = coll2.iterator
+      val elems3 = coll3.iterator
+
+      for(el1 <- coll1)
+       if(!acc && elems2.hasNext && elems3.hasNext)
+         acc = f(el1, elems2.next, elems3.next)
+
+      acc
+    }
+
+    def forall(f: (El1, El2, El3) => Boolean): Boolean = {
+      var acc = true
+      val elems2 = coll2.iterator
+      val elems3 = coll3.iterator
+
+      for(el1 <- coll1)
+       if(acc && elems2.hasNext && elems3.hasNext)
+         acc = f(el1, elems2.next, elems3.next)
+
+      acc
+    }
+
+    def foreach[U](f: (El1, El2, El3) => U): Unit = {
+      val elems2 = coll2.iterator
+      val elems3 = coll3.iterator
+
+      for(el1 <- coll1)
+       if(elems2.hasNext && elems3.hasNext)
+         f(el1, elems2.next, elems3.next)
+    }
+  }
 """
 }
 
@@ -271,7 +513,7 @@ class Tuple(val i: Int) extends Group("Tuple") with Arity
 {
   // prettifies it a little if it's overlong
   def mkToString() = {
-    def str(xs: List[String]) = xs.mkString(""" + "," + """)
+  def str(xs: List[String]) = xs.mkString(""" + "," + """)
     if (i <= MAX_ARITY / 2) str(mdefs)
     else {
       val s1 = str(mdefs take (i / 2))
@@ -303,7 +545,21 @@ zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz */
 object Product extends Group("Product")
 {
   def make(i: Int) = apply(i)()
-  def apply(i: Int) = new Product(i)
+  def apply(i: Int) = i match {
+    case 1  => ProductOne
+    case 2  => ProductTwo
+    case _ => new Product(i)
+  }
+}
+
+object ProductOne extends Product(1)
+{
+  override def covariantSpecs = "@specialized(Int, Long, Double) "
+}
+
+object ProductTwo extends Product(2)
+{
+  override def covariantSpecs = "@specialized(Int, Long, Double) "
 }
 
 class Product(val i: Int) extends Group("Product") with Arity
@@ -354,3 +610,44 @@ trait {className}{covariantArgs} extends Product {{
 </file>}
 
 }
+
+/** Abstract functions **/
+
+object AbstractFunctionZero extends AbstractFunction(0) {
+  override def covariantSpecs = FunctionZero.covariantSpecs
+}
+
+object AbstractFunctionOne extends AbstractFunction(1) {
+  override def covariantSpecs = FunctionOne.covariantSpecs
+  override def contravariantSpecs = FunctionOne.contravariantSpecs
+}
+
+object AbstractFunctionTwo extends AbstractFunction(2) {
+  override def covariantSpecs = FunctionTwo.covariantSpecs
+  override def contravariantSpecs = FunctionTwo.contravariantSpecs
+}
+
+class AbstractFunction(val i: Int) extends Group("AbstractFunction") with Arity
+{
+  override def packageDef = "scala.runtime"
+
+  val superTypeArgs = typeArgsString(targs ::: List("R"))
+
+  def apply() = {
+<file name={"runtime/" + fileName}>{header}
+abstract class {className}{contraCoArgs} extends Function{i}{superTypeArgs} {{
+{moreMethods}
+}}
+</file>}
+
+}
+object AbstractFunction
+{
+  def make(i: Int) = apply(i)()
+  def apply(i: Int) = i match {
+    case 0    => AbstractFunctionZero
+    case 1    => AbstractFunctionOne
+    case 2    => AbstractFunctionTwo
+    case _    => new AbstractFunction(i)
+  }
+}