Pourquoi taitement et uncurrying pas implicite dans scala

Question

Si j'ai une fonction:

f : A => B => C 

Je peux définir une conversion implicite telle que cela peut être utilisé lorsqu'une fonction (A, B) => C est attendue. Cela va aussi dans l'autre sens.

Pourquoi ces conversions ne sont-elles pas implicite (ou disponibles implicitement)? Je suppose que de mauvaises choses pourraient arriver pour une certaine valeur de mauvaises choses. Quelle valeur est-ce?

Answer 1

Je ne pense pas que quelque chose de mauvais va arriver. La conversion est complètement non ambiguë. Dans le pire des cas, Scala ne pourra pas comprendre que la conversion implicite s'applique.

implicit def curryImplicitly[A,B,C](f: (A, B) => C) = 
    (a: A) => (b: B) => f(a, b) 
implicit def uncurryImplicitly[A,B,C](f: A => B => C) = 
    (a: A, b: B) => f(a)(b) 

Ensuite, ceux-ci seraient également utiles.

implicit def flipImplicitly[A,B,C](f: (A, B) => C) = 
    (b: B, a: A) => f(a, b) 
implicit def flipImplicitlyCurried[A,B,C](f: A => B => C) = 
    (b: B) => (a: A) => f(a)(b) 

Mais ce ne sont pas transitif, vous devez donc celles-ci:

implicit def flipAndCurry[A,B,C](f: (A, B) => C) = 
    (b: B) => (a: A) => f(a, b) 
implicit def flipAndUncurry[A,B,C](f: A => B => C) = 
    (b: B, a: A) => f(a)(b) 

Mais maintenant, la conversion est ambiguë. Donc, ce ne sont pas toutes des roses.

Apprenons comment cela fonctionne dans la pratique. Vous pourriez avoir besoin d'équivalents pour Function3, Function4, etc.

Answer 2

Vous ne voulez pas qu'ils soient implicitement disponibles par défaut (toujours allumé) parce que le système de type a du mal à vous aider quand vous avez surchargé avec des arguments d'un tas de types similaires:

A => B => C 
D => C  // D is allowed to be a tuple (A,B)... 

(A,B) => C // If I have this, to whom should I convert? 

Une partie de l'avantage de la frappe forte vous avertit lorsque vous avez fait quelque chose d'idiot. Essayer trop fort de faire fonctionner les choses réduit les avantages. Ici, si les conversions ont été effectuées automatiquement, vous pourriez ne pas appeler la méthode que vous vouliez appeler. Les avoir disponibles implicitement sur demande, c'est bien, mais ce n'est pas si difficile à faire soi-même si vous en avez besoin. C'est quelque chose que j'utiliserais très rarement; Je ne le mettrais pas dans mon top dix ou probablement même les cent premières choses que je voudrais dans la bibliothèque (en partie parce que je pourrais préférer la conversion automatique à un tuple au lieu de l'automatique currying/uncurrying).