This next post is an introduction to operators in Kotlin, not the basic the "use a plus sign to add numbers together" stuff (you read this blog, you got to be smart enough to figure that out). No, this post is about just how amazingly extensive the language is when it comes to support for allowing your classes to use them.
Adding things together
So let's start with a simple addition things together with plus I said we wouldn't do. In the following example code, we have a way to keep track of scoring events in a rugby game and I would like to add up those events to get the total score:
 enum class scoreType {
 <code>try</code>,
 conversion,
 kick
 }
 data class score(val type:scoreType) {
 fun points() = when(this.type) {
 scoreType.<code>try</code> > 5
 scoreType.conversion > 2
 scoreType.kick > 3
 }
 }
 fun main(args: Array<String>) {
 val gameData = listOf(score(scoreType.<code>try</code>), score(scoreType.conversion), score(scoreType.<code>try</code>), score(scoreType.kick))
 var totalPoints = 0
 for (event in gameData) {
 totalPoints = event + totalPoints
 }
 println(totalPoints)
 }
This obviously won't compile, you can't += an Int and my own class? Right?!
We could make this change, which is probably the better way but for my silly example, let us say this isn't ideal.
 totalPoints = event.points() + totalPoints
So to get our code to compile we just need a function named plus
which has the operator
keyword and whle I could call this myself, the Kotlin compiler is smart enough to now make it just work:
 data class score(val type:scoreType) {
 fun points() = when(this.type) {
 scoreType.<code>try</code> > 5
 scoreType.conversion > 2
 scoreType.kick > 3
 }
 operator fun plus(other:Int) = this.points() + other
 }
How cool is that?!
If I wanted to take it further and support say totalPoints += event
then you would need to add a function to Integer which tells it how to add a score to it. Thankfully that is easy with extension functions:
 operator fun Int.plus(other:score) = this + other.points()
Extensive
While the above is a bit silly, imagine building classes for distances, time, weights etc... being able to have a kilogram and a pound class and add them together! What makes Kotlin shine is how extensive it is, just look at this list!
Class  Operators  Method  Example Expression  

Arithmetic  + , '+=' 
plus 
first + second 

Augmented Assignments  += 
plusAssign  first += second` 

Unary  + 
unaryPlus 
+first 

Increment & Decrement  ++ 
inc 
first++ 

Arithmetic   , = 
minus 
first  second 

Augmented Assignments  = 
minusAssign 
first = second 

Unary   
unaryMinus 
`first  
Increment & Decrement   
dec 
first 

Arithmetic  * , *= 
times 
first * second 

Augmented Assignments  *= 
timesAssign 
first *= second 

Arithmetic  / , /= 
div 
first / second 

Augmented Assignments  /= 
divAssign 
first /= second 

Arithmetic  % , %= 
rem 
first % second 

Augmented Assignments  %= 
remAssign 
first %= second 

Equality  == , != 
equals 
first == second 

Comparison  > , < , <= , >= 
compareTo 
first > second 

Unary  ! 
not 
!first 

Arithmetic  .. 
rangeTo 
first..second 

In  in , !in 
contains 
first in second 

Index Access  [ , ] 
get 
This returns a value  first[index] 
Index Access  [ , ] 
set 
This sets a value  first[index] = second 
Invoke  () 
invoke 
first() 
I am going to go through some of these in more detail in future blog posts, but one I wanted to call out now:
Augmented Assignments vs. Plus or Minus
You might wonder why, when we just implemented plus
above we got both support for +
and +=
and the table lists +=
under both plus and augmented? Why both  because you may want to support just +=
without supporting +
.