Comment appliquer une fonction à un tuple ?

Question

Cela devrait être facile. Comment appliquer une fonction à un tuple en Scala ? Viz :

scala> def f (i : Int, j : Int) = i + j
f: (Int,Int)Int

scala> val p = (3,4)
p: (Int, Int) = (3,4)

scala> f p
:6: error: missing arguments for method f in object $iw;
follow this method with \`\_' if you want to treat it as a partially applied function
       f p
       ^

scala> f \_ p
:6: error: value p is not a member of (Int, Int) => Int
       f \_ p
           ^

scala> (f \_) p
:6: error: value p is not a member of (Int, Int) => Int
       (f \_) p
             ^

scala> f(p)
:7: error: wrong number of arguments for method f: (Int,Int)Int
       f(p)
       ^

scala> grr!

Merci d'avance.

Answer 1

Dans Scala 2.8 et plus récent :

scala> def f (i : Int, j : Int) = i + j
f: (i: Int,j: Int)Int

// Note the underscore after the f
scala> val ff = f _
ff: (Int, Int) => Int = <function2>

scala> val fft = ff.tupled
fft: ((Int, Int)) => Int = <function1>

Dans Scala 2.7 :

scala> def f (i : Int, j : Int) = i + j
f: (Int,Int)Int

// Note the underscore after the f
scala> val ff = f _
ff: (Int, Int) => Int = <function>

scala> val fft = Function.tupled(ff)
fft: ((Int, Int)) => Int = <function>

Answer 2

Pour faire suite à l'autre réponse, on pourrait écrire (testé avec 2.11.4) :

scala> def f (i: Int, j: Int) = i + j
f: (i: Int, j: Int)Int

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

scala> val p = (3,4)
p: (Int, Int) = (3,4)

scala> ff.tupled(p)
res0: Int = 7

Voir def tupled : ((T1, T2)) ⇒ R=%3ER) :

Crée une version tuplée de cette fonction : au lieu de 2 arguments, elle accepte un seul scala.Tuple2 argument.

Answer 3

Scala 2.13

def f (i : Int, j : Int) = i + j

import scala.util.chaining._
(3,4).pipe((f _).tupled)   //res0: Int = 7

Answer 4

scala> def f (i: Int, j: Int) = i + j
f: (i: Int, j: Int)Int
scala> val p = (3,4)
p: (Int, Int) = (3,4)
scala> val ft = (f _).tupled
ft: ((Int, Int)) => Int = <function1>
scala> ft apply(p)
res0: Int = 7

Answer 5

En Scala 3, vous pouvez utiliser TupledFunction :

Pour une seule utilisation, vous pouvez faire

summon[TupledFunction[(Int, Int) => Int, ((Int, Int)) => Int]].tupled(f)((2, 3))

Pour faciliter son utilisation, vous pouvez utiliser une extension (copiée de la propre documentation de Dotty)

extension [F, T <: Tuple, R](f: F)(using tf: TupledFunction[F, T => R])
  def tupled(t: T): R = tf.tupled(f)(t)

Et ensuite vous pouvez faire f.tupled((2, 3)) pour obtenir 5 .