Perché currying e uncurrying non implicita in scala

Question

Se ho una funzione:

f : A => B => C

Posso definire una conversione implicita tale che questo può essere utilizzato se una funzione (A, B) => C è previsto.Questo va nella direzione di altri anche.

Perché sono queste conversioni non implicito (oppure in modo implicito)?Io parto dal presupposto che male le cose potrebbero accadere per alcuni il valore di cose cattive.Che valore è?

Answer 1

Io non penso nulla di male accadrà.La conversione è completamente chiara.Peggiore dei casi, la Scala non sarà in grado di capire che la conversione implicita si applica.

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)

Poi di nuovo, questi sarebbe anche utile.

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)

Ma quelli non sono transitiva, quindi avete bisogno di questi:

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)

Ma ora che la conversione è ambiguo.Quindi non è tutto rose e fiori.

Sapere come funziona in pratica.Potrebbe essere necessario equivalenti per Function3, Function4, etc.

Answer 2

Non li vogliono implicitamente disponibile per impostazione predefinita (always-on), perché poi il tipo di sistema ha problemi ad aiutarti quando hai sovraccaricato con argomenti di un mazzo di tipi simili:

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?

Parte del vantaggio di tipizzazione forte è di avviso quando hai fatto qualcosa di stupido.Cercando troppo duro per far funzionare le cose, riduce i benefici.Qui, se le conversioni sono state fatte automaticamente, non si potrebbe chiamare il metodo che si intende chiamare.

Averli a disposizione in modo implicito, su richiesta, è bene, ma non è che difficile da fare da soli, se necessario.Questo è qualcosa che vorrei usare molto raramente;Non la metterei nella mia top ten o forse anche centinaia di cose che vorrei in biblioteca (in parte perché mi potrebbe preferire la conversione automatica di una tupla anziché automatico currying/uncurrying).