💎 Rust Unwrapping & Functional Rosetta Stone

Sugih Jamin in conversation with Gemini
February 23rd, 2026

I. Unwrapping & Fallbacks

Works for both Option<T> and Result<T, E> except where marked.

Rust Operator	Swift Equivalent	Kotlin Equivalent	Logic / Behavior
`.unwrap()`	`!` (Force unwrap)	`!!`	Panic if `None`/`Err`.
`.expect(msg)`	`fatalError(msg)`	`error(msg)`	Panic with custom message if `None`/`Err`.
`.unwrap_unchecked()`	`T!` (implicit unwrap)	`lateinit`	UB (Undefined Behavior). Only in `unsafe` blocks.
`.unwrap_or(alt)`	`?? alt`	`?: alt`	Eager fallback (evaluates `alt` immediately).
`.unwrap_or_default()`	`?? .init()`	`?: T()`	Fallback to `Default::default()` (e.g., `0`, `""`).
`.unwrap_or_else(\\|\\| {..})`	`?? {..}()`	`?: run {..}`	Lazy fallback (closure runs only if `None`/`Err`).

II. Transformation (Scope Functions)

Rust Operator	Swift Equivalent	Kotlin Equivalent	Logic / Behavior
`.map({..})`	`.map {..}`	`.let {..}`	Transforms the Ok/Some part; returns wrapped result.
`-R .map_err({..})`	N/A	N/A	Transforms the Err part only; useful for error normalization.
`.as_ref().map()`	N/A	N/A	Converts `Option<T>` to `Option<&T>` so `.map` borrows `T`.
`.map_or(alt, {..})`	N/A	N/A	Eager `alt` fallback + `.map` transformation.
`.map_or_else(\\|\\|, \\|\\|)`	N/A	N/A	Lazy fallback + `.map` transformation.

III. Chaining & Logic (Non-Unwrapping)

Rust Operator	Swift Equivalent	Kotlin Equivalent	Logic / Behavior
`.and(alt)`	N/A	N/A	Returns `alt` if `self` is Some/Ok, else returns `self`.
`.and_then({Some(v)})`	`.flatMap {..}`	`?.let {..}`	FlatMap: Prevents nesting (avoids `Option<Option<T>>`).
`.or(alt)`	N/A	N/A	Returns `alt` if `self` is None/Err, else returns `self`.
`.or_else(\\|\\| {..})`	N/A	N/A	Lazy `.or`; runs closure on the `Err`/`None` part.

IV. Type Conversion (O ↔ R)

Rust Operator	Logic / Behavior
`-R .ok()`	Result → Option: `Ok(v)` becomes `Some(v)`, `Err` becomes `None`.
`-O .ok_or(err)`	Option → Result: `Some(v)` becomes `Ok(v)`, `None` becomes `Err(err)`.
`-O .ok_or_else(\\|\\|)`	Lazy Option → Result: Computes `Err` from closure only if `None`.

V. Early Returns (The `?` Operator)

Analogous to guard let (Swift) or ?: return (Kotlin).

? (Question Mark): Early returns the “Error” variant (None or Err) to the caller. If successful, it unwraps the value.
-R .map_err().ok()?: If Err, normalize error type, convert to None, and early return None. If Ok(v), results in unwrapped v.
-O .ok_or_else({..})?: If None, compute error, convert to Err, and early return Err. If Some(v), results in unwrapped v.

Note on Kotlin: Since Kotlin uses T? (nullable types) rather than a formal Option enum, many “chaining” methods like and_then are achieved via the safe-call operator (?.) combined with .let { }.

Own notes:

Unwrapping operators: work with both Option and Result unless marked

.unwrap == force unwrap
- .expect(message): panic with message if null, otherwise same as .unwrap
- .unwrap_unchecked: implicit unwrap, may return garbage–only inside unsafe block!
.unwrap_or(alt) == null coalescing, eager evaluation of provided alt
- .unwrap_or_default: null coalescing, but if None, returns Default of T of the Some(T), e.g., Default of u32 is 0. T must have the Default trait.
- .unwrap_or_else({}): null coalescing but instead of fix-valued alt, alt computed from lambda, evaluated lazily
.map({}) == .let{} scope function == if-let{} value binding -R .map_err({}) == let scope function on the Err part of Result type, useful to convert error type to expected error type, e.g., when there are multiple error type variants
- .as_ref().map(): converts Option to Option<&T>, to force .map() to borrow T
.map_or(alt, {}) == .unwrap_or(alt) if Err, .map({}) if Ok, lambda evaluated eagerly
- .map_or_else({}, {}) == .map_or but alt for Err computed from first lambda, both lambdas evaluated lazily
.and(alt) returns alt if self is Some/Ok, else returns None/Err part of self; not unwrapped
- .and_then({Some(v)}) == ?.run({Some(v)})–but no async lambda
- doesn’t convert R to/from O
.or(alt) returns alt if self is None/Err, else returns Some/Ok part of self; not unwrapped
- .or_else({}) == .run scope function if Err/None, on the Err part, no async lambda
- doesn’t convert R to/from O -R .ok() converts Ok(v) to Some(v), Err to None -O .ok_or(err) converts Some(v) to Ok(v) and None to Err(err) -O .ok_or_else({}) converts None to Err({}) instead
? (== old style try! macro) = guard-let-else with early return, returning None if Option, Err if Result -R use with .map_err() to normalize multiple Error types in Result -R .map_err().ok()? if Err, early return None, else unwrap Ok(v) (after converting to Some(v), but irrelevant) -O .ok_or_else({})? if None, early return Err({}), else unwrap Some(v) (after converting to Ok(v), but irrelevant)