# 9. Operators

## 1. Introduction

Sather's operators are syntax sugars of certain methods.
These syntax sugars make Sather codes readable.
As the methods for operators are pre-defined,
you can re-define the operators of your own classes.

## 2. Arithmetic operators

Table 1 shows arithmetic methods and corresponding operators.

Table 1: Arithmetic methods and corresponding operators.
Methods |
Operators |

`a`.plus(`b`) |
`a` + `b` |

`a`.minus(`b`) |
`a` - `b` |

`a`.times(`b`) |
`a` * `b` |

`a`.div(`b`) |
`a` / `b` |

`a`.pow(`b`) |
`a` ^ `b` |

`a`.mod(`b`) |
`a` % `b` |

`a`.is_lt(`b`) |
`a` < `b` |

`a`.is_eq(`b`) |
`a` = `b` |

-`a` |
`a`.negate |

~`a` |
`a`.not |

Table 2 shows comparison operators with their corresponding methods.

Table 2: Comparison operators and their corresponding methods.
Operators |
Corresponding Methods |

`a` <= `b` |
`b`.is_lt(`a`).not |

`a` >= `b` |
`a`.is_lt(`b`).not |

`a` /= `b` |
`a`.is_eq(`b`).not |

`a` > `b` |
`b`.is_lt(`a`) |

## 3.Accessing array elements

You can refer and assign array elements by using `aget` and `aset` methods, respectively.
Table 3 shows the syntax sugars for these.

Table 3: Methods to access array elements with their syntax sugars.
Methods |
Syntax sugars |

`b` := `a`.aget(`i`) |
`b` := `a`[`i`] |

`a`.aset(`i`, `b`) |
`a`[`i`] := `b` |

## 4. Defining your own operators

You can define your own operators by defining methods such as
`is_eq`, `plus`, `minus`, `aget`, `aset`, and so on.
For instance, the `plus` method of the `STR` class has been
re-defined so that you can concatenate any objects that can be converted to strings.
The `INT` class has its `aget` and `aset` methods to access the array of bits.
You can modify the program crypt.sa in Abstract Classes

by using this methods.
The integers in the program are XORed by `bxor`.
It is unnecessary to get XOR's of whole 32 bits because the integers converted from `CHAR`'s,
have only 8 bits.
Following is a more efficient code.

fs := fs + cxor(s.elt!.int,key_rotate!);
private cxor(m,n:INT):CHAR is
i,k:INT;
loop
i:=CHAR::asize.times!;
k:=k.aset(i, m[i].xor(n[i]));
end;
return k.char;
end;

## 5. Summary

Sather allows you to re-define the operators like other OO languages.

Intuitive definition of the operators makes your codes readable.