Scala Language
Surcharge de l'opérateur

Définition d'opérateurs d'infix personnalisés

Dans Scala, les opérateurs (tels que + , - , * , ++ , etc.) ne sont que des méthodes. Par exemple, 1 + 2 peut être écrit comme suit: 1.+(2) . Ces sortes de méthodes sont appelées «opérateurs infixes» .

Cela signifie que des méthodes personnalisées peuvent être définies sur vos propres types, en réutilisant ces opérateurs:

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

Ces opérateurs définis comme méthodes peuvent être utilisés comme ceci:

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  

Notez que les opérateurs infixes ne peuvent avoir qu'un seul argument. l'objet avant l'opérateur appellera son propre opérateur sur l'objet après l'opérateur. Toute méthode Scala avec un seul argument peut être utilisée comme opérateur infixe.

Cela devrait être utilisé avec parcimonie. Il est généralement considéré comme une bonne pratique que si votre propre méthode fait exactement ce que l'on attend d'un opérateur. En cas de doute, utilisez un nom plus conservateur, comme add au lieu de + .

Définition d'opérateurs unitaires personnalisés

Les opérateurs unaires peuvent être définis en ajoutant l'opérateur unary_ . Les opérateurs unary_+ sont limités à unary_+ , unary_- , unary_! et 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) 
  }   
}

L'opérateur unaire peut être utilisé comme suit:

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

Cela devrait être utilisé avec parcimonie. Surcharger un opérateur unaire avec une définition qui n'est pas ce à quoi on pourrait s'attendre peut entraîner une confusion du code.