Scala, Currying su un metodo a gruppi di parametri multipli inclusi parametri impliciti?

Question

Dopo aver scoperto che currying multi parameter-groups method is possible, sto cercando di ottenere una funzione parzialmente applicata che richiede parametri impliciti.

Non è possibile farlo. Se no, potresti spiegarmi perché?

scala> def sum(a: Int)(implicit b: Int): Int = { a+b } 
sum: (a: Int)(implicit b: Int)Int 

scala> sum(3)(4) 
res12: Int = 7 

scala> val partFunc2 = sum _ 
<console>:8: error: could not find implicit value for parameter b: Int 
     val partFunc2 = sum _ 
        ^

Utilizzo un oggetto singleton per creare questa funzione parzialmente applicata e voglio usarlo in un ambito in cui è definito l'int implicito.

Answer 1

Questo perché non si dispone di un Int implicito nell'ambito. Vedi:

scala> def foo(x: Int)(implicit y: Int) = x + y 
foo: (x: Int)(implicit y: Int)Int 

scala> foo _ 
<console>:9: error: could not find implicit value for parameter y: Int 
       foo _ 
      ^

scala> implicit val b = 2 
b: Int = 2 

scala> foo _ 
res1: Int => Int = <function1> 

L'implicito viene sostituito con un valore reale dal compilatore. Se si esegue il curry del metodo, il risultato è una funzione e le funzioni non possono avere parametri impliciti, quindi il compilatore deve inserire il valore nel momento in cui si esegue il curry del metodo.

edit:

Per il vostro caso d'uso, perché non provare qualcosa di simile:

object Foo { 
    def partialSum(implicit x: Int) = sum(3)(x) 
} 

Answer 2

scala> object MySingleton { 
| def sum(a: Int)(implicit b: Int): Int = { a+b } 
| 
| 
| def caller(a: Int) = { 
|  implicit val b = 3; // This allows you to define the partial below 
|  def pf = sum _  // and call sum()() without repeating the arg list. 
|  pf.apply(a) 
| } 
| } 
defined module MySingleton 


scala> MySingleton.caller(10) 
res10: Int = 13