How to pass a non-nullable type to a function with a nullable parameter?

Question

A nullable type can be checked and cast to a non-nullable type, but the other way around is quite difficult.

For example:

str1: String? = ""
// if str1 not null
str2: String = str1

str3: String? = str2 // This works!

In my case I'm talking about a function with an Array parameter in which the contents could be null, but the contents of the Array I want to pass to the function is non-nullable. That does not work:

var var1: Array<String?> = arrayOfNulls(10)

var var2: Array<String> = var1.filterNotNull().toTypedArray()

var var3: Array<String?> = var2 // This does not work!

My question is how to make this work?

I am able to cast the array to a nullable array, but I'm not sure if this is the correct way of doing this.

In Kotlin type system `String` is a subtype of `String?`, so it should work fine. See https://pl.kotl.in/gnaZrD9Xm — Михаил Нафталь, Oct 21 '21 at 09:05
But Array does not seem to be a subtype of Array. That's the problem. — sd_master92, Oct 21 '21 at 09:07
@letsstartcoding I updated my question, the actual case is now added. — sd_master92, Oct 21 '21 at 09:26
@sd_master92 Yes, generics in Kotlin are _invariant_ by default. If you declared a function with an `Array` argument, then it will accept only `Array` (it could have accepted subtypes of `Array` if there were any, but the generic argument should remain same - `String`). If you want it to accept both `Array` and `Array` arguments you need to define it as _contravariant_ (`Array`) or _covariant_ (`Array`). See https://kotlinlang.org/docs/generics.html#variance — Михаил Нафталь, Oct 21 '21 at 09:36

score 2 · Accepted Answer · answered Oct 21 '21 at 09:31

In Kotlin, arrays are invariant, which means that an array of a given type can't be assigned to an array of its parent type. That's why you can't assign Array<String> to Array<String?>, even if String is a subclass of String?. For this to work, you should either

use lists, which are covariant:

var var1: Array<String?> = arrayOfNulls(10)
var var2: List<String> = var1.filterNotNull()
var var3: List<String?> = var2  // Now works

cast the array to a nullable array, as you're doing:

var var1: Array<String?> = arrayOfNulls(10)
var var2: Array<String> = var1.filterNotNull().toTypedArray()
var var3: Array<String?> = var2 as Array<String?>  // Now works

score 0 · Answer 2 · answered Oct 21 '21 at 08:32

0

var str1: String? = ""

// if str1 not null
var str2: String = str1 ?: ""

var str3: String? = str2

Try This, Here ?: stands for checking if a value is null or not, if not null its fine, but if it gets null you can set a default value in it, that why i used a default value "" in it.

answered Oct 21 '21 at 08:32

Emon Hossain Munna

707
9
27

Hi thanks for your answer. But I think you understood my question wrong. I'm talking about the 3rd step which is not working out. (str3: String? = str2) – sd_master92 Oct 21 '21 at 08:39

lets start coding · Answer 3 · 2021-10-21T09:38:03.310

what I can say is,

//This value can hold null values 
str1: String? = ""

// if str1 not null, store values in str2
// so, now str2 holds NOT NULL VALUES
str2: String = str1

// Now by default since str2 is NOT NULL
// All the values being passed inside str2 will always be NOT NULL
// 
str3: String? = str2 // This does not work

str3 will only throw an error in case str2 is null but it is not possible since as you said, it goes through a null check.

the workaround looks something like this.

This is one possible solution, i.e. defining str2 as a Nullable string

str1 : String? = ""

str2 : String? = str1

str3 : String? = str2

Another solution would be, putting null check at str2, because since str2 is not null str3 will by default be Not Null.

str1 : String? = ""

str2 : String = str1 ?: ""

str3 : String = str2

Update

As per the updated question,

// A list of nulls
var var1: List<String?> = listOf(null, null, null, null, null, null, null, null, null, null)

//Mutable List to hold not null values or filter out null values
var var2: MutableList<String> = mutableListOf()
for (i in var1) var2.add(i ?: "")

//var3 will always be not null
var var3: List<String?> = var2

score 0 · Answer 4 · answered Oct 25 '21 at 10:51

No answer actually seems to explain at the moment why arrays are invariant (and so Array<String> is not a subtype of Array<String?>). If

var var2: Array<String> = var1.filterNotNull().toTypedArray()

var var3: Array<String?> = var2 // This does not work!

worked, then you could do

var3[0] = null
val x: String = var2[0]

Because var3 and var2 refer to the same object, this puts null into an Array<String> and then retrieves it as a non-nullable String. This obviously breaks null-safety.

It's better to only "cast the array to a nullable array, as you're doing" if you are sure your code can never do this.

How to pass a non-nullable type to a function with a nullable parameter?

4 Answers4