Considera il seguente frammento di codice (adattato dal link ):
// Using scalaz 6
import scalaz._, Scalaz._
object Example extends App {
case class Container(i: Int)
def compute(s: String): State[Container, Int] = state {
case Container(i) => (Container(i + 1), s.toInt + i)
}
val d = List("1", "2", "3")
type ContainerState[X] = State[Container, X]
println( d.traverse[ContainerState, Int](compute) ! Container(0) )
}
Capisco cosa fa ad alto livello. Ma volevo tracciare cosa succede esattamente durante la chiamata a d.traverse alla fine. Chiaramente, List non ha traverse , quindi deve essere implicit ly convertito in un altro tipo che lo fa. Anche se ho passato una considerevole quantità di tempo cercando di scoprirlo, non ho avuto molto successo. Per prima cosa ho scoperto che esiste un metodo in scalaz.Traversable
traverse[F[_], A, B] (f: (A) => F[B], t: T[A])(implicit arg0: Applicative[F]): F[T[B]]
ma chiaramente non è questo (anche se è più probabile che "mio" traverse sia implementato usando questo). Dopo un sacco di ricerche, ho sfruttato i codici sorgente scalaz e ho trovato il metodo di scalaz.MA
traverse[F[_], B] (f: (A) => F[B])(implicit a: Applicative[F], t: Traverse[M]): F[M[B]]
che sembra essere molto vicino. Ancora mi manca cosa List viene convertito nel mio esempio e se utilizza MA.traverse o qualcos'altro.
La domanda è: quale procedura devo seguire per scoprire cosa viene chiamato esattamente a d.traverse ?
Avere anche un codice così semplice e così difficile da analizzare mi sembra un grosso problema. Mi sto perdendo qualcosa di molto semplice?
Come dovrei procedere quando voglio capire un codice che usa un sacco di% importato implicit s? C'è un modo per chiedere al compilatore che cosa implicit s ha usato? O c'è qualcosa come Hoogle per Scala in modo che possa cercare un metodo solo per nome?
