Is it possible to create a static extension functi...

# announcements

[locke]

Is it possible to create a static extension function to a Java class? It doesn't have a Companion to attach it to, but the non-static version is genericized?

[Shawn]

Extension functions are all static, and yes, you can write extension functions for Java classes

[locke]

Then what would the signature be?

fun <Class>.<function>(<arguments>) yields a request for a type argument from the compiler and, <Class>.Companion.<function>(<arguments>) yields an unresolved reference.

[Shawn]

I think I might’ve misunderstood what you meant, but let’s tackle the syntax first

[Shawn]

fun JavaClass.function(args) { } should work just fine - where do the type arguments come into play?

[Shawn]

Also, technically you can define a generic extension function like this

fun <T> T.function(args) { }

[locke]

The fact that JavaClass is genericized, and so the compiler requests a type argument, i.e. it's scoping that function to only JavaClass<T>.

I am trying to get it to work with just JavaClass.function... without needing to give it a type argument.

[Shawn]

Ah, I see what you mean now

[Shawn]

Should just be able to use star projection here if the type isn’t relevant

[Shawn]

fun JavaClass<*>.function()

[locke]

I am currently trying -- using that is losing access to static operators.

For context, I'm trying to add a composite function to Observable in RxJava. It's using both fromIterable and interval that are static on Observable. I guess since they're static I can just use Observable.fromIterable instead of this.fromIterable but that certainly feels like a code smell

[Shawn]

why is that a code smell? Calling static methods by way of an instance is the code smell

[locke]

In my brain this should refer to the Companion in this context and thus those methods should be available in scope without needing to define it. I.e. just calling fromIterable which is implicitly this.fromIterable

[locke]

But I guess that's not how it works

[locke]

Though interestingly this method doesn't actually work, it seems? Observable.function doesn't expose this extension.

[Shawn]

expose in what sense?

[locke]

You can't call it in client code. Observable.function doesn't actually reference the Observable<*>.function declaration. I'm sure if I had an instance of Observable I would have access, but that's not the goal.

[Shawn]

Are you trying to call extension methods from Java?

[karelpeeters]

@Shawn I may be misunderstanding but I think you missed that he wants static extension functions.

[Shawn]

Ahh, as though they were defined as a static method within the class body

[locke]

@Shawn, no I'm calling them from Kotlin. The goal is to be able to write an extension function such that I can in Kotlin declare:

Observable.myFunction(<arguments>)

[locke]

Yes, exactly

[Shawn]

that was my bad

[locke]

All good, technical problems are hard to communicate 🙂

[locke]

Is this even possible? I am not sure it is

[Shawn]

Unfortunately I don’t think it is 😕

[karelpeeters]

No, same for Kotlin classes that don't define a companion themselves.

[locke]

That's unfortunate. Oh well, thanks guys!

[gildor]

Please vote for this feature and share your use cases
https://youtrack.jetbrains.com/issue/KT-11968