Scala与Java SAM互操作，没有2.12 M2标志

Question

Is there any accepted technique of writing Scala code against a Java-8 API which uses Java @FunctionalInterface / SAM / lambda expressions?

While Java lambda expressions inter-op is available under a flag in M2 http://www.scala-lang.org/news/2.12.0-M2 , I was rather hoping that a type class / AnyVal solution might work together with scala.FunctionX traits.

Unfortunately though, scala.FunctionX extends AnyRef and not Any so one cannot use/mix these traits into an implicit AnyVal class implementation.

Added: I'm not entirely sure that I though out how I would achieve my aim even if scala.FunctionX were global traits (extending from Any). My use case is this though:

In a project of mine, I've chosen to provide a Java-8 API with FunctionalInterfaces like the Java Stream interfaces & classes so as to cater for the widest possible audience of JVM-based client languages eg Closure, Scala, Kotlin. For each client language using my Java-8 API, I will write appropriate bindings (if necessary) to use language-specific idioms if in event of accessing Java-8 API feels clunky in that language.

btw. I would be interested in any comments with this question taken in a Kotlin-Java interop context also.

Answer 1

This Scala program demonstrates one side of the coin for my question, that is, how to get Scala functions to masquerade as Java 8 Lambdas.

Syntactically and idiomatically this seems to work fine by creating some implicit Scala functions to convert Scala functions to their Java 8 FunctionalInterface counterpart types.

The caveat is, of course, that this method does not take advantage of Java 8's ability to optimize lambda creation via invokedynamic.

Accordingly this approach results in a JVM object being created for the Scala function instance and this may impact upon memory usage and performance compared with Java 8 native lambdas.

For the flip side of the coin, that is, how to get Java 8 Lambdas to masquerade as Scala functions, I guess one would have to write some Java code to interop with Scala (if one's aim was to have a Scala API that was callable from Java).

Justin Johansson, Microblogging about my Project Clockwork, A new implementation of XPath/XQuery on the JVM, as @MartianOdyssey on Twitter

https://twitter.com/MartianOdyssey

/**
  * Scala Functions masquerading as Java 8 Lambdas.
  *
  * (C) Justin Johansson 2015.
  *
  * Microblogging about my Project Clockwork, a
  * new implementation of XPath/XQuery on the JVM,
  * as @MartianOdyssey on Twitter (https://twitter.com/MartianOdyssey).
  *
  * Permission to use this code is granted under Apache License,
  * Version 2.0 and providing attribution is afforded to author,
  * Justin Johansson.
  */

package lab

import scala.language.implicitConversions

import java.util.{ Arrays => JArrays, List => JList }
import java.util.function.{ Consumer => JConsumer, Function => JFunction, Predicate => JPredicate }
import java.util.stream.{ Stream => JStream }

object JLambda extends App {
  println("JLambda: Scala to Java 8 lambda test")

  implicit def func1ToJConsumer[T](func: T => Unit): JConsumer[T] = {
    new JConsumer[T] {
      def accept(arg: T): Unit = func(arg)
    }
  }

  implicit def func1ToJFunction[T, R](func: T => R): JFunction[T, R] = {
    new JFunction[T, R] {
      def apply(arg: T): R = func(arg)
    }
  }

  implicit def func1ToJPredicate[T](func: T => Boolean): JPredicate[T] = {
    new JPredicate[T] {
      def test(arg: T): Boolean = func(arg)
    }
  }

  val myList = JArrays.asList("cake", "banana", "apple", "coffee")
  println(s"myList = $myList")

  val myListFiltered: JStream[String] = myList.stream
    .filter { x: String => x.startsWith("c") }

  val myListFilteredAndMapped: JStream[String] = myListFiltered
    .map { x: String => x.toUpperCase }

  myListFilteredAndMapped.forEach { x: String => println(s"x=$x") }
}


/*
Outputs:
JLambda: Scala to Java 8 lambda test
myList = [cake, banana, apple, coffee]
x=CAKE
x=COFFEE
*/

Answer 2

btw. I would be interested in any comments with this question taken in a Kotlin-Java interop context also.

Kotlin's FunctionX interfaces are SAM's, so there's no need to do anything extra to make Java 8 understand them