Hey guys I'm checking if mutli global variables are not null before calling a function like that ```...

# kotlin-native

[Raed Ghazal]

Hey guys I'm checking if mutli global variables are not null before calling a function like that

varX?.let { varX ->
    varY?.let { varY ->
        foo(varX, varY)
    }
}

is there a better way to have this null safe and thread safe but in a cleaner look?

[Raed Ghazal]

something like

(varX, varY)?.let { varX, varY ->
    foo(varX, varY)
}

[Eryk Lepszy]

Why not just use a basic if check for that?

if (varX != null && varY != null) {
    foo(varX, varY)
}

[Tijl]

he specifically mentioned they are global, so you’d have to take them into a local scope first (which let also does for you)

[Raed Ghazal]

@Eryk Lepszy this is not thread safe

[Eryk Lepszy]

You're right, I missed that, sorry

[Tijl]

@Raed Ghazal you can make an inline function that does this, I think I used the one in this answer some time:

https://stackoverflow.com/a/35522422/2338613

no stdlib way I am aware of, let me know if you found one though

[Raed Ghazal]

@Tijl Okay nice!

[Raed Ghazal]

thats why I love kotlin
will use this approach

[Raed Ghazal]

thank you

[Raed Ghazal]

You're right, I missed that, sorry

@Eryk Lepszy no worries, thanks for trying 😄

[natario1]

I find this simpler to read:

val x = x ?: return
val y = y ?: return
foo(x, y)

[Raed Ghazal]

also nice but you don't always want to call return and end the function

[CLOVIS]

varX?.to(varY)
  ?.takeIf { varY != null }
  ?.let { (varX, varY) -> foo(varX, varY) }

It's ugly though.

[Raed Ghazal]

staying with my original approach is much better man @CLOVIS 😂

[y9san9]

the best approach for me is

run {
    val x = x ?: return@run
    val y = y ?: return@run
    foo(x, y)
}

[CLOVIS]

@y9san9 actually you don't need the variable shadowing:

run {
  foo(x ?: return@run, y ?: return@run
}

That might be the shortest/cleanest way.

[y9san9]

lol yes it is