Scala: Decomposing tuple in argomenti della funzione

Question

in python che posso fare questo:

def f((a, b)): 
    return a + b 

d = (1, 2) 
f(d) 

Qui il passato in tupla viene decomposto mentre il suo essere passato a f.

In questo momento a Scala in questo momento sto facendo questo:

def f(ab:(Int, Int)) : Int = { 
    val (a, b) = ab 
    a + b 
} 
val d = (1, 2) 
f(d) 

C'è qualcosa che posso fare qui in modo che la decomposizione avviene mentre gli argomenti vengono passati in? Solo curioso.

Grazie.

Answer 1

È possibile creare una funzione e abbinare il suo ingresso con pattern matching:

scala> val f: ((Int, Int)) => Int = { case (a,b) => a+b } 
f: ((Int, Int)) => Int 

scala> f(1, 2) 
res0: Int = 3 

o partita l'ingresso del metodo con la parola chiave match:

scala> def f(ab: (Int, Int)): Int = ab match { case (a,b) => a+b } 
f: (ab: (Int, Int))Int 

scala> f(1, 2) 
res1: Int = 3 

Un altro modo è quello di utilizzare una funzione con due argomenti e per "tupla":

scala> val f: (Int, Int) => Int = _+_ 
f: (Int, Int) => Int = <function2> 

scala> val g = f.tupled // or Function.tupled(f) 
g: ((Int, Int)) => Int = <function1> 

scala> g(1, 2) 
res10: Int = 3 

// or with a method 
scala> def f(a: Int, b: Int): Int = a+b 
f: (a: Int, b: Int)Int 

scala> val g = (f _).tupled // or Function.tupled(f _) 
g: ((Int, Int)) => Int = <function1> 

scala> g(1, 2) 
res11: Int = 3 

// or inlined 
scala> val f: ((Int,Int)) => Int = Function.tupled(_+_) 
f: ((Int, Int)) => Int = <function1> 

scala> f(1, 2) 
res12: Int = 3 

Answer 2

ne dite:

ab._1 + ab._2 

Il _1, _2 ecc accedere i diversi elementi della tupla.

Answer 3

object RandomExperiments extends App{ 
    def takeTuple(t:(Int,Int))=print (s"$t ${t._1}\n") 
    takeTuple(1,3) 
    takeTuple((1,3)) 
    takeTuple(((1,3))) 

} 

stampe:

(1,3) 1 
(1,3) 1 
(1,3) 1