Difference between private top-level extension function and private extension function inside class

Question

We are currently switching our project to Kotlin, and ran across following question:

We need a certain extension function only inside a given class. Thus, we have two possibilities: (1) Declaring the extension function private on the file top-level or (2) declaring the extension function private inside the class.

Following a MCVE:

Top-level example (file C1.kt):

private fun String.double() = this.repeat(2)
class C1 {
    init {
        println("init".double())
    }
}

Inside class example (file C2.kt):

class C2 {
    private fun String.double() = this.repeat(2)
    init {
        println("init".double())
    }
}

Questions:

1. Is there any difference to those two approaches, except that in C1.kt the extension function String.double() would also be visible to other possible file members (such as further classes in the same file)?

2. Since we want to achieve code "as kotlinic as possible", we would like to know which of the two approaches is the suggested one. Is there an official suggestion / style guide on the example above? I think it is considered good practice to declare extension functions as close as possible to its intended use, thus in the above example the structure of C2 would be suggested?

Jesicajeske

Just as a curiosity: If you let IntelliJ create the extension function for you, it will be placed out of the class. I was not able to find a guideline or recommendation, so using the suggestion from IntelliJ, and if the extension does not require access to other private members, it probably make sense to define extension outside. – Quipster

Answer 1

1. Is there any difference to those two approaches, except that in C1.kt the extension function String.double() would also be visible to other possible file members (such as further classes in the same file)?

There is one difference: When specifying an extension function inside the class (in your example C2), then you additionally have access to the instance of this class with the qualified this syntax (in your example this@C2).

2. Since we want to achieve code "as kotlinic as possible", we would like to know which of the two approaches is the suggested one. Is there an official suggestion / style guide on the example above? I think it is considered good practice to declare extension functions as close as possible to its intended use, thus in the above example the structure of C2 would be suggested?

That's a good question. Personally, I would put the extension functions outside the class, since they (normally) specify behavior that is related to the extended type and not to the type of the class where they are used. However, if you do need class-related information within the extension function, I would then specify them inside the class.

Camarata