¿Cómo se define un var/val local en el constructor primario en Scala?

Question

En Scala, el constructor primario de una clase no tiene cuerpo explícito, pero se define implícitamente desde el cuerpo de la clase. ¿Cómo, entonces, se puede distinguir entre los campos y los valores locales (es decir, los valores locales del método constructor)?

Por ejemplo, tomemos el siguiente fragmento de código, una forma modificada de un código de ejemplo de "Programación en Scala":

class R(n: Int, d: Int) { 
    private val g = myfunc 
    val x = n/g 
    val y = d/g 
} 

Mi opinión es que esto va a generar una clase con tres campos: un privado " g ", y público" x "e" y ". Sin embargo, el valor de g se usa solo para el cálculo de los campos xey, y no tiene ningún significado más allá del alcance del constructor.

Entonces, en este ejemplo (ciertamente artificial), ¿cómo se puede definir valores locales para este constructor?

Answer 1

E.g.

class R(n: Int, d: Int) { 
    val (x, y) = { 
    val g = myfunc 
    (n/g, d/g) 
    } 
} 

Answer 2

Existen varias formas de hacerlo. Puede declarar tales variables temporales dentro de definiciones privadas, para usarlas durante el tiempo de construcción. Puede usar variables temporales dentro de bloques que devuelven expresiones (como en la respuesta de Alaz). O, finalmente, puede usar tales variables dentro de constructores alternativos.

De manera similar a los constructores alternativos, también podría definirlos dentro del método "apply" del objeto-compañero.

Lo que no se puede hacer es declarar un campo como "temporal".

Tenga en cuenta también que cualquier parámetro recibido por el constructor primario también es un campo. Si no desea que dichos parámetros se conviertan en campos y no desea exponer los campos reales en un constructor, la solución habitual es hacer privado el constructor primario, con los campos reales, y usar un constructor alternativo o un object-companion's apply() como el constructor "principal" efectivo.

Answer 3

Algunos discusión sobre este tema, incluyendo los comentarios de Martin Odersky, es here

Answer 4

Otra opción que tenemos es hacer que el constructor de objetos primaria privada y el uso de un compañero objeto de aplicar el método como constructor. Si aplicamos (juego de palabras no pretende) este enfoque a su ejemplo se vería así:

class R private (val x: Int, val y: Int); 

object R { 
    def apply(n: Int, d: Int): R = { 
    val g = myfunc; 
    new R(n/g, d/g); 
    } 
} 

para crear una instancia de R en lugar de:

val r = new R(1, 2); 

escritura:

val r = R(1, 2); 

Esto es un poco detallado, pero podría ser peor, creo :). Esperemos que los vals privados [este] sean tratados como variables temporales en versiones futuras de Scala. El mismo Martin insinuó eso.