Here's an example from Delegated properties documentation.

import kotlin.reflect.KProperty

class Delegate {
    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
        return "$thisRef, thank you for delegating '${property.name}' to me!"
    }

    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
        println("$value has been assigned to '${property.name}' in $thisRef.")
    }
}

CodePudding user response：

This is because delegated properties are defined by convention. What this means is:

[its] semantics are defined through syntactic expansion of one syntax form into another syntax form.

You can see the expansion of a delegated property further down the documentation page:

class C {
    var prop: Type by MyDelegate()
}

// this code is generated by the compiler instead:
class C {
    private val prop$delegate = MyDelegate()
    var prop: Type
        get() = prop$delegate.getValue(this, this::prop)
        set(value: Type) = prop$delegate.setValue(this, this::prop, value)
}

And one of the characteristics of a syntax that is defined by convention, is that (from the first link):

All call expressions that are produced by expansion are only allowed to use operator functions.

and also:

This expansion of a particular syntax form to a different piece of code is usually defined in the terms of operator functions.

Just to give you more examples, the first link shows more examples of syntaxes that are defined by convention. Here are the corresponding operator functions related to them:

Notice that you need to put the word operator on all of those functions for the corresponding syntax to work. In other words, "operator" signifies that this function can be used in a syntax defined by convention.

CodePudding user response：

I'm not sure if I understand your question correctly, but we add operator to mark functions as not just regular functions, but functions designated to provide some specific functionality. This is not really limited to delegated properties - it is the same for all operators.

I think marking as operators have at least two benefits. First, it is explicit to the reader that the function can be used with some language feature. Second, it helps to avoid situations when we intended to provide some operator, but we made a mistake e.g. in parameter types, so it is silently ignored. operator immediately tells us whether the function signature is correct or not.