¿Cómo pasar un argumento de tupla de la mejor manera?

Question

¿Cómo pasar un argumento de tupla de la mejor manera?

Ejemplo:

def foo(...): (Int, Int) = ... 

def bar(a: Int, b: Int) = ... 

Ahora me gustaría para pasar la salida de foo-bar. Esto puede lograrse con:

val fooResult = foo(...) 
bar(fooResult._1, fooResult._2) 

Este enfoque parece un poco feo, especialmente cuando tratamos con una tupla n con n > 2. También tenemos que almacenar el resultado de foo en un valor adicional, porque de lo contrario foo tiene que ser ejecutado más de una vez usando bar(foo._1, foo._2).

¿Hay una mejor manera de pasar por la tupla como argumento?

Answer 1

No es un método especial tupled disponibles para cada función:

val bar2 = (bar _).tupled // or Function.tupled(bar _) 

bar2 toma una tupla de (Int, Int) (igual que bar argumentos). Ahora se puede decir:

bar2(foo()) 

Si sus métodos eran en realidad funciones (nótese la palabra clave val) la sintaxis es mucho más agradable:

val bar = (a: Int, b: Int) => //... 
bar.tupled(foo()) 

Ver también

• How to apply a function to a tuple?

Answer 2

Usando tupled, como @Tomasz menciona, es un buen enfoque.

También puede extraer la tupla devuelta por foo durante la asignación:

val (x, y) = foo(5) 
bar(x, y) 

Esto tiene la ventaja de un código más limpio (sin _1 y _2), y le permite asignar nombres descriptivos para x y y, haciendo que su código más fácil de leer

Answer 3

Cabe también saber acerca

foo(...) match { case (a,b) => bar(a,b) } 

como una alternativa que no requiere que usted para crear explícitamente un temporal fooResult. Es un buen compromiso cuando la velocidad y la falta de desorden son importantes. Puede crear una función con bar _ y luego convertirla para tomar un solo argumento de tupla con .tupled, pero esto crea dos nuevos objetos de función cada vez que llama al par; podrías almacenar el resultado, pero eso podría saturar tu código innecesariamente.

Para el uso diario (es decir, esto no es la parte que limitan el rendimiento de su código), sólo puede

(bar _).tupled(foo(...)) 

en línea.Claro, usted crea dos objetos funcionales adicionales, pero lo más probable es que haya creado la tupla también, por lo que no le importa que mucho, ¿verdad?