Scala Language
Sobrecarga del operador

Definición de operadores de infijo personalizados

En Scala, los operadores (como + , - , * , ++ , etc.) son solo métodos. Por ejemplo, 1 + 2 se puede escribir como 1.+(2) . Este tipo de métodos se denominan 'operadores de infijo' .

Esto significa que los métodos personalizados se pueden definir en sus propios tipos, reutilizando estos operadores:

class Matrix(rows: Int, cols: Int, val data: Seq[Seq[Int]]){
  def +(that: Matrix) = {
    val newData = for (r <- 0 until rows) yield
      for (c <- 0 until cols) yield this.data(r)(c) + that.data(r)(c)

    new Matrix(rows, cols, newData)
  }
}

Estos operadores definidos como métodos se pueden usar de la siguiente manera:

val a = new Matrix(2, 2, Seq(Seq(1,2), Seq(3,4)))
val b = new Matrix(2, 2, Seq(Seq(1,2), Seq(3,4)))

// could also be written a.+(b)
val sum = a + b  

Tenga en cuenta que los operadores de infijo solo pueden tener un solo argumento; el objeto antes de que el operador llame a su propio operador en el objeto después del operador. Cualquier método Scala con un solo argumento se puede usar como un operador de infijo.

Esto debe ser usado con parcimony. En general, se considera una buena práctica solo si su propio método hace exactamente lo que uno esperaría de ese operador. En caso de duda, use un nombre más conservador, como add lugar de + .

Definiendo Operadores Unarios Personalizados

Los operadores unarios se pueden definir precediendo al operador con unary_ . Los operadores unarios están limitados a unary_+ , unary_- , unary_! y unary_~ :

class Matrix(rows: Int, cols: Int, val data: Seq[Seq[Int]]){
  def +(that: Matrix) = {
    val newData = for (r <- 0 until rows) yield
      for (c <- 0 until cols) yield this.data(r)(c) + that.data(r)(c)

    new Matrix(rows, cols, newData)
  }

  def unary_- = {
    val newData = for (r <- 0 until rows) yield 
      for (c <- 0 until cols) yield this.data(r)(c) * -1
   
    new Matrix(rows, cols, newData) 
  }   
}

El operador unario se puede utilizar de la siguiente manera:

val a = new Matrix(2, 2, Seq(Seq(1,2), Seq(3,4)))
val negA = -a

Esto debe ser usado con parcimony. Sobrecargar a un operador unario con una definición que no es lo que uno esperaría puede llevar a la confusión del código.