plum

import std/Option
import std/Result
import std/Bool
import std/Number
import std/Str
# `obj?.field` / `obj?.method(args)` — Groovy/Kotlin-style safe navigation.
# Reaches into a `Result`'s `Ok`/an `Option`'s `Some` without unwrapping it,
# mapping the field/method access over the inner value and re-wrapping the
# result; `Err`/`None` passes through untouched. Pure sugar for
# `obj.map(|v| v.field)` — desugared entirely in the parser (see
# `plum-core`'s `parseSafeAttribute`), so nothing past it needs to know this
# syntax exists.

enum Person =
  | Person(name: Str, age: Int)
  fun birthday(self) -> Int =
    self.age + 1

fun personName(p: Option[Person]) -> Option[Str] =
  p?.name

fun personBirthday(p: Option[Person]) -> Option[Int] =
  p?.birthday()

fun personNameResult(p: Result[Person, Str]) -> Result[Str, Str] =
  p?.name

fun somePerson() -> Option[Person] =
  Some(Person(name: "Ann", age: 3))

fun noPerson() -> Option[Person] =
  None

fun okPerson() -> Result[Person, Str] =
  Ok(Person(name: "Ann", age: 3))

fun errPerson() -> Result[Person, Str] =
  Err("missing")

test "safe navigation maps a field access over Some, passes None through unchanged"
  a := personName(somePerson())
  assert a.isSome()
  assert a.unwrap() == "Ann"
  b := personName(noPerson())
  assert b.isNone()

test "safe navigation maps a method call over Some"
  a := personBirthday(somePerson())
  assert a.isSome()
  assert a.unwrap() == 4

test "safe navigation maps a field access over Ok, passes Err through unchanged"
  a := personNameResult(okPerson())
  assert a.isOk()
  assert a.unwrap() == "Ann"
  b := personNameResult(errPerson())
  assert b.isErr()
  assert b.unwrapErr() == "missing"