Scala Language
Überladung des Bedieners

Benutzerdefinierte Infix-Operatoren definieren

In Scala-Operatoren (wie + , - , * , ++ usw.) sind dies nur Methoden. Zum Beispiel kann 1 + 2 als 1.+(2) . Diese Arten von Methoden werden als "Infixoperatoren" bezeichnet .

Dies bedeutet, dass benutzerdefinierte Methoden für Ihre eigenen Typen definiert werden können, wobei diese Operatoren wiederverwendet werden:

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

Diese als Methoden definierten Operatoren können wie folgt verwendet werden:

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  

Beachten Sie, dass Infix-Operatoren nur ein einziges Argument haben können. Das Objekt vor dem Operator ruft seinen eigenen Operator für das Objekt nach dem Operator auf. Als Infix-Operator kann jede Scala-Methode mit einem einzigen Argument verwendet werden.

Dies sollte mit Parcimony verwendet werden. Es wird im Allgemeinen nur dann als bewährte Methode angesehen, wenn Ihre eigene Methode genau das tut, was Sie von diesem Operator erwarten würden. Verwenden Sie im Zweifelsfall eine konservativere Benennung, z. B. add anstelle von + .

Benutzerdefinierte unäre Operatoren definieren

Unäre Operatoren können definiert werden, indem dem Operator unary_ . Unäre Operatoren sind auf unary_+ , unary_- , unary_! und 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) 
  }   
}

Der unäre Operator kann wie folgt verwendet werden:

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

Dies sollte mit Parcimony verwendet werden. Das Überladen eines unären Operators mit einer Definition, die nicht erwartet wird, kann zu Code-Verwirrung führen.