Scala: funzioni normali rispetto a funzioni tuple?

Question

Qual è la differenza tra questi? So che le loro firme di tipo sono diverse e che tutte le funzioni iniziano normalmente e devono essere .tupled per ottenere la loro forma tupla. Qual è il vantaggio dell'utilizzo di funzioni non violate (ma non curate)? Soprattutto perché mi sembra che passare più argomenti a una funzione tupla li spacchetta automagicamente in ogni caso, quindi in tutte le apparenze sono uguali.

Una differenza che vedo è che ti costringe ad avere i tipi per ogni numero di argomenti delle funzioni: Function0, Function1, Function2, Function3 ecc, mentre le funzioni di tupled sono tutti solo Function1[A, R], ma che sembra un aspetto negativo. Qual è il grande vantaggio dell'utilizzo di funzioni non tuplate di cui sono predefinite?

Answer 1

Le funzioni tuplicate richiedono che venga creato un oggetto tupla quando vengono chiamati (a meno che gli argomenti non siano già inseriti in una tupla). Le funzioni non-tuple definiscono semplicemente un metodo che prende il numero appropriato di argomenti. Pertanto, data l'architettura JVM, le funzioni non-tupled sono più efficienti.

Answer 2

Considerate questo esempio:

scala> def mult = (x: Int, y: Int) => x * y 
mult: (Int, Int) => Int 

scala> val list = List(1, 2, 3) 
list: List[Int] = List(1, 2, 3) 

scala> list zip list map mult 
<console>:10: error: type mismatch; 
found : (Int, Int) => Int 
required: ((Int, Int)) => ? 
       list zip list map mult 
           ^

scala> list zip list map mult.tupled 
res4: List[Int] = List(1, 4, 9) 

ci sono molte situazioni in cui si finisce abbinamento elementi in tuple. In tali situazioni, è necessaria una funzione tupla per gestirlo. Ma ci sono molti altri posti in cui questo è non vero! Per esempio:

scala> list.foldLeft(1)(mult) 
res5: Int = 6 

scala> list.foldLeft(1)(mult.tupled) 
<console>:10: error: type mismatch; 
found : ((Int, Int)) => Int 
required: (Int, Int) => Int 
       list.foldLeft(1)(mult.tupled) 
            ^

Quindi, in sostanza, Scala ha una dicotomia tra tuple e parametri, il che significa che è necessario convertire le funzioni da tupled a untupled e viceversa qua e là.