i dont want to make the `instance` nullable, i jus...

# announcements

[poohbar]

i dont want to make the instance nullable, i just want simpleName to return "" in that case.. but even wrapping it in if (instance != null) does not help

[Shawn]

try bounding R as Any -

class Wrapper<R : Any>(private val instance: R? = null)

[poohbar]

hmm.. that helped.. that is very interesting..

if i dont specify a bound its Any? by default?

[Shawn]

yep

[streetsofboston]

But instance is a R?, it still can be null…

[poohbar]

i guess i am confused as to what R? exactly does..

[poohbar]

yup, Anton, it wont compile with just that one change

[poohbar]

but it will let you do an null check and smart cast it

[poohbar]

it will also let you do !!

[Shawn]

So there’s a subtle thing you gotta take into account here as far as the parameterization of the class goes

[streetsofboston]

class Wrapper<R : Any>(private val instance: R? = null){
    fun simpleName() = instance?.let { it::class.simpleName }  // no more error on this line
}

[Shawn]

Without <R : Any>, it’s possible to have a valid wrapper of both Wrapper<Foo> and Wrapper<Foo?>

[Shawn]

@streetsofboston
fun simpleName() = if (instance != null) instance::class.simpleName else ""
seems to work just fine

[streetsofboston]

That’s true…it’s a val, not a `var`…

[Shawn]

A wrapper that can hold a Foo but actually holds null is perfectly valid - it’s kinda how Optional works

[poohbar]

i see that nullable types bring some new complexity into generics

[Shawn]

yep

[streetsofboston]

If you want to prevent null values for instance do class Wrapper<R : Any>(private val instance: R)

[Shawn]

No, but, sometimes you do want null values

[poohbar]

yup. in my case i do want instance to be sometimes null

[Shawn]

In this case I think @poohbar wants this Wrapper to be able to hold null in certain cases, but you don’t want the type to be Wrapper<Foo?>, you want it to be Wrapper<Foo>, much like Optional<Foo> if you’ve used that at all in Java-land

[Shawn]

smart-casting breaks because if R itself is a nullable type, then there is no way to safely dereference it

[streetsofboston]

Then, what @Shawn suggested is the best way to go: class Wrapper<R : Any>(private val instance: R? = null)

[poohbar]

yup.. i must admit that I still find it a bit confusing that an Optional<Foo> can hold null 🤔

[poohbar]

i guess it's ok though.. since the accessor method clearly returns Foo?

[poohbar]

makes sense..

[poohbar]

thanks guys 🙂

[streetsofboston]

It’s a bit weird: Take this:

class Wrapper<R>(private val instance: R?){
    fun simpleName() = instance?.let { it::class.simpleName }  // error on this line
}

The it:: has an error about it being a nullable type. Event though instance?.let { } was called with a .? operator, it is still nullable. It almost looks like instance is R??

[Shawn]

R?? isn’t a bad way of putting it actually

[Shawn]

Optional<R> is essentially the only way Java can really express the notion of R | null or a union of those two types

[Shawn]

if you allowed R itself to be nullable you’d have some kind of weird Union[Union[R, null], null]

[streetsofboston]

Alas, it isn’t R??, it is actually R?????????????????????????????????? ....
This still has a nullability error in the compiler: fun simpleName() = instance?.let { it?.let { it::class.simpleName } }

[Shawn]

which I don’t think the Kotlin type system handles well