Scala 如何将函数应用于元组？

这应该很容易。如何将函数应用于Scala中的元组？即：

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! scala>def（i:Int，j:Int）=i+j f：（Int，Int）Int scala>valp=（3,4） p：（Int，Int）=（3,4） scala>fp ：6:错误：对象$iw中缺少方法f的参数； 如果要将其视为部分应用的函数，请使用“\u1”遵循此方法 f p ^ scala>f\up ：6:错误：值p不是（Int，Int）=>Int的成员 f_p ^ scala>（f_up） ：6:错误：值p不是（Int，Int）=>Int的成员 （f_）p ^ scala>f（p） ：7:错误：方法f的参数数目错误：（Int，Int）Int f（p） ^ scala>grr！ 非常感谢。

在Scala 2.8及更新版本中：

scala>def（i:Int，j:Int）=i+j
f：（i:Int，j:Int）Int
//注意f后面的下划线
scala>val ff=f_
ff：（Int，Int）=>Int=
scala>val fft=ff.tuple
fft:（（Int，Int））=>Int=

在Scala 2.7中：

scala>def（i:Int，j:Int）=i+j
f：（Int，Int）Int
//注意f后面的下划线
scala>val ff=f_
ff：（Int，Int）=>Int=
scala>val fft=Function.tuple（ff）
fft:（（Int，Int））=>Int=

根据另一个答案，可以写下（使用2.11.4测试）：

scala>def（i:Int，j:Int）=i+j
f：（i:Int，j:Int）Int
scala>val ff=f_
ff：（Int，Int）=>Int=
scala>valp=（3,4）
p：（Int，Int）=（3,4）
scala>ff.tuple（p）
res0:Int=7

见：

创建此函数的元组版本：它不是2个参数，而是 接受单个参数

scala>def（i:Int，j:Int）=i+j
f：（i:Int，j:Int）Int
scala>valp=（3,4）
p：（Int，Int）=（3,4）
scala>val ft=（f _）.tuple
ft:（（Int，Int））=>Int=
scala>ft应用（p）
res0:Int=7

Scala 2.13 在Scala 3中，您可以使用：

只需一次使用，您就可以

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

为了便于使用，可以使用扩展名（从Dotty自己的文档复制）

扩展[F，tr]）
def tupled（t:t）：R=tf.tupled（f）（t）

---

然后你可以做

f.tuple（（2,3））

来得到

5

有趣的是，scala（这里是2.11.0）会把你的非耦合参数变成一个元组，如果你这样做：

fft.apply（1,2）

很高兴知道你能做到这一点，但这似乎比仅仅使用

函数（tup.\u 1，tup.\u 2）要短得多

在第一个place@AllenWang我认为重要的一点是，

tuple

可以用于任何算术运算。很好的可维护性。谢谢你的回答，但是添加一些解释可能会帮助更多的人

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>

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

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

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

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

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

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