A modern programming language that makes developers happier.

kotlinlang

Hey. Can I have an extension function that would handle `SomeClass&lt;X&gt;` and `SomeClass&lt;X?&gt;` 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 :slightly_smiling_face:

<https://discuss.kotlinlang.org/t/nulls-and-generics/2219/7>

does this work? `fun &lt;T: Any&gt; SomeClass&lt;T?&gt;.something()`

otherwise you can just go with `X` without upper bound

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 &lt;T: Any&gt; SomeClass&lt;T?&gt;.something(): SomeClass&lt;T or T?&gt;` depending on extended class

I’ll try to work around, it would add too much language complexity even if possible.

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&lt;X?&gt;()`

Please clarify, you want e.g. `SomeClass&lt;String&gt;` to yield `SomeClass&lt;String?&gt;` but `SomeClass&lt;Int&gt;` to yield `SomeClass&lt;Int&gt;`? Or what exactly do you want?

I have instances of a type of `SomeClass&lt;String&gt;` and `SomeClass&lt;String?&gt;` which I’d like to extend and the extension would accordingly return `SomeClass&lt;String&gt;` and `SomeClass&lt;String?&gt;`, 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 :stuck_out_tongue: What you want is this:
```
fun &lt;T&gt; SomeClass&lt;T&gt;.foo(): SomeClass&lt;T&gt;
```
If you call `foo` on a `SomeClass&lt;String&gt;` it will return `SomeClass&lt;String&gt;` and if you call it on `SomeClass&lt;String?&gt;` it will return `SomeClass&lt;String?&gt;`.

If you need the type to be constrained, you can do:
`fun &lt;T : String?&gt; SomeClass&lt;T&gt;.foo(): SomeClass&lt;T&gt;` - In this case only `String` or `String?` could be used for `T`.

let me try this one :slightly_smiling_face:

This one seems to work fine :slightly_smiling_face: