Dans Scala, quelles sont les règles pour faire des fermetures avec des underscores?

Question

Au début, je l'avais cru que l'utilisation des underscores pour faire des fermetures (par exemple println _) étaient juste un raccourci pour l'aide d'une flèche (par exemple x => println x), mais j'appris récemment que vous pouvez également effectuer les opérations suivantes:

def f(a: Int, b: Int) = a + 2 * b 
List(1, 2, 3).reduce(f _) 

Compte tenu mes hypothèses passées, f _ ressemble à une fermeture qui accepte exactement un argument et passe exactement un argument à f. J'ai supposé qu'il me dirait qu'il ne pourrait pas compiler parce que f attend deux arguments, et reduce devrait s'attendre à une fonction avec deux arguments. Mais cela fonctionne comme si j'avais écrit:

def f(a: Int, b: Int) = a + 2 * b 
List(1, 2, 3).reduce((x, y) => f(x, y)) 

Que se passe-t-il ici? Quelles sont les règles pour créer des fermetures avec des underscores?

Answer 1

Rien de spécial ne se passe. La méthode reduce prend une fonction qui prend deux Int s et produit un Int, donc en fournissant un f fonctionne très bien. Notez que lorsque vous dites f _ qui s'étend réellement à x => f x (ou, dans le cas de deux paramètres tels que ici, (x, y) => f(x, y)). Vous pouvez également fournir f qui sera ensuite utilisé directement, sans le wrapper de fonction anonyme supplémentaire.

La transformation d'une méthode en fonction en f _ est appelée eta-expansion (description complète: j'ai écrit cet article). La différence est subtile; function est une valeur, tandis qu'une méthode est, bien, une méthode que vous appelez sur un objet pour lequel elle est définie, par ex. myObject.myMethod. La fonction peut être autonome, être conservée dans des collections, etc. Définir votre méthode f directement comme une fonction serait val f: (Int, Int) => Int = (a: Int, b: Int) => a + b ou, avec l'inférence de type, val f = (a: Int, b: Int) => a + b.

BTW Je ne vois pas comment c'est une fermeture.