F # - Sobrecarga del operador

Puede redefinir o sobrecargar la mayoría de los operadores integrados disponibles en F #. Por tanto, un programador también puede utilizar operadores con tipos definidos por el usuario.

Los operadores son funciones con nombres especiales, entre paréntesis. Deben definirse como miembros de clase estáticos. Como cualquier otra función, un operador sobrecargado tiene un tipo de retorno y una lista de parámetros.

El siguiente ejemplo muestra un operador + en números complejos -

//overloading + operator
static member (+) (a : Complex, b: Complex) =
Complex(a.x + b.x, a.y + b.y)

La función anterior implementa el operador de suma (+) para una clase compleja definida por el usuario. Agrega los atributos de dos objetos y devuelve el objeto complejo resultante.

Implementación de sobrecarga del operador

El siguiente programa muestra la implementación completa:

//implementing a complex class with +, and - operators
//overloaded
type Complex(x: float, y : float) =
   member this.x = x
   member this.y = y
   //overloading + operator
   static member (+) (a : Complex, b: Complex) =
      Complex(a.x + b.x, a.y + b.y)

   //overloading - operator
   static member (-) (a : Complex, b: Complex) =
      Complex(a.x - b.x, a.y - b.y)

   // overriding the ToString method
   override this.ToString() =
      this.x.ToString() + " " + this.y.ToString()

//Creating two complex numbers
let c1 = Complex(7.0, 5.0)
let c2 = Complex(4.2, 3.1)

// addition and subtraction using the
//overloaded operators
let c3 = c1 + c2
let c4 = c1 - c2

//printing the complex numbers
printfn "%s" (c1.ToString())
printfn "%s" (c2.ToString())
printfn "%s" (c3.ToString())
printfn "%s" (c4.ToString())

Cuando compila y ejecuta el programa, produce el siguiente resultado:

7 5
4.2 3.1
11.2 8.1
2.8 1.9