fix unit tests by have lambdas implement concrete classes

core/src/main/scala/com/salesforce/op/dsl/RichDateFeature.scala

@@ -204,7 +204,15 @@ trait RichDateFeature {
 }
 
 object RichDateFeatureLambdas {
-  def toDateList: Date => DateList = (x: Date) => x.value.toSeq.toDateList
+  private class ToDateList extends Function1[Date, DateList] with Serializable {
+    def apply(x: Date): DateList = x.value.toSeq.toDateList
+  }
+
+  private class ToDateTimeList extends Function1[DateTime, DateTimeList] with Serializable {
+    def apply(x: DateTime): DateTimeList = x.value.toSeq.toDateTimeList
+  }
+
+  def toDateList: Date => DateList = new ToDateList
 
-  def toDateTimeList: DateTime => DateTimeList = (x: DateTime) => x.value.toSeq.toDateTimeList
+  def toDateTimeList: DateTime => DateTimeList = new ToDateTimeList
 }

core/src/main/scala/com/salesforce/op/dsl/RichTextFeature.scala

@@ -800,23 +800,58 @@ trait RichTextFeature {
 }
 
 object RichTextFeatureLambdas {
+  private class EmailToPickList extends Function1[Email, PickList] with Serializable {
+    def apply(v: Email): PickList = v.domain.toPickList
+  }
+
+  private class EmailToPrefix extends Function1[Email, Text] with Serializable {
+    def apply(v: Email): Text = v.prefix.toText
+  }
+
+  private class EmailToDomain extends Function1[Email, Text] with Serializable {
+    def apply(v: Email): Text = v.domain.toText
+  }
+
+  private class UrlToPickList extends Function1[URL, PickList] with Serializable {
+    def apply(v: URL): PickList = if (v.isValid) v.domain.toPickList else PickList.empty
+  }
+
+  private class UrlToDomain extends Function1[URL, Text] with Serializable {
+    def apply(v: URL): Text = v.domain.toText
+  }
+
+  private class UrlToProtocol extends Function1[URL, Text] with Serializable {
+    def apply(v: URL): Text = v.protocol.toText
+  }
+
+  private class UrlIsValid extends Function1[URL, Boolean] with Serializable {
+    def apply(v: URL): Boolean = v.isValid
+  }
+
+  private class TextToPickList extends Function1[Text, PickList] with Serializable {
+    def apply(v: Text): PickList = v.value.toPickList
+  }
+
+  private class TextToMultiPickList extends Function1[Text, MultiPickList] with Serializable {
+    def apply(v: Text): MultiPickList = v.value.toSet[String].toMultiPickList
+  }
 
-  def emailToPickList: Email => PickList = _.domain.toPickList
+  def emailToPickList: Email => PickList = new EmailToPickList
 
-  def emailToPrefix: Email => Text = _.prefix.toText
+  def emailToPrefix: Email => Text = new EmailToPrefix
 
-  def emailToDomain: Email => Text = _.domain.toText
+  def emailToDomain: Email => Text = new EmailToDomain
 
-  def urlToPickList: URL => PickList = (v: URL) => if (v.isValid) v.domain.toPickList else PickList.empty
+  def urlToPickList: URL => PickList = new UrlToPickList
 
-  def urlToDomain: URL => Text = _.domain.toText
+  def urlToDomain: URL => Text = new UrlToDomain
 
-  def urlToProtocol: URL => Text = _.protocol.toText
+  def urlToProtocol: URL => Text = new UrlToProtocol
 
-  def urlIsValid: URL => Boolean = _.isValid
+  def urlIsValid: URL => Boolean = new UrlIsValid
 
-  def textToPickList: Text => PickList = _.value.toPickList
+  def textToPickList: Text => PickList = new TextToPickList
 
-  def textToMultiPickList: Text => MultiPickList = _.value.toSet[String].toMultiPickList
+  def textToMultiPickList: Text => MultiPickList = new TextToMultiPickList
 
 }

