Quel est le problème avec la définition de la méthode

Question

Voici mes signatures de méthode et définitions scala

def accumulate[T[_]: Traversable, O: Monoid, A]: (A => O) => T[A] => O = 
    fao => ta => 
     (implicitly[Traversable[T]].traverse[({type f[X] = Acc[O, X]})#f, A, O](ta)(a => Acc(fao(a)))).value 

    def reduce[T[_]: Traversable, O: Monoid]: T[O] => O = to => accumulate[T, O, O](a => a)(to) 

Cependant, j'obtiens l'erreur suivante pour ma définition de réduire

Error:(160, 82) not enough arguments for method accumulate: (implicit evidence$7: Traversable[T], implicit evidence$8: Monoid[O])(O => O) => (T[O] => O). 
Unspecified value parameter evidence$8. 
    def reduce[T[_]: Traversable, O: Monoid]: T[O] => O = to => accumulate[T, O, O](a => a)(to) 
                       ^

Je ne sais pas où je vais faux. Toute aide serait appréciée.

Merci!

Answer 1

Vous êtes dérouté par les paramètres cachés (implicites) de la méthode accumulate. Le contexte délimite vous avez placé sur ce que cela signifie que la méthode vraiment a la signature de type:

def accumulate[T[_], O, A](
    implicit traversable: Traversable[T], 
    monoid: Monoid[O]): (A => O) => T[A] => O 

En fait, je vous conseille de pas contexte d'utilisation limites Si vous avez réellement besoin d'utiliser leurs implicits correspondants dans vos méthodes (par opposition à simplement les transmettre implicitement à une autre méthode). Il est beaucoup plus clair de taper les implicites explicitement (ironiquement).

Alors, qu'est-ce qui se passe dans reduce est que vous essayez de passer dans la fonction a => a dans la position où le compilateur attend les deux arguments implicites de Traversable[T] et Monoid[O]. La solution consiste à passer dans les implicits explicitement ou monomorphiseaccumulate avant de l'appeler:

def reduce[T[_]: Traversable, O: Monoid]: T[O] => O = { to => 
    // This forces the compiler to pass in the correct implicits 
    val accumulate_ = accumulate[T, O, O] 
    accumulate_(a => a)(to) 
}