use a class and a val to avoid the allocation of a LazyRef when w know that we always need the value

Inherit from AbstractFunctionX, rather than FunctionX to reduce bytecode

Author: mkeskells

library/src/scala/collection/TraversableOnce.scala

@@ -13,11 +13,12 @@
 package scala
 package collection
 
-import mutable.{ Buffer, Builder, ArrayBuffer }
+import mutable.{ArrayBuffer, Buffer, Builder}
 import generic.CanBuildFrom
-import scala.annotation.unchecked.{ uncheckedVariance => uV }
-import scala.language.{implicitConversions, higherKinds}
+import scala.annotation.unchecked.{uncheckedVariance => uV}
+import scala.language.{higherKinds, implicitConversions}
 import scala.reflect.ClassTag
+import scala.runtime.AbstractFunction1
 
 /** A template trait for collections which can be traversed either once only
  *  or one or more times.
@@ -115,32 +116,39 @@ trait TraversableOnce[+A] extends Any with GenTraversableOnce[A] {
 
   // for internal use
   protected[this] def reversed = {
-    object reverser extends Function1[A, Unit] {
+    //avoid the LazyRef as we don't have an @eager object
+    class reverser extends AbstractFunction1[A, Unit] {
       var elems: List[A] = Nil
       override def apply(v1: A): Unit = elems ::= v1
     }
+    val reverser = new reverser
     self foreach reverser
     reverser.elems
   }
 
   def size: Int = {
     //we can't guard with isEmpty as some implementation have
     // def isEmpty = size == 0
-    object counter extends Function1[A, Unit] {
+
+    //avoid the LazyRef as we don't have an @eager object
+    class counter extends AbstractFunction1[A, Unit] {
       var result = 0
       override def apply(v1: A): Unit = result += 1
     }
+    val counter = new counter
     self foreach counter
     counter.result
   }
 
   def nonEmpty: Boolean = !isEmpty
 
   def count(p: A => Boolean): Int = {
-    object counter extends Function1[A, Unit] {
+    //avoid the LazyRef as we don't have an @eager object
+    class counter extends AbstractFunction1[A, Unit] {
       var result = 0
       override def apply(v1: A): Unit = if (p(v1)) result += 1
     }
+    val counter = new counter
     this foreach counter
     counter.result
   }
@@ -182,10 +190,12 @@ trait TraversableOnce[+A] extends Any with GenTraversableOnce[A] {
   def :\[B](z: B)(op: (A, B) => B): B = foldRight(z)(op)
 
   def foldLeft[B](z: B)(op: (B, A) => B): B = {
-    object folder extends Function1[A, Unit] {
+    //avoid the LazyRef as we don't have an @eager object
+    class folder extends AbstractFunction1[A, Unit] {
       var result = z
       override def apply(v1: A): Unit = result = op(result,v1)
     }
+    val folder = new folder
     this foreach folder
     folder.result
   }
@@ -211,7 +221,8 @@ trait TraversableOnce[+A] extends Any with GenTraversableOnce[A] {
     if (isEmpty)
       throw new UnsupportedOperationException("empty.reduceLeft")
 
-    object reducer extends Function1[A, Unit] {
+    //avoid the LazyRef as we don't have an @eager object
+    class reducer extends AbstractFunction1[A, Unit] {
       var first = true
       var acc: B = 0.asInstanceOf[B]
 
@@ -222,6 +233,7 @@ trait TraversableOnce[+A] extends Any with GenTraversableOnce[A] {
         }
         else acc = op(acc, x)
     }
+    val reducer = new reducer
     self foreach reducer
     reducer.acc
   }
@@ -268,11 +280,12 @@ trait TraversableOnce[+A] extends Any with GenTraversableOnce[A] {
   def maxBy[B](f: A => B)(implicit cmp: Ordering[B]): A = {
     if (isEmpty)
       throw new UnsupportedOperationException("empty.maxBy")
-    object maxer extends Function1[A, Unit] {
+
+    //avoid the LazyRef as we don't have an @eager object
+    class maxer extends AbstractFunction1[A, Unit] {
       var maxF: B = null.asInstanceOf[B]
       var maxElem: A = null.asInstanceOf[A]
       var first = true
-
       override def apply(elem: A): Unit = {
         val fx = f(elem)
         if (first || cmp.gt(fx, maxF)) {
@@ -281,18 +294,21 @@ trait TraversableOnce[+A] extends Any with GenTraversableOnce[A] {
           first = false
         }
       }
+
     }
+    val maxer = new maxer
     self foreach maxer
     maxer.maxElem
   }
   def minBy[B](f: A => B)(implicit cmp: Ordering[B]): A = {
     if (isEmpty)
       throw new UnsupportedOperationException("empty.minBy")
-    object miner extends Function1[A, Unit] {
+
+    //avoid the LazyRef as we don't have an @eager object
+    class miner extends AbstractFunction1[A, Unit] {
       var minF: B = null.asInstanceOf[B]
       var minElem: A = null.asInstanceOf[A]
       var first = true
-
       override def apply(elem: A): Unit = {
         val fx = f(elem)
         if (first || cmp.lt(fx, minF)) {
@@ -301,7 +317,9 @@ trait TraversableOnce[+A] extends Any with GenTraversableOnce[A] {
           first = false
         }
       }
+
     }
+    val miner = new miner
     self foreach miner
     miner.minElem
   }
@@ -388,7 +406,8 @@ trait TraversableOnce[+A] extends Any with GenTraversableOnce[A] {
    */
   def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder = {
     b append start
-    object appender extends Function1[A, Unit] {
+
+    class appender extends AbstractFunction1[A, Unit] {
       var first = true
       override def apply(x: A): Unit = {
         if (first) {
@@ -401,6 +420,7 @@ trait TraversableOnce[+A] extends Any with GenTraversableOnce[A] {
         }
       }
     }
+    val appender = new appender
     self foreach appender
     b append end
     b

library/src/scala/collection/immutable/HashMap.scala

@@ -19,6 +19,7 @@ import java.{util => ju}
 import generic._
 import scala.annotation.unchecked.{uncheckedVariance => uV}
 import parallel.immutable.ParHashMap
+import scala.runtime.{AbstractFunction1, AbstractFunction2}
 import scala.util.hashing.MurmurHash3
 
 /** This class implements immutable maps using a hash trie.
@@ -215,22 +216,26 @@ sealed class HashMap[A, +B] extends AbstractMap[A, B]
           this.merge0(thatHash, 0, merger)
 
         case that: HasForeachEntry[A, B] =>
-          object adder extends Function2[A, B, Unit] {
+          //avoid the LazyRef as we don't have an @eager object
+          class adder extends AbstractFunction2[A, B, Unit] {
             var result: HashMap[A, B] = HashMap.this
             override def apply(key: A, value: B): Unit = {
               result = result.updated0(key, computeHash(key), 0, value, null, merger)
             }
           }
+          val adder = new adder
           that foreachEntry adder
           adder.result
         case that =>
-          object adder extends Function1[(A,B), Unit] {
+          //avoid the LazyRef as we don't have an @eager object
+          class adder extends AbstractFunction1[(A,B), Unit] {
             var result: HashMap[A, B] = HashMap.this
             override def apply(kv: (A, B)): Unit = {
               val key = kv._1
               result = result.updated0(key, computeHash(key), 0, kv._2, kv, merger)
             }
           }
+          val adder = new adder
           that.asInstanceOf[GenTraversableOnce[(A,B)]] foreach adder
           adder.result
       }

library/src/scala/collection/immutable/HashSet.scala

@@ -19,6 +19,7 @@ import java.util
 import generic._
 import scala.collection.parallel.immutable.ParHashSet
 import scala.annotation.tailrec
+import scala.runtime.AbstractFunction1
 
 /** This class implements immutable sets using a hash trie.
  *
@@ -93,10 +94,12 @@ sealed class HashSet[A] extends AbstractSet[A]
       else nullToEmpty(union0(that, 0))
     case _ =>
       if (that.isEmpty) this else {
-        object acc extends Function1[A, Unit] {
+        //avoid the LazyRef as we don't have an @eager object
+        class acc extends AbstractFunction1[A, Unit] {
           var res = HashSet.this
           override def apply(v1: A): Unit = res += v1
         }
+        val acc = new acc
         if (that.isInstanceOf[Set[A]])
           that foreach acc
         else

library/src/scala/util/hashing/MurmurHash3.scala

@@ -13,7 +13,9 @@
 package scala
 package util.hashing
 
-import java.lang.Integer.{ rotateLeft => rotl }
+import java.lang.Integer.{rotateLeft => rotl}
+
+import scala.runtime.AbstractFunction1
 
 private[hashing] class MurmurHash3 {
   /** Mix in a block of data into an intermediate hash value. */
@@ -104,7 +106,8 @@ private[hashing] class MurmurHash3 {
       finalizeHash(h, 0)
     }
     else {
-      object hasher extends Function1[Any, Unit] {
+      //avoid the LazyRef as we don't have an @eager object
+      class hasher extends AbstractFunction1[Any, Unit] {
         var a, b, n = 0
         var c = 1
         override def apply(x: Any): Unit = {
@@ -115,6 +118,7 @@ private[hashing] class MurmurHash3 {
           n += 1
         }
       }
+      val hasher = new hasher
       xs foreach hasher
       var h = seed
       h = mix(h, hasher.a)
@@ -128,14 +132,16 @@ private[hashing] class MurmurHash3 {
   final def orderedHash(xs: TraversableOnce[Any], seed: Int): Int = {
     if  (xs.isEmpty) finalizeHash(seed, 0)
     else {
-      object hasher extends Function1[Any, Unit] {
+      //avoid the LazyRef as we don't have an @eager object
+      class hasher extends AbstractFunction1[Any, Unit] {
         var n = 0
         var h = seed
         override def apply(x: Any): Unit = {
           h = mix(h, x.##)
           n += 1
         }
       }
+      val hasher = new hasher
       xs foreach hasher
       finalizeHash(hasher.h, hasher.n)
     }