Overloaded operators: Difference between revisions

 

Many commands have multiple [[6502_Assembly#Addressing_Modes| addressing modes]], which alter the way a command is executed. On the 6502 most of these are in fact different opcodes, using the same mnemonic.

LDA $80 ;load the value stored at zero page memory address $80

LDA $2080 ;load the value stored at absolute memory address $2080.

LDA $80,x ;load the value stored at memory address ($80+x).

LDA ($80,x) ;use the values stored at $80+x and $81+x as a 16-bit memory address to load from.

 

=={{header|68000 Assembly}}==

Most assemblers will interpret instructions such as <code>MOVE</code>, <code>ADD</code>, etc. according to the operand types provided.

EOR.W #%1100000000000000,D5 ;assembles the same as EORI.W #%1100000000000000,D5

 

If you use <code>MOVE.W</code> with an address register as the destination, the CPU will sign-extend the value once it's loaded into the address register. In other words, a word that is $8000 or "more" will get padded to the left with Fs, whereas anything $7FFF or less will be padded with zeroes.

 

=={{header|Ada}}==

Many Ada standard libraries overload operators. The following examples are taken from the Ada Language Reference Manual describing operators for vector and matrix types:

 

type Real_Matrix is array (Integer range <>, Integer range <>) of Real'Base;

-- Real_Vector arithmetic operations

return Real_Matrix;

function "/" (Left : Real_Matrix; Right : Real'Base)

 

The following examples are from the Ada package Ada.Numerics.Generic_Complex_Types

 

function "-" (Right : Complex) return Complex;

function Conjugate (X : Complex) return Complex;

function "*" (Left : Real'Base; Right : Imaginary) return Imaginary;

function "/" (Left : Imaginary; Right : Real'Base) return Imaginary;

 

=={{header|ALGOL 68}}==

For new dyadic operators, the priority must be specified (though some implementations provide a default).

In both cases this is done with a PRIO declaration.

# Algol 68 allows operator overloading, both of existing operators and new ones #

# Programmer defined operators can be a "bold word" (uppercase word) or a symbol #

OP + = ( INT a, BOOL b )INT: IF b THEN a + 1 ELSE a FI;

print( ( TOSTRING a + " ""+"" " + TOSTRING ( a = 10 ) + " = " + TOSTRING ( a + ( a = 10 ) ), newline ) )

{{out}}

<pre>

 

For example, <code>⌊</code> is Floor in the monadic case:

But in the dyadic case, it becomes Minimum:

 

=={{header|C++}}==

 

And yes, I know subtracting cuboids can give negative volumes. It's theoretically possible (remember volume or triple integrals ? ).

//Aamrun, 4th October 2021

 

return 0;

}

{{out}}

<pre>

=={{header|F_Sharp|F#}}==

For those who complain that they can't follow my F# examples perhaps if I do the following it will help them.

// Overloaded operators. Nigel Galloway: September 16th., 2021

let (+) (n:int) (g:int) = n-g

printfn "%d" (23+7)

{{out}}

<pre>

The following example overloads the member operators <code>Cast</code>(Cast) and <code>*=</code>(Multiply And Assign) for objects of a user-defined type.

 

As Integer numerator, denominator

r1 *= r2

Dim As Double d = r1

 

 

 

Note that `+` is symmetric except for its restriction to object x object, as illustrated by:

 

Most of the other operators that are usually thought of as "arithmetic" are also overloaded, notably:

<pre>

 

The comparison operators can also be used on non-JSON entities as well, e.g.

0 < infinite #=> true

nan < 0 #=> true

 

The logical operators (`and`, `or`, `not`) are also defined for all JSON entities, their logic being

`length/0` is defined on all JSON entities except `true` and `false`. Note that it is defined

as the absolute value on JSON numbers, and that:

 

It is also worth pointing out that a single name/arity function can have multiple definitions within

directly accessible. The functionality of the "outer" definition, however, can be accessed indirectly,

as illustrated by the following contrived example:

def outer_length: length;

def length: outer_length | tostring;

[outer_length, length];

 

 

=={{header|Julia}}==

Most operators in Julia's base syntax are in fact just syntactic sugar for function calls. In particular, the symbols:

* / ÷ % & ⋅ ∘ × ∩ ∧ ⊗ ⊘ ⊙ ⊚ ⊛ ⊠ ⊡ ⊓ ∗ ∙ ∤ ⅋ ≀ ⊼ ⋄ ⋆ ⋇ ⋉ ⋊ ⋋ ⋌ ⋏ ⋒ ⟑ ⦸ ⦼ ⦾ ⦿ ⧶ ⧷ ⨇ ⨰ ⨱ ⨲ ⨳ ⨴ ⨵ ⨶ ⨷ ⨸ ⨻

⨼ ⨽ ⩀ ⩃ ⩄ ⩋ ⩍ ⩎ ⩑ ⩓ ⩕ ⩘ ⩚ ⩜ ⩞ ⩟ ⩠ ⫛ ⊍ ▷ ⨝ ⟕ ⟖ ⟗

are parsed in the same precedence as the multiplication operator function *, and the symbols:

+ - ⊕ ⊖ ⊞ ⊟ ∪ ∨ ⊔ ± ∓ ∔ ∸ ≏ ⊎ ⊻ ⊽ ⋎ ⋓ ⧺ ⧻ ⨈ ⨢ ⨣ ⨤ ⨥ ⨦ ⨧ ⨨ ⨩ ⨪ ⨫ ⨬ ⨭ ⨮ ⨹ ⨺ ⩁ ⩂ ⩅ ⩊ ⩌ ⩏ ⩐ ⩒ ⩔ ⩖ ⩗ ⩛ ⩝ ⩡ ⩢ ⩣

are parsed as infix operators with the same precedence as +. There are many other operator symbols that can be used as prefix or as infix operators once defined as a function in Julia.

<br /><br />

As a language, much of Julia is organized around the concept of multiple dispatch. Because the language dispatches function calls according to the types of the function arguments, even the base arithmetic operators are in fact overloaded operators in Julia.

is dispatched to the overloaded function *(x::Float64, y::Float64)::Float64. Similarly, string concatenation in Julia is with * rather than +, so "hello " * "world" is dispatched to the overloaded function *(x::String, y::String)::String, and other types such as matrices also have arithmetic operators overloaded in base Julia:

2×2 Matrix{Int64}:

51 62

73 84

Users may define their own overloaded functions in similar ways, whether or not such operators are already used in base Julia. In general, it is considered bad practice, and as "type piracy", to define a user overloaded operator which dispatches on the same types for which base Julia has already defined the same function. Instead, user defined types can be best made to have analogous operators defined for

the new type so as to leverage existing code made for analogous base types. This can allow generic functions to use new types in efficient and constructive ways.

=== A simple example ===

The code below is just given as a simplistic example, since in practice the body of such simple one-liner functions would most likely be used without the overloading syntax.

import Base.-

 

@show [2, 3, 4, 3, 1, 7] - 3 # [2, 3, 4, 3, 1, 7] - 3 = [2, 4, 1, 7]

@show "world" - 'o' # "world" - 'o' = "wrld"

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

Define a custom vector object and define how plus works on these objects:

{{out}}

<pre>vec[{13, 10}]</pre>

Nim allows overloading of operators. There is no restrictions regarding types of arguments when overloading an operator. For instance, we may define a vector type and addition of vectors:

 

 

func `+`(a, b: Vector): Vector = (a.x + b.x, a.y + b.y, a.z + b.z)

 

 

The list of predefined operators with their precedence can be found here: https://rosettacode.org/wiki/Operator_precedence#Nim

For instance, we may define an operator <code>^^</code> the following way:

 

 

To determine the precedence of user-defined operators, Nim defines a set of rules:

so that they can be used on members of that class(package). Also see 'Zeckendorf arithmetic' where overloading

is used on Zeckendorf numbers.

 

use strict; # https://rosettacode.org/wiki/Overloaded_operators

my ($self, $other, $swap) = @_;

$self->new( $$self =~ s/$$other/$$other/g );

{{out}}

<pre>

Inline assembly mnemonics have multiple implicit addressing modes as per the standard intel syntax.

 

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%g\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3.5</span> <span style="color: #0000FF;">+</span> <span style="color: #000000;">3</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- 6.5</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%t\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3.5</span> <span style="color: #0000FF;">></span> <span style="color: #000000;">3</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- true</span>

mov eax,1 -- etc

}

 

=={{header|Raku}}==

For example:

 

 

is a perfectly cromulent sequence definition in Raku. A little odd perhaps, but completely sensible. (It's the sequence starting with givens 1,2,1, with each term after the value of the term 3 terms back, raised to the power of the term two terms back, multiplied by the value one term back, continuing for some undefined number of terms. - Whatever to the whatever times whatever until whatever.)

 

Addition:

say 3.0 + 0.5e1; # Rat plus Num

say '3' + 5; # Str plus Int

say '3' + '5'; # Str plus Str

say '3.0' + '0.5e1'; # Str plus Str

 

+ is a numeric operator so every thing is evaluated numerically if possible

 

Concatenation:

say 3.0 ~ 0.5e1; # Rat concatenate Num

say '3' ~ 5; # Str concatenate Int

say '3' ~ '5'; # Str concatenate Str

say '3.0' ~ '0.5e1'; # Str concatenate Str

 

~ is a Stringy operator so everything is evaluated as a string (numerics are evaluated numerically then coerced to a string).

itself.

 

 

sub infix:<⊗> (Int $x, Int $y) is equiv(&infix:<×>) {

}

 

{{out}}

<pre>31562</pre>

 

Very, '''very''' basic Line class:

has @.start;

has @.end;

 

# In operation:

 

{{out}}

 

<br>Note that some REXXes may also have other characters (glyphs) for the negation operator &nbsp; (not) &nbsp; such as: &nbsp; &nbsp; <big>^</big> &nbsp; and/or &nbsp; <big>¬</big> &nbsp; glyphs.

say '──positive prefix──'

say +5 /* positive prefix integer */

say '1' && (0) /* binary XOR'ed binary */

 

{{out|output|text=&nbsp; when using the internal default input:}}

<pre>

 

However, whilst it is very useful for classes representing mathematical objects, it should otherwise be used sparingly as code can become unreadable if it is used inappropriately.

 

var s1 = "Rosetta "

var d2 = Date.new(2021, 9, 13)

var i1 = (d2 - d1).days

 

{{out}}