Hey. Can I have an extension function that would handle

SomeClass<X>

and

SomeClass<X?>

at once?

Nullable generics hmm.. i vaguely remember something there.. i will play around with it

I don’t like it as a permanent solution but for the safe of my refactoring it would help to to deduplicate a lot of code 🙂

does this work?

fun <T: Any> SomeClass<T?>.something()

do you need

?

explicitly?

It’s

SomeClass

why handle `T?`not the extension method.

i think you can go either way, not sure if that changes how it works, i would keep it seperated personally as a matter of taste.. type is one thing and the fact it could be nullable another

The issue is that I need something like

un <T: Any> SomeClass<T?>.something(): SomeClass<T or T?>

depending on extended class

and in case you want to use nonullable T in the function body like

value: T = argument ?: throw IllegalStateException()

might be possible (i don't think i ever tried though .. or i do not remember)

you need extension like that ?

SomeClass.myExtension<X?>()

Please clarify, you want e.g.

SomeClass<String>

to yield

SomeClass<String?>

but

SomeClass<Int>

to yield

SomeClass<Int>

? Or what exactly do you want?

I have instances of a type of

SomeClass<String>

and

SomeClass<String?>

which I’d like to extend and the extension would accordingly return

SomeClass<String>

and

SomeClass<String?>

, depending on the extended type. I’m wondering if I can have just one extension in which internally I would handle potential nullability.

"extended type" is very confusing in this context 😛 What you want is this:

fun <T> SomeClass<T>.foo(): SomeClass<T>

If you call

foo

on a

SomeClass<String>

it will return

SomeClass<String>

and if you call it on

SomeClass<String?>

it will return

SomeClass<String?>

.

let me try this one 🙂