Scala: rastrear a seleção de implícitos e outras mágicas de código

Question

Ao tentar descobrir como uma biblioteca funciona, conversões implícitas são confusas. Por exemplo, olhando para uma expressão como 'Val Foo: Foo = 1', o que converte 1 em foo?

É possível instruir a Biblioteca Scala (ou REPL) a imprimir os caminhos de código que estão executando ao avaliar uma expressão?

Answer 1

Você pode adicionar "-xprint: typer" à linha de comando do compilador (ou "-ybrowse: typer" para um navegador GUI swing) para ver o código com as conversões aplicadas explicitamente.

Answer 2

Como alternativa para imprimir as conversões, é preciso perceber que os implícitos não podem simplesmente sair do nada. Você tem que trazê -los para o escopo de alguma forma. As alternativas são:

1. Explícito import declaração. Ter cuidado com import x.y._ quando y é um objeto, pois essa é a única maneira de trazer um implícito no escopo.
2. O companheiro de objeto da classe que está sendo convertido em outra coisa.
3. O companheiro de objeto da classe de destino, desde que esse alvo seja explicitado de alguma forma (como no seu exemplo).

Observe que o objeto scala.Predef é tudo importado para o escopo por padrão, e é assim que os implícitos padrão de Scala entram no escopo.

Answer 3

scalac -print Imprime o código após conversões de tipo implícito, quando aplicado.

class A{
    val x : String = "hi" drop 1 
}

Vai resultar em:

package <empty> {
  class A extends java.lang.Object with ScalaObject {
    @remote def $tag(): Int = scala.ScalaObject$class.$tag(A.this);
    private[this] val x: java.lang.String = _;
    <stable> <accessor> def x(): java.lang.String = A.this.x;
    def this(): A = {
      A.super.this();
      A.this.x = scala.this.Predef.forceRandomAccessCharSeq(
        scala.this.Predef.stringWrapper("hi").drop(1));
      ()
    }
  }
}