core/src/main/scala/com/salesforce/op/stages/impl/feature/ToOccurTransformer.scala

@@ -59,12 +59,14 @@ class ToOccurTransformer[I <: FeatureType]
 
 
 object ToOccurTransformer {
-
-  def defaultMatches[T <: FeatureType]: T => Boolean = {
-    case num: OPNumeric[_] if num.nonEmpty => num.toDouble.get > 0.0
-    case text: Text if text.nonEmpty => text.value.get.length > 0
-    case collection: OPCollection => collection.nonEmpty
-    case _ => false
+  private class DefaultMatches[T <: FeatureType] extends Function1[T, Boolean] with Serializable {
+    def apply(t: T): Boolean = t match {
+      case num: OPNumeric[_] if num.nonEmpty => num.toDouble.get > 0.0
+      case text: Text if text.nonEmpty => text.value.get.length > 0
+      case collection: OPCollection => collection.nonEmpty
+      case _ => false
+    }
   }
 
+  def defaultMatches[T <: FeatureType]: T => Boolean = new DefaultMatches[T]
 }

core/src/test/scala/com/salesforce/op/OpWorkflowModelReaderWriterTest.scala

@@ -386,6 +386,14 @@ trait UIDReset {
 }
 
 object OpWorkflowModelReaderWriterTest {
-  def catHeadFn: OPVector => Real = v => Real(v.value.toArray.headOption)
-  def emptyVectorFn: Passenger => OPVector = _ => OPVector.empty
+  private class CatHeadFn extends Function1[OPVector, Real] with Serializable {
+    def apply(v: OPVector): Real = Real(v.value.toArray.headOption)
+  }
+
+  private class EmptyVectorFn extends Function1[Passenger, OPVector] with Serializable {
+    def apply(p: Passenger): OPVector = OPVector.empty
+  }
+
+  def catHeadFn: OPVector => Real = new CatHeadFn
+  def emptyVectorFn: Passenger => OPVector = new EmptyVectorFn
 }

core/src/test/scala/com/salesforce/op/stages/Lambdas.scala

@@ -34,38 +34,65 @@ import com.salesforce.op.features.types.Real
 import com.salesforce.op.features.types._
 
 object Lambdas {
-  def fncUnary: Real => Real = (x: Real) => x.v.map(_ * 0.1234).toReal
+  private class FncUnary extends Function1[Real, Real] with Serializable {
+    def apply(x: Real): Real = x.v.map(_ * 0.1234).toReal
+  }
+
+  private class FncSequence extends Function1[Seq[DateList], Real] with Serializable {
+    def apply(x: Seq[DateList]): Real = {
+      val v = x.foldLeft(0.0)((a, b) => a + b.value.sum)
+      Math.round(v / 1E6).toReal
+    }
+  }
+
+  private class FncBinarySequence extends Function2[Real, Seq[DateList], Real] with Serializable {
+    def apply(y: Real, x: Seq[DateList]): Real = {
+      val v = x.foldLeft(0.0)((a, b) => a + b.value.sum)
+      (Math.round(v / 1E6) + y.value.getOrElse(0.0)).toReal
+    }
+  }
 
-  def fncSequence: Seq[DateList] => Real = (x: Seq[DateList]) => {
-    val v = x.foldLeft(0.0)((a, b) => a + b.value.sum)
-    Math.round(v / 1E6).toReal
+  private class FncBinary extends Function2[Real, Real, Real] with Serializable {
+    def apply(y: Real, x: Real): Real = {
+      (
+        for {
+          yv <- y.value
+          xv <- x.value
+        } yield xv * yv
+      ).toReal
+    }
   }
 
-  def fncBinarySequence: (Real, Seq[DateList]) => Real = (y: Real, x: Seq[DateList]) => {
-    val v = x.foldLeft(0.0)((a, b) => a + b.value.sum)
-    (Math.round(v / 1E6) + y.value.getOrElse(0.0)).toReal
+  private class FncTernary extends Function3[Real, Real, Real, Real] with Serializable {
+    def apply(x: Real, y: Real, z: Real): Real = {
+      (for {
+        xv <- x.value
+        yv <- y.value
+        zv <- z.value
+      } yield xv * yv + zv).toReal
+    }
   }
 
-  def fncBinary: (Real, Real) => Real = (x: Real, y: Real) => (
-    for {
-      yv <- y.value
-      xv <- x.value
-    } yield xv * yv
-    ).toReal
+  private class FncQuaternary extends Function4[Real, Real, Text, Real, Real] with Serializable {
+    def apply(x: Real, y: Real, t: Text, z: Real): Real = {
+      (for {
+        xv <- x.value
+        yv <- y.value
+        tv <- t.value
+        zv <- z.value
+      } yield xv * yv + zv * tv.length).toReal
+    }
+  }
+
+  def fncUnary: Real => Real = new FncUnary
+
+  def fncSequence: Seq[DateList] => Real = new FncSequence
+
+  def fncBinarySequence: (Real, Seq[DateList]) => Real = new FncBinarySequence
 
-  def fncTernary: (Real, Real, Real) => Real = (x: Real, y: Real, z: Real) =>
-    (for {
-      xv <- x.value
-      yv <- y.value
-      zv <- z.value
-    } yield xv * yv + zv).toReal
+  def fncBinary: (Real, Real) => Real = new FncBinary
 
-  def fncQuaternary: (Real, Real, Text, Real) => Real = (x: Real, y: Real, t: Text, z: Real) =>
-    (for {
-      xv <- x.value
-      yv <- y.value
-      tv <- t.value
-      zv <- z.value
-    } yield xv * yv + zv * tv.length).toReal
+  def fncTernary: (Real, Real, Real) => Real = new FncTernary
 
+  def fncQuaternary: (Real, Real, Text, Real) => Real = new FncQuaternary
 }

core/src/test/scala/com/salesforce/op/stages/OpPipelineStagesTest.scala

@@ -162,7 +162,11 @@ class OpPipelineStagesTest
 }
 
 object OpPipelineStagesTest {
-  def fnc0: Real => Real = x => x
+  private class Fnc0 extends Function1[Real, Real] with Serializable {
+    def apply(x: Real): Real = x
+  }
+
+  def fnc0: Real => Real = new Fnc0
 
   class TestStage(implicit val tto: TypeTag[RealNN], val ttov: TypeTag[RealNN#Value])
     extends Pipeline with OpPipelineStage1[RealNN, RealNN] {

core/src/test/scala/com/salesforce/op/stages/impl/feature/DropIndicesByTransformerTest.scala

@@ -116,5 +116,9 @@ class DropIndicesByTransformerTest extends OpTransformerSpec[OPVector, DropIndic
 }
 
 object DropIndicesByTransformerTest {
-  def matchFn: OpVectorColumnMetadata => Boolean = _.isNullIndicator
+  private class MatchFn extends Function1[OpVectorColumnMetadata, Boolean] with Serializable {
+    def apply(x: OpVectorColumnMetadata): Boolean = x.isNullIndicator
+  }
+
+  def matchFn: OpVectorColumnMetadata => Boolean = new MatchFn
 }

features/src/test/scala/com/salesforce/op/stages/base/binary/BinaryTransformerTest.scala

@@ -51,5 +51,9 @@ class BinaryTransformerTest extends OpTransformerSpec[Real, BinaryTransformer[Re
 }
 
 object BinaryTransformerTest {
-  def fn: (Real, RealNN) => Real = (i1, i2) => new Real(for {v1 <- i1.value; v2 <- i2.value} yield v1 / (v2 * v2))
+  private class Fn extends Function2[Real, RealNN, Real] with Serializable {
+    def apply(i1: Real, i2: RealNN): Real = new Real(for {v1 <- i1.value; v2 <- i2.value} yield v1 / (v2 * v2))
+  }
+
+  def fn: (Real, RealNN) => Real = new Fn
 }

features/src/test/scala/com/salesforce/op/stages/base/quaternary/QuaternaryTransformerTest.scala

@@ -57,7 +57,11 @@ class QuaternaryTransformerTest
 }
 
 object QuaternaryTransformerTest {
-  def fn: (Real, Integral, Text, Binary) => Real = (r, i, t, b) =>
-    (r.v.getOrElse(0.0) + i.toDouble.getOrElse(0.0) + b.toDouble.getOrElse(0.0) +
-      t.value.map(_.length.toDouble).getOrElse(0.0)).toReal
+  private class Fn extends Function4[Real, Integral, Text, Binary, Real] with Serializable {
+    def apply(r: Real, i: Integral, t: Text, b: Binary): Real =
+      (r.v.getOrElse(0.0) + i.toDouble.getOrElse(0.0) + b.toDouble.getOrElse(0.0) +
+        t.value.map(_.length.toDouble).getOrElse(0.0)).toReal
+  }
+
+  def fn: (Real, Integral, Text, Binary) => Real = new Fn
 }

features/src/test/scala/com/salesforce/op/stages/base/sequence/BinarySequenceTransformerTest.scala

@@ -62,6 +62,10 @@ class BinarySequenceTransformerTest
 }
 
 object Lambda {
-  def fn: (Real, Seq[Text]) => MultiPickList =
-    (r, texts) => MultiPickList(texts.map(_.value.get).toSet + r.value.get.toString)
+  class Fn extends Function2[Real, Seq[Text], MultiPickList] with Serializable {
+    def apply(r: Real, texts: Seq[Text]): MultiPickList =
+      MultiPickList(texts.map(_.value.get).toSet + r.value.get.toString)
+  }
+
+  def fn: (Real, Seq[Text]) => MultiPickList = new Fn
 }

features/src/test/scala/com/salesforce/op/stages/base/sequence/SequenceTransformerTest.scala

@@ -61,5 +61,9 @@ class SequenceTransformerTest extends OpTransformerSpec[MultiPickList, SequenceT
 }
 
 object SequenceTransformerTest {
-  def fn: Seq[Real] => MultiPickList = value => MultiPickList(value.flatMap(_.v.map(_.toString)).toSet)
+  private class Fn extends Function1[Seq[Real], MultiPickList] with Serializable {
+    def apply(value: Seq[Real]): MultiPickList = MultiPickList(value.flatMap(_.v.map(_.toString)).toSet)
+  }
+
+  def fn: Seq[Real] => MultiPickList = new Fn
 }

features/src/test/scala/com/salesforce/op/stages/base/ternary/TernaryTransformerTest.scala

@@ -56,6 +56,10 @@ class TernaryTransformerTest extends OpTransformerSpec[Real, TernaryTransformer[
 }
 
 object Lambda {
-  def fn: (Real, Integral, Binary) => Real =
-    (r, i, b) => (r.v.getOrElse(0.0) + i.toDouble.getOrElse(0.0) + b.toDouble.getOrElse(0.0)).toReal
+  private class Fn extends Function3[Real, Integral, Binary, Real] with Serializable {
+    def apply(r: Real, i: Integral, b: Binary): Real =
+      (r.v.getOrElse(0.0) + i.toDouble.getOrElse(0.0) + b.toDouble.getOrElse(0.0)).toReal
+  }
+
+  def fn: (Real, Integral, Binary) => Real = new Fn
 }

features/src/test/scala/com/salesforce/op/stages/base/unary/UnaryTransformerTest.scala

@@ -59,5 +59,9 @@ class UnaryTransformerTest extends OpTransformerSpec[Real, UnaryLambdaTransforme
 }
 
 object UnaryTransformerTest {
-  def fn: Real => Real = r => r.v.map(_ * 2.0).toReal
+  private class Fn extends Function1[Real, Real] with Serializable {
+    def apply(r: Real): Real = r.v.map(_ * 2.0).toReal
+  }
+
+  def fn: Real => Real = new Fn
 }