Kotlin - Function's Invoke Operator Overloading - operator-overloading

Question

I am currently studying Kotlin - Operator Overloading
I am trying to understand (with an example) how does operator overloading work for a function's invoke() function
The pre-test
Kotlin's Extension Functions
fun exampleOfExtensionFunction() {
fun Int.randomize(): Int {
return Random(this.toLong()).nextInt()
}
val randomizedFive = 5.randomize()
println("$randomizedFive")
}
Prints :
-1157408321
In Kotlin, functions can be declared as variables with types
fun exampleOfFunctionType() {
val printNumber: (number: Int) -> Unit
printNumber = { number ->
println("[$number = ${number.toString(16).toUpperCase()} = ${number.toString(2)}]")
}
printNumber(1023)
}
Prints :
[1023 = 3FF = 1111111111]
Kotlin allows operator overloading with both extension and member functions
fun exampleOfOperatorOverloadingUsingExtensionFunction() {
class MyType() {
val strings: ArrayList<String> = ArrayList<String>()
override fun toString(): String {
val joiner: StringJoiner = StringJoiner(" , ", "{ ", " }")
for (string in strings) {
joiner.add("\"$string\"")
}
return joiner.toString()
}
}
operator fun MyType.contains(stringToCheck: String): Boolean {
for (stringElement in strings) {
if (stringElement == stringToCheck) return true
}
return false
}
val myType = MyType()
myType.strings.add("one")
myType.strings.add("two")
myType.strings.add("three")
println("$myType")
println("(myType.contains(\"four\")) = ${myType.contains("four")} , (\"three\" in myType) = ${"three" in myType}")
}
Prints :
{ "one" , "two" , "three" }
(myType.contains("four")) = false , ("three" in myType) = true
Test Attempt
Based on the above. I tried to create an example of a function's invoke() operator overloading using the type (Boolean, Boolean, Boolean) -> Boolean as a receiver type for an extension function invoke(flag1: Boolean, flag2: Boolean, flag3: Boolean). This however did not work as expected.
fun attemptFunctionInvokeOperatorOverloading() {
operator fun ((Boolean, Boolean, Boolean) -> Boolean).invoke(flag1: Boolean, flag2: Boolean, flag3: Boolean): Boolean {
println("Overloaded invoke operator")
return flag1 && flag2 && flag3
}
var func1: ((Boolean, Boolean, Boolean) -> Boolean) = { flag1, flag2, flag3 ->
println("func1 body")
flag1 && flag2 && flag3
}
fun func2(flag1: Boolean, flag2: Boolean, flag3: Boolean): Boolean {
println("func2 body")
return flag1 && flag2 && flag3
}
func1(true, true, false)
func2(true, true, true)
}
Prints :
func1 body
func2 body
Expected :
Overloaded invoke operator
Overloaded invoke operator
Another question :
What exactly is this? (If it isn't operator overloading)
operator fun ((Boolean, Boolean, Boolean) -> Boolean).invoke(flag1: Boolean, flag2: Boolean, flag3: Boolean): Boolean {
println("Overloaded invoke operator")
return flag1 && flag2 && flag3
}

Answer 1

As said in another answer, invoke is defined on the function object itself, so you can't override it with an extension method.
I think the deeper problem here, though, is a slight misunderstanding of the purpose of this feature. Let's look at plus for the + operator instead.
I think you'll agree that attempting to define operator fun Int.plus(b: Int): Int { /* ... */} makes no sense, because overriding the default + operator for ints is a pretty dangerous thing to do, yes?
However, if you define a complex number class:
data class Complex(real: Double, img: Double)
Then it's perfectly reasonable to define this to sum complex numbers:
operator fun Complex.plus(other: Complex): Complex {
val real = this.real + other.real
val img = this.img + other.img
return Complex(real, img)
}
So, same thing with invoke and (): The meaning of () is that it's whatever is analogous to invoking a function for your type, and overriding invoke on something that's already a function is just asking for trouble. What you want to use it for instead is to provide function-like syntax for your own objects.
For example, imagine you define an interface like so:
interface MyCallback {
fun call(ctx: MyContext)
}
Which you use the usual way:
callback.call(ctx)
But with an implementation of the invoke operator overload, you get to use it as a function:
operator fun MyCallback.invoke(ctx: Context) = this.call(ctx)
/* Elsewhere... */
callback(ctx)
Hope that clarifies how you use invoke/()

Answer 2

Your issue has to to with resolution precedence. According to the Kotlin docs:
If a class has a member function, and an extension function is defined which has the same receiver type, the same name and is applicable to given arguments, the member always wins.
So your operator fun ((Boolean, Boolean, Boolean) -> Boolean).invoke(...) extension function is never called because the member invoke takes precedence.
Another Answer
It is indeed operator overloading, but through an extension. Again, since (Boolean, Boolean, Boolean) -> Boolean already has a fun invoke(Boolean, Boolean, Boolean): Boolean defined, your extension loses.