Swift `if let` Equivalent in Kotlin: Safe Null Handling with `let`, `?.`, and `if`

By the end of this page, you will understand how Kotlin handles nullable values and how to write the Kotlin equivalent of Swift's if let. You will learn when to use a plain if null check, when to use ?.let { ... }, and how the Elvis operator ?: helps with fallback behavior.

Kotlin does not have Swift's exact if let syntax, but it solves the same problem through its null-safety system.

In Kotlin, a variable can be either:

• non-nullable: it must always hold a value
• nullable: it may hold a value or null

For example:

val name: String = "Ada"      // cannot be null
val nickname: String? = null   // can be null

This matters because Kotlin prevents many null-related runtime errors at compile time. If a value might be null, Kotlin forces you to handle that case explicitly.

Swift's if let means:

• check whether a value exists
• if it does, unwrap it into a non-null local variable
• otherwise, run the else branch

In Kotlin, the most direct equivalent is usually:

if (b.`val` != null) {
    val a = b.`val`
    // use a
} else {
    // handle null
}

Or more idiomatically:

b.`val`?.let { a ->
    // use a
} ?: run {
    
}

Think of a nullable value like a box that may or may not contain an item.

• Swift's if let says: "Open the box only if something is inside."
• Kotlin says the same thing in a few different ways:
  • if (box != null): first check whether the box is empty
  • box?.let { ... }: only perform the action if the box contains something
  • box ?: fallback: if the box is empty, use something else instead

So the core idea is not the exact syntax. The real idea is: handle missing values safely before using them.

1. Direct if null check

This is the clearest equivalent to Swift if let when you want both an if and an else.

val value = b.`val`

if (value != null) {
    val a = value
    println("Value exists: $a")
} else {
    println("Value is null")
}

Here:

• value may be null
• if (value != null) checks for that
• inside the if block, Kotlin knows value is non-null

2. Using ?.let

b.`val`?.let { a ->
    println("Value exists: $a")
}

This runs the block only if b.val is not null.

3. Using with an -style fallback

Consider this Kotlin example:

val input: String? = "hello"

input?.let { value ->
    println("Inside let: $value")
} ?: run {
    println("Input was null")
}

Step-by-step

1. input is declared as String?, so it may be null.
2. input?.let { ... } means:
   • if input is not null, call let
   • if input is null, skip the block
3. In this case, input is "hello", so the let block runs.
4. Inside the block, value is non-null and equals "hello".
5. The line println("Inside let: $value") prints:

Inside let: hello

1. Because the left side was not null, the ?: run { ... } part is not used.

API responses

A server may return an optional field:

val email: String? = response.email
email?.let {
    sendEmail(it)
} ?: run {
    log("No email address available")
}

Android UI updates

A screen may only show some data if it exists:

user.bio?.let {
    bioTextView.text = it
} ?: run {
    bioTextView.text = "No bio provided"
}

Parsing input

User input may be missing or invalid:

val ageText: String? = readLine()
if (ageText != null) {
    println("You entered: $ageText")
} else {
    println("No input provided")
}

Configuration values

Apps often use defaults when a setting is absent:

val host = config.host ?: "localhost"

Database fields

Nullable database columns are common:

record.middleName?.let {
    println("Middle name: $it")
}

In real Kotlin projects, developers choose different null-handling styles depending on intent.

1. Guard clauses

When a value is required, developers often return early:

fun process(user: User?) {
    val validUser = user ?: return
    println(validUser.name)
}

This avoids deep nesting.

2. Validation before work

fun register(email: String?) {
    if (email == null) {
        println("Email is required")
        return
    }

    println("Registering $email")
}

3. Run code only when data exists

sessionToken?.let {
    apiClient.authenticate(it)
}

This pattern is very common for optional values.

4. Default values with Elvis

val pageSize = request.pageSize ?: 20

5. Error handling with

1. Trying to use a nullable value directly

Broken code:

val name: String? = null
println(name.length)

Problem:

• name may be null, so Kotlin does not allow direct access to length

Fix:

println(name?.length)

or

if (name != null) {
    println(name.length)
}

2. Using let when a simple if is clearer

This works, but can be harder to read:

value?.let {
    println(it)
} ?: run {
    println("null")
}

Sometimes this is clearer:

if (value != null) {
    println(value)
} else {
    println("null")
}

Choose readability over cleverness.

3. Overusing

Quick reference

Nullable type

val name: String? = null

Check for null

if (name != null) {
    println(name)
} else {
    println("null")
}

Safe call

println(name?.length)

let

name?.let {
    println(it)
}

let with fallback

name?.let {
    println(it)
} ?: run {
    println("null")
}

Elvis operator

val displayName = name ?: "Guest"

Throw if missing

val id = inputId ?: throw IllegalArgumentException()

Is let the same as Swift if let in Kotlin?

Not exactly, but it solves a similar problem. ?.let { ... } runs code only when the value is not null.

What is the closest direct equivalent to Swift if let ... else in Kotlin?

Usually:

if (value != null) {
    // use value
} else {
    // null case
}

Should I use if or let in Kotlin for null checks?

Use if when you want clear branching. Use let when you want a concise action only for the non-null case.

What does ?: mean in Kotlin?

It is the Elvis operator. It provides a fallback when the value on the left is null.

Why does Kotlin use String??

The ? means the type is nullable. Without it, the variable cannot hold null.

• Null safety — The core Kotlin feature behind this question.
• Safe call operator (?.) — Lets you access or call something only if the value is not null.
• Elvis operator (?:) — Provides fallback values or fallback logic when null appears.
• Nullable types — Explains why some variables require explicit null handling.
• Scope functions (let, run, also, apply, with) — let is one of Kotlin's scope functions.
• Smart casts — Kotlin can treat a value as non-null after a successful null check.
• Guard clauses — A common pattern using ?: return or ?: throw.
• !! operator — Important to understand because it bypasses null safety and may crash.