scala tuple déballage

Je sais que cette question a été soulevée à de nombreuses reprises dans différentes manières. Mais il n'est pas encore clair pour moi. Est-il un moyen pour atteindre les objectifs suivants.

def foo(a:Int, b:Int) = {}

foo(a,b) //right way to invoke foo

foo(getParams) //is there a way to get this working without explicitly unpacking the tuple??

def getParams = {
   //Some calculations
   (a,b)  //where a & b are Int
}
InformationsquelleAutor scout | 2010-08-25
  1. 101

    C'est une procédure en deux étapes. Premier tour foo dans une fonction, puis d'appeler tupled sur elle pour en faire une fonction d'un tuple.

    (foo _).tupled(getParams)
    • Ne serait-il pas plus propre si Scala juste pensé que des arguments comme les Tuples pour commencer?
    • Oui, il serait beaucoup plus clair si Scala permettrait d'unifier la gestion des tuples et des listes d'arguments. De ce que j'ai entendu, il y a beaucoup de non-évident bord des cas qui auraient besoin d'attention à la manipulation à faire pour que cela arrive. Autant que je sache, l'unification des tuples et des listes d'arguments n'est pas sur la Scala feuille de route à ce moment.
    • Juste pour ajouter, si toto est la méthode de fabrique de la compagne de l'objet, on peut utiliser (Foo.s'appliquent _).tupled(getParams)
    InformationsquelleAutor Dave Griffith
  2. 52

    @dave-griffith est mort sur.

    Vous pouvez aussi appeler:

    Function.tupled(foo _)

    Si vous voulez flâner dans la "voie à plus d'information que j'ai demandé" un territoire, il existe également des méthodes intégrées partiellement appliquée fonctions (et sur Function) pour le nourrissage. Quelques-uns d'entrée/sortie des exemples:

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

scala> foo _
res0: (Int, Double) => Double = <function2>

scala> foo _ tupled
res1: ((Int, Double)) => Double = <function1>

scala> foo _ curried
res2: (Int) => (Double) => Double = <function1>

scala> Function.tupled(foo _)
res3: ((Int, Double)) => Double = <function1>

//Function.curried is deprecated
scala> Function.curried(foo _)
warning: there were deprecation warnings; re-run with -deprecation for details
res6: (Int) => (Double) => Double = <function1>

    Dans lequel la au curry version est invoqué avec plusieurs listes d'arguments:

    scala> val c = foo _ curried
c: (Int) => (Double) => Double = <function1>

scala> c(5)
res13: (Double) => Double = <function1>

scala> c(5)(10)
res14: Double = 50.0

    Enfin, vous pouvez également uncurry/untuple si nécessaire. Function a les builtins pour cela:

    scala> val f = foo _ tupled
f: ((Int, Double)) => Double = <function1>

scala> val c = foo _ curried
c: (Int) => (Double) => Double = <function1>

scala> Function.uncurried(c)
res9: (Int, Double) => Double = <function2>

scala> Function.untupled(f)
res12: (Int, Double) => Double = <function2>

    InformationsquelleAutor Brendan W. McAdams
  3. 19

    Function.tupled(foo _)(getParams) ou celui proposé par Dave.

    EDIT:

    Pour répondre à votre commentaire:

    Que si toto se trouve être le
    constructeur de la classe?

    Dans ce cas, cette astuce ne fonctionne pas.

    Vous pouvez écrire une méthode de fabrique dans le compagnon objet de votre classe, puis obtenir l'tupled version de son apply méthode à l'aide de ces techniques.

    scala> class Person(firstName: String, lastName: String) {
     |   override def toString = firstName + " " + lastName
     | }
defined class Person

scala> object Person {
     |   def apply(firstName: String, lastName: String) = new Person(firstName, lastName)
     | }
defined module Person

scala> (Person.apply _).tupled(("Rahul", "G"))
res17: Person = Rahul G

    Avec case classes, vous obtenez un compagnon objet avec une apply méthode pour libre, et donc cette technique est plus pratique à utiliser avec case classes.

    scala> case class Person(firstName: String, lastName: String)
defined class Person

scala> Person.tupled(("Rahul", "G"))
res18: Person = Person(Rahul,G)

    Je sais que c'est beaucoup de duplication de code, mais hélas... nous n'avons pas les macros (encore)! 😉

    • Dans le dernier exemple, ici, vous pouvez raser un peu... Compagnon objets pour les classes de toujours étendre approprié Fonctionn trait. Ainsi, la dernière ligne est peut-être Person.tupled(("Rahul", "G")) Il est très pratique de le faire dans écrites à la main, compagnon d'objets trop.
    • Édité, merci. 🙂
    InformationsquelleAutor missingfaktor
  4. 3

    J'apprécie certains de l'autre les réponses qui ont été plus proche de ce que vous avez demandé, mais je l'ai trouvé plus facile pour un projet en cours pour ajouter une autre fonction qui convertit tuple paramètres dans le split paramètres:

    def originalFunc(a: A, b: B): C = ...
def wrapperFunc(ab: (A, B)): C = (originalFunc _).tupled(ab)
    InformationsquelleAutor xen
  5. 1

    Maintenant, vous pouvez mettre en œuvre toto et lui faire prendre un param de la Tuple2 classe comme si.

    def foo(t: Tuple2[Int, Int]) = {
  println("Hello " + t._1 + t._2)
  "Makes no sense but ok!"
}

def getParams = {
  //Some calculations
  val a = 1;
  val b = 2;
  (a, b) //where a & b are Int
}

//So you can do this!
foo(getParams)
//With that said, you can also do this!
foo(1, 3)
    InformationsquelleAutor Rejinderi