Scala 将元组传递给curried函数

以下元组：

val i = (1, 2, 3, 4, 5, 6)

需要作为参数传递给curried函数，如下所示：

f("param") (i)

定义curried函数时，定义接收元组的参数类型的正确方法是什么

def f(s:String) (myTuple:???) = {
  val (a, b, c, d, e. f) = myTuple
  // more code
}

在定义参数类型时，我希望避免让用户指定元组中每个元素的数量和类型。换句话说，我想避免这种情况：

def f(s:String) (myTuple:(Int, Int, Int, Int, Int, Int)) = {
  val (a, b, c, d, e. f) = myTuple
  // more code
}

谢谢

咖喱不会改变您声明函数参数的方式：

val i = (1, 2, 3, 4, 5, 6)

def f(myTuple: (Int, Int, Int, Int, Int, Int)) = {
  val (a, b, c, d, e, f) = myTuple
}

f(i)

由于您有六个参数，我建议您使用case类来记录它们的含义：

case class Params(p1: Int, p2: Int, someFancyName: Int, otherName: Int, p5: Int, p6: Int)

def f(myTuple: Params) = {
  val Params(a, b, c, d, e, f) = myTuple
}

val i = (1, 2, 3, 4, 5, 6)

f(Params.tupled(i))

调用函数参数的人更容易理解函数参数，因为每个参数在case类中都有一个名称

我看到你编辑了你的问题：如果你想避免指定元素的数量，你可以使用类似磁铁模式的东西，为每个元组实现一个磁铁，或者你可以使用宏

如果使用magnet模式，则必须实现许多不同的实现，具体取决于参数的数量和类型（在实现中不能通用，必须知道如何处理参数）。这是最多三项元组的一个简短示例：

abstract class TupleMagnet[T](t: T) {
  def apply(): Unit
}

object TupleMagnet {
  implicit def tuple1Magnet[A](t: Tuple1[A]) = new TupleMagnet(t) {
    def apply() =  { println(t._1) }
  }
  implicit def tuple2Magnet[A, B](t: (A, B)) = new TupleMagnet(t) {
    def apply() = t match { case (a, b) =>  println(""+a + b) }

  }
  implicit def tuple3Magnet[A, B, C](t: (A, B, C)) = new TupleMagnet(t) {
    def apply() = t match { case (a, b, c) =>  println(""+a + b + c) }
  }
}


def f[T](magnet: TupleMagnet[T]) = magnet()

val i = (1, 2, 3)
f(i)

val j = (1, 2)
f(j)

参数数量/类型的另一个通用选项可以是使用

HList

s或

Records

并实现一个或类似的方法

咖喱不会改变您声明函数参数的方式：

val i = (1, 2, 3, 4, 5, 6)

def f(myTuple: (Int, Int, Int, Int, Int, Int)) = {
  val (a, b, c, d, e, f) = myTuple
}

f(i)

由于您有六个参数，我建议您使用case类来记录它们的含义：

case class Params(p1: Int, p2: Int, someFancyName: Int, otherName: Int, p5: Int, p6: Int)

def f(myTuple: Params) = {
  val Params(a, b, c, d, e, f) = myTuple
}

val i = (1, 2, 3, 4, 5, 6)

f(Params.tupled(i))

调用函数参数的人更容易理解函数参数，因为每个参数在case类中都有一个名称

我看到你编辑了你的问题：如果你想避免指定元素的数量，你可以使用类似磁铁模式的东西，为每个元组实现一个磁铁，或者你可以使用宏

如果使用magnet模式，则必须实现许多不同的实现，具体取决于参数的数量和类型（在实现中不能通用，必须知道如何处理参数）。这是最多三项元组的一个简短示例：

abstract class TupleMagnet[T](t: T) {
  def apply(): Unit
}

object TupleMagnet {
  implicit def tuple1Magnet[A](t: Tuple1[A]) = new TupleMagnet(t) {
    def apply() =  { println(t._1) }
  }
  implicit def tuple2Magnet[A, B](t: (A, B)) = new TupleMagnet(t) {
    def apply() = t match { case (a, b) =>  println(""+a + b) }

  }
  implicit def tuple3Magnet[A, B, C](t: (A, B, C)) = new TupleMagnet(t) {
    def apply() = t match { case (a, b, c) =>  println(""+a + b + c) }
  }
}


def f[T](magnet: TupleMagnet[T]) = magnet()

val i = (1, 2, 3)
f(i)

val j = (1, 2)
f(j)

---

参数数量/类型的另一个通用选项可以是使用

HList

s或

Records

并实现一个或类似的方法

（Int，Int，Int，Int，Int，Int，Int）

。这一行

（a，b，c，d，e.f）=myTuple

应该是

val（a，b，c，d，e，f）=myTuple

，我想避免指定元组中每个元素的数量和类型。难道没有更好的办法吗？对于非curry函数，我知道可以使用“tupled”关键字。感谢您指出-更新了问题

（Int，Int，Int，Int，Int，Int，Int）

。这一行

（a，b，c，d，e.f）=myTuple

应该是

val（a，b，c，d，e，f）=myTuple

，我想避免指定元组中每个元素的数量和类型。难道没有更好的办法吗？对于非咖喱函数，我知道可以使用“tupled”关键字。感谢您指出-更新了问题谢谢Giovanni。case类可以工作，但似乎有些过分。@user1052610我添加了更多的选项，这些选项甚至更加过分：D Scala是一种静态类型语言，必须在编译时知道参数的类型和数量hhmm。现在，我将坚持案例类。谢谢@GiovanniCaporaletti无法让TupleMagnet示例在scala ide上工作。你能不能编辑并复制一个工作示例，这样我就可以从中学习。不，这是因为抽象类TupleMagnet[T]（T:T）在框外。我无法编辑你的答案。对不起，谢谢你，乔瓦尼。case类可以工作，但似乎有些过分。@user1052610我添加了更多的选项，这些选项甚至更加过分：D Scala是一种静态类型语言，必须在编译时知道参数的类型和数量hhmm。现在，我将坚持案例类。谢谢@GiovanniCaporaletti无法让TupleMagnet示例在scala ide上工作。你能不能编辑并复制一个工作示例，这样我就可以从中学习。不，这是因为抽象类TupleMagnet[T]（T:T）在框外。我无法编辑你的答案。很抱歉