syntax - trait - ¿Qué personajes puedo omitir en Scala?

variables scala

Question

En Scala, ¿por qué puedo omitir el punto y las franjas en T m 0 (en lugar de Tm(0) ) en lo siguiente?

scala> object T { def m(i:Int) = 0 == i }
defined module T

scala> T m 0
res19: Boolean = true

Pero, ¿por qué no puedo omitir las correas en n(0) en lo siguiente?

scala> def n(i:Int) = 0 == i
n: (Int)Boolean

scala> n 0
<console>:1: error: '';'' expected but integer literal found.
       n 0
         ^

Answer 1

Creo que el estilo de sintaxis del operador solo funciona cuando tienes un objeto explícito en el lado izquierdo. La sintaxis está destinada a permitirle expresar las operaciones de estilo "operando operador de operando" de una manera natural.

Answer 2

El ejemplo anterior, T m 0, es un ejemplo de "notación de operador". Scala tiene tres tipos de notaciones de operador, prefijo (llamado unario), infijo y postfijo. Veamos ejemplos de los tres en acción aquí:

class MyByte(val n : Int) {
  require(n >= 0 && n <= 255)
  def unary_! = new MyByte(n ^ 0xff)
  def +(m : MyByte) = new MyByte(n + m.n)
  def bits = (math.log(n) / math.log(2) + 1).toInt
  override def toString = "0" * (8 - bits) + n.toBinaryString
}

Y aquí está en uso:

scala> val a = new MyByte(5)
a: MyByte = 00000101

scala> val b = new MyByte(10)
b: MyByte = 00001010

scala> ! a  // Prefix/Unary
res58: MyByte = 11111010

scala> a + b  // Infix
res59: MyByte = 00001111

scala> b bits  // Postfix
res60: Int = 4

Mientras que las notaciones infijo y postfix aceptan cualquier identificador válido de Scala, aunque se habla de restringir la notación postfix, solo se pueden usar cuatro identificadores como prefijo: ~,!, - y +.

Ahora, cuando prueba "m 0", Scala lo descarta como un operador único, por no ser válido (~,!, - y +). Encuentra que "m" es un objeto válido, es una función, no un método, y todas las funciones son objetos.

Como "0" no es un identificador válido de Scala, no puede ser ni un infijo ni un operador postfix. Por lo tanto, Scala se queja de que esperaba ";" - que separaría dos (casi) expresiones válidas: "m" y "0". Si lo insertó, entonces se quejaría de que m requiere un argumento o, en su defecto, una "_" para convertirlo en una función parcialmente aplicada.