Passaggio di una funzione Scala a un metodo Java 8

Question

Passaggio di una funzione Scala a un metodo Java 8

#1 da (10 voti)

18

Il seguente codice Scala funziona e può essere passato a un metodo Java in attesa di una funzione. C'è un modo più pulito per fare questo? Ecco il mio primo passaggio:

val plusOne = new java.util.function.Function[Int,Int] {
  override def apply(t:Int):Int = t + 1

  override def andThen[V](after:function.Function[_ >: Int, _ <: V]):
    function.Function[Int, V] = ???

  override def compose[V](before:function.Function[_ >: V, _ <: Int]):
    function.Function[V, Int] = ???
}

Ecco il mio secondo passaggio: utilizza un wrapper generico per l'interfaccia della funzione Java-8 per semplificare la sintassi di Scala:

// Note: Function1 is Scala's functional interface,
// Function (without the 1) is Java 8's.
case class JavaFunction1[U,V](f:Function1[U,V]) extends Function[U,V] {
  override def apply(t: U): V = f(t)
  override def compose[T](before:Function[_ >: T, _ <: U]):
    Function[T, V] = ???
  override def andThen[W](after:Function[_ >: V, _ <: W]):
    Function[U, W] = ???
}

val plusOne = JavaFunction1((x:Int) => x + 1)
val minusOne = JavaFunction1((x:Int) => x - 1)

Possiamo fare di meglio?

Come follow-up, c'è qualche possibilità che Scala un giorno utilizzi l'op-code invoke-dynamic come fa Java 8 per la sua applicazione di funzione di prima classe? Ciò renderà tutto magicamente funzionante o ci sarà ancora bisogno di una conversione sintattica?

functions functional-programming java8 scala higher-order-functions

posta GlenPeterson 06.03.2014 - 02:06

fonte

1 risposta

Leggi altre domande sui tag functions functional-programming java8 scala higher-order-functions

Flusso di lavoro Gitlab, forzare la revisione del codice o unire la richiesta sul ramo Qual è lo scopo di questa apparente auto-referenza in C #?

score 10 · Accepted Answer

Puoi rendere la conversione implicita:

implicit def toJavaFunction[U, V](f:Function1[U,V]): Function[U, V] = new Function[U, V] {
  override def apply(t: U): V = f(t)

  override def compose[T](before:Function[_ >: T, _ <: U]):
    Function[T, V] = toJavaFunction(f.compose(x => before.apply(x)))

  override def andThen[W](after:Function[_ >: V, _ <: W]):
    Function[U, W] = toJavaFunction(f.andThen(x => after.apply(x)))
}

implicit def fromJavaFunction[U, V](f:Function[U,V]): Function1[U, V] = f.apply

In realtà non è necessario sovrascrivere compose e andThen , ma forse il compilatore di Scala non conosce ancora i metodi di interfaccia predefiniti di Java 8. (EDIT: dovrebbe funzionare in 2.10.3.)

Inoltre, dovresti essere in grado di assegnare Scala lambdas (cioè x => ... ) a Function e qualsiasi altro tipo di SAM in Scala 2.11 e Java 8 lambda a Function1 . (EDIT: questo in realtà è stato aggiunto in Scala 2.12, non in 2.11.)