Optional / Nullable — кључни појмови и рад са nullable типовима

Шта су Optional и Nullable?

Optional у Swift и nullable у Kotlin — су језички алати који чине null експлицитним делом система типова. У Swift Optional је енум: Optional.none (nil) и Optional.some(Wrapped). У Kotlin nullable се означава суфиксом ? у типу: String? може бити стринг или null.

Оба приступа решавају фундаментални проблем који је Тони Хоар назвао „грешком вредном милијарду долара" — null reference. Пре појаве опционалних типова, свака референца је могла бити null, а провера је препуштена програмеру. Swift и Kotlin пребацују ову проверу у фазу компајлирања: код који игнорише null неће се компајлирати.

Упркос заједничком циљу, Swift и Kotlin имплементирају null-safety различито. Swift користи алгебарски тип Optional са комплетним pattern-matching. Kotlin уграђује nullable у систем типова на нивоу компајлера, без стварања посебног wrapper типа.

Историјски, null reference се појавио 1965. године у језику ALGOL W као начин представљања одсуства вредности. Током шест деценија, null је постао извор безбројних падова — према истраживању Тонија Хоара, од 30 до 50 посто грешака у продукцијском коду повезано је са NullPointerException. Swift са Optional и Kotlin са nullable типовима постали су први мејнстрим језици који су решили овај проблем на нивоу система типова, чинећи null експлицитним делом уговора функције.

Optional у Swift: синтакса и рад са опционалним типовима

У Swift Optional је пуноправни тип, декларисан као enum Optional<Wrapped>. Синтаксички шећер ? замењује пуни запис: Int? је еквивалентно Optional<Int>. Рад са Optional укључује неколико начина издвајања вредности.

If-let и guard-let везивање

if let — условно издвајање: ако Optional садржи вредност, она се везује за константу унутар блока. guard let — рани излаз из функције ако је Optional једнак nil. guard let чини код равним, избегавајући угнежђене if-let.

Optional chaining

Optional chaining (сигурни секвенцијални приступ) кроз ? омогућава позив метода или својства на Optional без експлицитног unwrapping-а. Ако је било која карика ланца nil, цео ланац враћа nil. Ово скраћује код при раду са хијерархијским подацима.

Nil-coalescing оператор

?? (nil-coalescing) — оператор који враћа вредност Optional ако није nil, у супротном — подразумевану вредност. Ово је кратка алтернатива за if-let за пружање резервне вредности.

var name: String? = "Alice"

// If-let везивање
if let unwrapped = name {
    print("Здраво, \(unwrapped)")
}

// Optional chaining
let count = name?.count

// Nil-coalescing
let display = name ?? "Гост"

// Map на Optional
let greeting = name.map { "Hello, \($0)" }

Nullable у Kotlin: безбедни позиви и елвис оператор

У Kotlin nullable је део система типова, а не посебан wrapper тип. Тип String? може садржати null, String (без знака питања) — никада. Компајлер прати nullable кроз smart cast и анотације.

Безбедан позив ?.

?. — оператор безбедног позива. Ако објекат није null, позива се метод или својство; ако је null — враћа се null без позива. Ово је аналогно optional chaining у Swift, али синтаксички краће.

Елвис оператор ?:

?: — Kotlin аналог nil-coalescing-а. Ако израз са леве стране није null, враћа се; у супротном — вредност са десне стране. Елвис оператор се често комбинује са раним излазом кроз return или throw.

Smart cast и !! оператор

Smart cast — Kotlin компајлер аутоматски претвара nullable у non-null након провере null у if или when. !! — принудни позив (force unwrap) који баца NullPointerException при null. Користите !! само када је null грешка.

val name: String? = "Alice"

// Безбедан позив
val length = name?.length

// Елвис оператор
val display = name ?: "Гост"

// Smart cast након провере
if (name != null) {
    println("Дужина: ${name.length}")
}

// Let са ламбдом
name?.let { println("Здраво, $it") }

// Force unwrap — само када сте сигурни
val forced = name!!

Optional и Nullable: кључне разлике приступа

Иако Swift и Kotlin решавају исти задатак, њихови приступи null-safety-ју се суштински разликују. Разумевање ових разлика је важно за програмере који раде на обе платформе.

Представљање у систему типова

Swift користи enum Optional — стандардни алгебарски тип. Kotlin уграђује nullable на нивоу система типова компајлера, без стварања wrapper објекта. Ово утиче на перформансе: Optional у Swift је објекат на хеапу, nullable у Kotlin је провера null без алокације.

Синтакса и изражајност

Kotlin синтакса је краћа захваљујући уграђеним операторима ?., ?:, !!. Swift захтева више експлицитне синтаксе: if let, guard let, map на Optional. Међутим, Swift пружа pattern-matching кроз switch, што Kotlin директно не подржава за nullable.

Обрасци null-safety у мобилном развоју

У мобилном развоју формирани су стандардни обрасци рада са опционалним типовима који смањују количину шаблонског кода и повећавају безбедност.

Map и flatMap на Optional

Swift и Kotlin подржавају map и flatMap за Optional и nullable. Ако вредност постоји — примењује се трансформација, ако је null — враћа се null. Ово елиминише угнежђене if-let провере.

Подразумеване вредности кроз елвис

Уместо if-let + else користите ?: или ?? са подразумеваном вредношћу. Ово чини код декларативним: „користи X, ако постоји, иначе Y" уместо процедуралне провере.

Nullable у Compose и SwiftUI

У Jetpack Compose и SwiftUI опционални типови управљају приказом: ако је стање null — скривамо компоненту, иначе приказујемо. Ово одговара принципу single source of truth.

data class UserState(
    val name: String?,
    val email: String?
)

// Smart cast у when са различитим варијантама
fun greeting(state: UserState): String = when {
    state.name != null && state.email != null ->
        "${state.name} (${state.email})"
    state.name != null -> state.name
    else -> "Гост"
}

// Compose: приказ по постојању
@Composable
fun UserProfile(name: String?) {
    name?.let {
        Text(text = it)
    } ?: Text(text = "Нема података")
}

За миграцију постојећег Java кода на Kotlin препоручује се коришћење анотација @Nullable и @NonNull из пакета androidx.annotation. Kotlin компајлер узима у обзир ове анотације при интеракцији са Java-ом, аутоматски чинећи одговарајуће типове nullable или non-null. Постепена миграција са експлицитним анотацијама је сигурнија од глобалног укључивања null-safety у пројекту.

Типичне грешке при раду са Optional и Nullable

Null-safety смањује број грешака, али их не елиминише у потпуности. Програмери често праве карактеристичне пропусте при раду са опционалним типовима.

• Force unwrap без гаранције — name! или name!! без сигурности да вредност није null доводи до пада у продукцији. Проверите null пре force unwrap-а.
• Претерано if-let — угнежђени if-let за три или више Optional ствара пирамиду (pyramid of doom). Користите guard let или flatMap.
• Игнорисање nil-coalescing — експлицитна провера кроз if-let са else блоком замењује се ?? или ?:, што скраћује код и побољшава читљивост.
• Nullable у јавним API-јима — ако функција прихвата nullable, сваки позив захтева проверу. Преферирајте non-null са подразумеваном вредношћу или overload.