Posso passare un metodo di istanza di un oggetto a un metodo che prevede un callback in Scala?

Question

Diciamo che ho un metodo che prevede un altro metodo come parametro. È possibile inviare i metodi di istanza di un oggetto per quel parametro? Come gestirò i metodi che non hanno parametri?

scriverò alcuni pseudocodice:

void myMethod1(callback<void,int> otherFunc); // imagine a function returning void, and taking a int parameter 

void myMethod2(callback<int,void> otherFunc); // function returning void, not taking params 

se per esempio ho un ArrayList, in questo modo:

val a = new ArrayList() 

come potrei inviare è add Metodo parametro per myMethod1, ed è Metodo size come parametro per myMethod2?

Answer 1

Penso che myMethod4 possa essere ciò che intendi quando dici: "Non è possibile fare riferimento a a.size e invocarlo quando necessario?".

def myMethod1(f: Int => Unit): Unit = f(1) 

def myMethod2(f:() => Int): Unit = { 
    val value = f // f is function, taking no arguments, and returning an int. 
       // we invoke it here. 
() 
} 

def myMethod3(f: => Int): Unit = { 
    val value = f // f is call by name parameter. 
() 
} 

def myMethod4[A](f: A => Int, a: A): Unit = { 
    val value = f(a) 
() 
} 

import java.util.ArrayList 

val a = new ArrayList[Int](1) 
myMethod1((i: Int) => a.add(i)) 
myMethod1(a.add(_))  // shorthand for the above 
myMethod2(() => a.size) // a.size is not evaluated, it is enclosed in an anonymous function definition. 
myMethod3(a.size)  // a.size is not evaluated here, it is passed as a by-name parameter. 
myMethod4((al: ArrayList[Int]) => al.size, a) 
myMethod4((_: ArrayList[Int]).size, a) 
myMethod4[ArrayList[Int]](_.size, a) 

Answer 2

def myMethod(callback : Int => Unit, size : => Int) = ... 

myMethod(a.add _, a.size) 

Void è rappresentato attraverso il tipo Unit.

Modifica: Attraverso l'utilizzo sopra di => Int, size viene passato per nome, il che significa che viene sempre rivalutato quando necessario.

Answer 3

Il tipo di una funzione in Scala è denotata

(Types,To,Pass) => ReturnType 

(è possibile lasciare fuori le parentesi se c'è solo un singolo tipo di pass), e il modo di convertire un metodo in un funzione per passare a un altro metodo è

myObject.myMethod _

Così, mettendo insieme questi - e prestando attenzione ai tipi di classi Java:

scala> def addMySize(adder: Int => Boolean, sizer:() => Int) = adder(sizer()) 
addMySize: ((Int) => Boolean,() => Int)Boolean 

scala> val a = new java.util.ArrayList[Int]() 
a: java.util.ArrayList[Int] = [] 

scala> addMySize(a.add _, a.size _) 
res0: Boolean = true 

scala> addMySize(a.add _, a.size _) 
res1: Boolean = true 

scala> println(a) 
[0, 1] 

(Si noti che ArrayList ha un componente aggiuntivo che prende un oggetto e restituisce un valore booleano -. Non uno che restituisce void)