# Operators

Operators like `+` and `-` are regular method calls. For example:

``````a + b
``````

is the same as:

``````a.+(b)
``````

You can define an operator for a type like this:

``````struct Vector2
getter x, y

def initialize(@x : Int32, @y : Int32)
end

def +(other)
Vector2.new(x + other.x, y + other.y)
end
end

v1 = Vector2.new(1, 2)
v2 = Vector2.new(3, 4)
v1 + v2               #=> Vector2(@x=4, @y=6)
``````

Next follows the full list of operators with their usual meaning.

## Unary operators

``````+   # positive
-   # negative
!   # not
~   # bitwise complement
``````

These are defined without arguments. For example

``````struct Vector2
def -
Vector2.new(-x, -y)
end
end

v1 = Vector2.new(1, 2)
-v1                    #=> Vector2(@x=-1, @y=-2)
``````

Note: `!` (not) cannot be defined as a method (its meaning can't be changed).

## Binary operators

• `+` – addition
• `-` – subtraction
• `*` – multiplication
• `/` – division
• `%` – modulo
• `&` – bitwise and
• `|` – bitwise or
• `^` – bitwise xor
• `**` – exponentiation
• `<<` – shift left, append
• `>>` – shift right
• `==` – equals
• `!=` – not equals
• `<` – less
• `<=` – less or equal
• `>` – greater
• `>=` – greater or equal
• `<=>` – comparison
• `===`case equality

## Indexing

``````[]  # array index (raises on out of bounds)
[]? # array index (nil on out of bounds)
[]= # array index assignment
``````

For example:

``````class MyArray
def [](index)
# ...
end

def [](index1, index2, index3)
# ...
end

def []=(index, value)
# ...
end
end

array = MyArray.new

array       # invokes the first method
array[1, 2, 3] # invokes the second method
array = 2   # invokes the third method

array.[](1)       # invokes the first method
array.[](1, 2, 3) # invokes the second method
array.[]=(1, 2)   # invokes the third method
``````

## Meaning

One can assign any meaning to the operators, but the convention is to follow the above ones to avoid cryptic code, or code that behaves in an unexpected way.