plum

import std/Result
import std/Option
import std/Bool
import std/Number
import std/Str
import std/List

# `expr?` unwraps a `Result`'s `Ok` or an `Option`'s `Some`, or exits the
# enclosing function early with the `Err`/`None` value as-is otherwise — same
# idea as Rust's `?`. The enclosing function's own return type must accept
# whatever gets returned early; that isn't checked until codegen (see
# `plum-checker`'s `inferExpr` on `Expr::Try`), so a mismatch there still
# surfaces as a clear compile error, just a less precise one.
#
# `left ?: right` (elvis) is the plain-expression counterpart: same Ok/Some
# vs Err/None narrowing, but no early return — `right` is a fallback value,
# fully checked (unlike `?`) since there's no enclosing-return-type
# uncertainty to be permissive about.

fun parsePositive(s: Str) -> Result[Int, Str] =
  n := parseInt(s)?
  if n < 0
    return Err("negative")
  return Ok(n)

fun sumTwo(a: Str, b: Str) -> Result[Int, Str] =
  x := parsePositive(a)?
  y := parsePositive(b)?
  return Ok(x + y)

fun firstPositive(list: List[Int]) -> Option[Int] =
  match list.get(0)
    Some(v) =>
      if v > 0
        return Some(v)
      return None
    None =>
      return None

fun doubledFirstPositive(list: List[Int]) -> Option[Int] =
  a := firstPositive(list)?
  return Some(a * 2)

# `left ?: right` — same Ok/Some-vs-Err/None narrowing as `?`, but a plain
# expression (no early return): `right` is the fallback value, unified against
# the success field's type by the checker.

fun sumOrZero(a: Str, b: Str) -> Int =
  x := parsePositive(a) ?: 0
  y := parsePositive(b) ?: 0
  x + y

fun firstOrDefault(list: List[Int], default: Int) -> Int =
  list.get(0) ?: default

test "try operator unwraps Ok and propagates the value through two calls"
  r := sumTwo("2", "3")
  assert r.isOk()
  assert r.unwrap() == 5

test "try operator exits early with Err, skipping the rest of the function"
  r := sumTwo("2", "-3")
  assert r.isErr()
  assert r.unwrapErr() == "negative"

test "try operator unwraps Some and propagates the value"
  l := List(5)
  r := doubledFirstPositive(l)
  assert r.isSome()
  assert r.unwrap() == 10

test "try operator exits early with None, skipping the rest of the function"
  l := List[Int]()
  r := doubledFirstPositive(l)
  assert r.isNone()

test "elvis operator unwraps Ok and falls back to 0 on Err"
  assert sumOrZero("2", "3") == 5
  assert sumOrZero("2", "-3") == 2

test "elvis operator unwraps Some and falls back to the given default on None"
  assert firstOrDefault(List(5), 99) == 5
  assert firstOrDefault(List[Int](), 99) == 99