A modern programming language that makes developers happier.

kotlinlang

I’m curious,
Is there a difference between:
`class Container&lt;T&gt;(val value: T)`
and
`class Container&lt;T&gt;(val value: T?)` ?
(note the extra `?` after the `T`)?

so let’s say you pass in a `String?` to the first `Container` class’s constructor - you would get a `Container&lt;String?&gt;` back

if you passed in a `String?` to the second `Container`, you’d get back a `Container&lt;String&gt;` that just holds a nullable `String`

IMO that second definition is kinda sketch, I would call it out in a code review. If you want a `Container&lt;T&gt;` that can potentially hold either `T` or `T?`, I’d recommend being explicit about it, like so:

```
class Container&lt;T : Any&gt;(val value: T?)
```

Using second declaration you can create instance using:
```Container&lt;String&gt;(null)```
While this will not compile for first one.

The second one is suspect; i’m wondering if it has any valid usages…

For the seconds example `class Container&lt;T&gt;(val value: T?)`:
What is the type of `value` in `Container&lt;String?&gt;`?
What is its type in `Container&lt;String&gt;`?
Is there such a type as `String??` :slightly_smiling_face:

`String?` for both.
`String??` is the same as `String?`.

<@U74HWEPTP> That indeed works this way if you let the compiler infer type:
```
class Container1&lt;out T&gt;(val value: T)
class Container2&lt;out T&gt;(val value: T?)

fun main() {
    val s : String? = ""
    val x/*: Container1&lt;String?&gt;*/ = Container1(s)
    val y/*: Container2&lt;String&gt;*/ = Container2(s)

}
```
But you could still explicitly type `y` to a nullable one:
`val y: Container2&lt;String?&gt; = Container2(s)`
Is there any difference between the first `y` and the second `y`?

recalling from when a similar question was asked a while ago, I think the second `y` might break smartcasting

adapted from the last time:
```
class Wrapper&lt;R&gt;(private val instance: R? = null) {
    fun simpleName(): String {
        return if (instance != null) instance::class.simpleName ?: "default"
        else "default"
    }
}
```

it is admittedly a very contrived example, but this won’t compile

<https://kotlinlang.slack.com/archives/C0922A726/p1553018260894000?thread_ts=1553017628.889200>

But this only won’t compile when using `::class`… and it won’t compile for `class Wrapper&lt;R&gt;(private val instance: R)` either…

you’re not wrong, and this is really a better argument for bounding `R` in this case I suppose

:slightly_smiling_face:
Basically, `class Container&lt;T&gt;(val value: T?)` is valid Kotlin, but, please, don’t use it :slightly_smiling_face:

it might compile but I think you open yourself up to subtle type system-related bugs

maybe you could come up with a good kotlin puzzler for the next kotlinconf with this example :stuck_out_tongue:

I know this is quite stupid code, but nonetheless:
```class MyList&lt;T&gt;(
    val list: List&lt;T&gt;,
    val defaultValue: T? = null
) : List&lt;T&gt; by list {
    
    fun getOrDefault(index: Int): T?
    	= list.getOrElse(index) { defaultValue }
}```
So you want to allow creation of both `MyList&lt;String&gt;` and `MyList&lt;String?&gt;` while `defaultValue` should always be nullable.

Pretty valid example where your “feature” can be useful :slightly_smiling_face: