In Kotlin, I can redefine some existing operators, but what about creating new operators?

Question

In Kotlin, I see that I can override some operators, such as + with the plus() function and * with the times() function ... but for some things like Sets, the preferred (set theory) of characters / operators does not exist. For example A∩B for intersection and A∪B for union.

I cannot define my own operators, there is no clear syntax to say which character to use for the operator. For example, if I want to make a function for $$ as an operator:

 operator fun String.$$(other: String) = "$this !!whatever!! $other" // or even operator fun String.whatever(other: String) = "$this !!whatever!! $other" // how do I say this is the $$ symbol?!? 

I get the same error for both:

Error: (y, x) Kotlin: the 'operator' modifier is not applicable to this function: illegal function name

What are the rules for which statements can be created or redefined?

Note: this question was intentionally written by the author and author ( Answering Machine ), so idiomatic answers are usually asked by Kotlin's topics in SO.

Answer 1

Kotlin only allows overriding a particular set of statements, and you cannot change the list of available statements,

You must take care to redefine the operators that you are trying to stay in the spirit of the original operator, or other common uses of the mathematical symbol. But sometimes a typical character is not available. For example, setting Union ∪ can be easily done like + , because conceptually it makes sense, and this is already the built-in Set<T>.plus() operator already provided by Kotlin, or you can get creative and use the infix function for this case:

 // already provided by Kotlin: // operator fun <T> Set<T>.plus(elements: Iterable<T>): Set<T> // and now add my new one, lower case 'u' is pretty similar to math symbol ∪ infix fun <T> Set<T>.u(elements: Set<T>): Set<T> = this.plus(elements) // and therefore use any of... val union1 = setOf(1,2,5) u setOf(3,6) val union2 = setOf(1,2,5) + setOf(3,6) val union3 = setOf(1,2,5) plus setOf(3,6) 

Or maybe this is more clear:

 infix fun <T> Set<T>.union(elements: Set<T>): Set<T> = this.plus(elements) // and therefore val union4 = setOf(1,2,5) union setOf(3,6) 

And continuing our list of Set statements, the intersection is a ∩ symbol, so if every programmer has a font where the letter 'n' looks ∩ , we could get away with:

 infix fun <T> Set<T>.n(elements: Set<T>): Set<T> = this.intersect(elements) // and therefore... val intersect = setOf(1,3,5) n setOf(3,5) 

or using operator overload * as:

 operator fun <T> Set<T>.times(elements: Set<T>): Set<T> = this.intersect(elements) // and therefore... val intersect = setOf(1,3,5) * setOf(3,5) 

Although you can already use the existing standard library infix function intersect() as:

 val intersect = setOf(1,3,5) intersect setOf(3,5) 

In those cases when you invent something new, you need to choose the nearest operator or function name. For example, denying a set of enumerations, perhaps use the operator - ( unaryMinus() ) or the operator ! ( not() ):

 enum class Things { ONE, TWO, THREE, FOUR, FIVE } operator fun Set<Things>.unaryMinus() = Things.values().toSet().minus(this) operator fun Set<Things>.not() = Things.values().toSet().minus(this) // and therefore use any of... val current = setOf(Things.THREE, Things.FIVE) println(-current) // [ONE, TWO, FOUR] println(-(-current)) // [THREE, FIVE] println(!current) // [ONE, TWO, FOUR] println(!!current) // [THREE, FIVE] println(current.not()) // [ONE, TWO, FOUR] println(current.not().not()) // [THREE, FIVE] 

Be careful, as overloading the operator can be very useful, or it can lead to confusion and chaos. You must decide which is best while maintaining the readability of the code. Sometimes an operator is best suited if it matches the norm for that character, or replacing an infix that looks like the original character, or using a descriptive word so that there is no chance of confusion.

Always check the Kotlin Stdlib API Reference , because many of the statements you want can already be defined or have equivalent extension functions.

One more thing ...

And about your $$ statement, technically you can do it like:

 infix fun String.`$$`(other: String) = "$this !!whatever!! $other" 

But since you need to avoid the function name, it will be ugly to call:

 val text = "you should do" `$$` "you want" 

This is not an overload of the operating system and will only work if it is a function that infix can do .