Scala Language
Overbelasting operator

Aangepaste Infix-operatoren definiëren

In Scala zijn operatoren (zoals + , - , * , ++ , enz.) Slechts methoden. 1 + 2 kan bijvoorbeeld worden geschreven als 1.+(2) . Dit soort methoden worden 'infix-operatoren' genoemd .

Dit betekent dat aangepaste methoden kunnen worden gedefinieerd voor uw eigen typen, waarbij deze operators opnieuw worden gebruikt:

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)
  }
}

Deze als methode gedefinieerde operatoren kunnen als volgt worden gebruikt:

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  

Merk op dat infix-operatoren slechts één argument kunnen hebben; het object voordat de operator de eigen operator op het object na de operator aanroept. Elke Scala-methode met één argument kan als infix-operator worden gebruikt.

Dit moet worden gebruikt met parcimony. Het wordt over het algemeen als een goede praktijk beschouwd als uw eigen methode precies doet wat men van die operator zou verwachten. Gebruik in geval van twijfel een conservatievere naamgeving, zoals add plaats van + .

Aangepaste Unary-operators definiëren

Unaire operatoren kunnen worden gedefinieerd door de operator te vervangen door unary_ . Unaire operatoren zijn beperkt tot unary_+ , unary_- , unary_! en 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) 
  }   
}

De unaire operator kan als volgt worden gebruikt:

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

Dit moet worden gebruikt met parcimony. Het overbelasten van een unaire operator met een definitie die niet is wat men zou verwachten, kan leiden tot code-verwarring.