Início / coding / Perguntas / 78009792
Accepted
bwbecker
Asked: 2024-02-17 04:13:19 +0800 CST

Subclasses anônimas com métodos extras – scala2 vs. scala3

  • 772

O código a seguir funciona como esperado em scala2, mas gera um erro em tempo de compilação em scala3. Tentei encontrar uma explicação em Programação em Scala, Quinta Edição e na web, mas não consegui. Alguma ideia?

object Main {
    def main(args:Array[String]): Unit = {

        val foo = new Foo(7)
        println(foo.double)             // 14

        val bar = new Foo(8) {
            def triple:Int = this.i * 3
        }

        println(bar.double)             // 16
        println(bar.triple)             // 24 in scala2; compile error in scala3
    }
}

class Foo(val i:Int) {
    def double:Int = i*2
}

Erro de compilação:

-- [E008] Not Found Error: /tmp/example.scala:12:20 ----
12 |        println(bar.triple)
   |                ^^^^^^^^^^
   |                value triple is not a member of Foo
scala

2 respostas

  1. Best Answer

    Se você compilar seu código com scala -Xprint:typer , verá que val baragora tem explicitamente o tipo Foono Scala 3:

        def main(args: Array[String]): Unit = 
      {
        val foo: Foo = new Foo(7)
        println(foo.double)
        val bar: Foo = 
          {
            final class $anon() extends Foo(8) {
              def triple: Int = this.i.*(3)
            }
            new $anon():Foo
          }
        println(bar.double)
        println(bar.triple)
      }

    Compare isso com Scala 2, onde barobtém o tipo de refinamento Foo { def triple: Int }:

          val bar: Foo{def triple: Int} = {
        final class $anon extends Foo {
          def <init>(): <$anon: Foo> = {
            $anon.super.<init>(8);
            ()
          };
          def triple: Int = this.i.*(3)
        };
        new $anon()
      };

    Então, é

    val bar: Foo                   // In Scala 3
val bar: Foo{def triple: Int}  // In Scala 2

    Para alcançar o comportamento do Scala 2, você poderia introduzir Barexplicitamente uma nova classe:

            class Bar extends Foo(8) {
          def triple: Int = this.i * 3
        }
        val bar = new Bar

    Código compilável completo:

    object Main {
    def main(args:Array[String]): Unit = {

        val foo = new Foo(7)
        println(foo.double)             // 14

        class Bar extends Foo(8) {
          def triple: Int = this.i * 3
        }
        val bar = new Bar

        println(bar.double)             // 16
        println(bar.triple)             // 24 in scala2; compile error in scala3
    }
}

class Foo(val i:Int) {
    def double:Int = i*2
}

    Quanto ao motivo pelo qual está inferindo Fooem vez de Foo { def triple: Int }- não tenho certeza, acho que eles descobriram que esse comportamento funciona melhor com outros recursos da linguagem.

    Como você explicaria que val x = "hello"infere x: Stringe não x: "hello"?

    • 3

  2. Isso é abordado no guia de migração Scala 3 em https://docs.scala-lang.org/scala3/guides/migration/incompat-type-inference.html#reflective-type :

    As chamadas reflexivas do Scala 2 são abandonadas e substituídas pelos Tipos Estruturais Programáticos mais amplos.

    • 2

relate perguntas