PricingLoginStart free
Kotlin Academy · Lesson

Option and Nullable: When to Use Each

Compare Arrow's Option type with Kotlin nullable types and choose appropriately.

Lesson 3 of 413 steps

Option and Nullable: When to Use Each is a free Kotlin Academy lesson on CoddyKit. This is lesson 3 of 4. Any 3 lessons of this learning path are free to read in full — after that, CoddyKit PRO unlocks every lesson, plus hands-on practice with a built-in code editor and a 24/7 AI tutor. It is part of the Kotlin Academy learning path, and your progress syncs across the web and the CoddyKit app. The Kotlin Academy course includes 4 lessons in total.

Two Ways to Represent Absence

Kotlin has built-in nullable types (T?) that represent "a value or nothing." Arrow also provides Option — a sealed type with Some(value: A) and None. Both solve the same problem but fit different contexts.

Kotlin Nullable Types

Kotlin's T? is the idiomatic choice for absence in most Kotlin code. The compiler enforces null checks, the safe-call operator ?. chains calls gracefully, and ?: "default" provides fallbacks concisely:

val name: String? = findUser(id)?.name
val display = name ?: "Anonymous"

Arrow's Option<A>

Option wraps a nullable concept in a proper algebraic type with map, flatMap, filter, fold, and more. It integrates naturally with Arrow's functional pipeline style:

import arrow.core.Option
import arrow.core.Some
import arrow.core.None
import arrow.core.toOption

val opt: Option<String> = "hello".toOption()   // Some("hello")
val absent: Option<String> = None

Converting Between Option and Nullable

Convert freely: value?.toOption() wraps a nullable into Option; option.getOrNull() extracts the value or null; option.getOrElse { default } provides a fallback:

val opt: Option<String> = nullableString.toOption()
val back: String? = opt.getOrNull()

map and flatMap on Option

map { } transforms a Some value (returns None unchanged). flatMap { } chains operations that themselves return Option:

val length: Option<Int> = "hello".toOption().map { it.length }  // Some(5)
val noneLength: Option<Int> = (null as String?).toOption().map { it.length }  // None

filter on Option

filter { predicate } converts a Some to None if the predicate is false:

val positiveAge: Option<Int> = 25.toOption().filter { it > 0 }  // Some(25)
val rejectedAge:  Option<Int> = (-1).toOption().filter { it > 0 }  // None

fold: Consuming Option

fold(ifEmpty, ifSome) handles both cases in one expression without pattern matching:

val result: String = someOption.fold(
    ifEmpty = { "Nothing here" },
    ifSome  = { value -> "Got: $value" }
)

When to Prefer Nullable T?

Prefer Kotlin nullable (T?) when:

When to Prefer Option<A>

Prefer Option when:

Option Inside either { }

Inside Arrow's either { } block, you can call .bind() on an Option by first converting it to Either:

fun findUserOpt(id: Long): Option<User> = TODO()

fun getUser(id: Long): Either<UserError, User> = either {
    findUserOpt(id)
        .toEither { UserError.NotFound }
        .bind()
}

The Option Anti-Pattern

Do not use Option everywhere just because it exists. In Kotlin, String? is clearer than Option in most application code. Reserve Option for when its functional operators add genuine value.

Quick Check

What does None.map { it.length } return in Arrow's Option?

Answer it in the interactive lesson

Recap: Option and Nullable

Key takeaways:

Free to start

Learn Kotlin with an AI tutor — free

Write and run real code in your browser, get instant help from a 24/7 AI tutor, and pick up where you left off on the web or in the app.

Courses
51
Lessons
203
Start learning freeView the full course

Frequently Asked Questions

Is the “Option and Nullable: When to Use Each” lesson free?

Yes — any 3 lessons of the Kotlin Academy learning path, including “Option and Nullable: When to Use Each”, are free to read in full here on the web. After that, CoddyKit PRO unlocks every lesson, plus interactive practice with a built-in code editor and a 24/7 AI tutor. The Kotlin Academy course includes 4 lessons in total.

What will I learn in “Option and Nullable: When to Use Each”?

Compare Arrow's Option type with Kotlin nullable types and choose appropriately. You practise Kotlin Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Kotlin Academy?

No prior experience is required. Kotlin Academy on CoddyKit is structured for beginners through advanced learners, so you can start here or from the beginning and move at your own pace. This is lesson 3 of 4.

How long does the “Option and Nullable: When to Use Each” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Kotlin Academy lesson?

Yes. Every Kotlin Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

  1. Either : Typed Error Handling Without Exceptions
  2. Arrow Raise DSL: Composing Typed Errors
  3. Option and Nullable: When to Use Each
  4. Functional Domain Modeling with Arrow's Core Types
← Back to Kotlin Academy