plum

module std

import std/Option

import std/Str

import std/Bool

import std/Number

# Result[T, E] represents either success (`Ok`, carrying a `T`) or failure

# (`Err`, carrying an `E`) — used throughout std for fallible operations

# (`Bool.parse`, `Int.fromStr`, `Float.fromStr`).

#

# `andThen` (which would need `cb`'s return type's `T` to be found NESTED

# inside another `Result[U, E]`, not `cb`'s own bare return type) is

# intentionally not implemented here — same method-level-generics gap

# documented on `Option.andThen` in `libs/std/option.plum`. `map`/`mapErr`

# don't have that problem (`cb`'s return type IS directly the new generic

# param, same shape as `List.map`), so those ARE implemented below.

enum Result[T, E] =

  | Ok(T)

  | Err(E)

  fun isOk(self) -> Bool =

    match self

      Ok(_) => True

      Err(_) => False

  fun isErr(self) -> Bool =

    match self

      Ok(_) => False

      Err(_) => True

  # Returns the wrapped success value, or traps if `self` is `Err`.

  fun unwrap(self) -> T =

    match self

      Ok(v) =>

        return v

      Err(_) =>

        todo

  # Returns the wrapped error value, or traps if `self` is `Ok`.

  fun unwrapErr(self) -> E =

    match self

      Ok(_) =>

        todo

      Err(e) =>

        return e

  # Returns the wrapped success value, or traps if `self` is `Err`. `msg`

  # documents the expectation at the call site (matching Rust's

  # `Result::expect`) but isn't surfaced anywhere at runtime — see the

  # identical note on `Option.expect`.

  fun expect(self, msg: Str) -> T =

    match self

      Ok(v) =>

        return v

      Err(_) =>

        todo

  fun expectErr(self, msg: Str) -> E =

    match self

      Ok(_) =>

        todo

      Err(e) =>

        return e

  fun unwrapOr(self, default: T) -> T =

    match self

      Ok(v) =>

        return v

      Err(_) =>

        return default

  # Like `unwrapOr`, but the fallback is computed lazily from the error via

  # `cb` (only when `self` is `Err`).

  fun unwrapOrElse(self, cb: fn(E) -> T) -> T =

    match self

      Ok(v) =>

        return v

      Err(e) =>

        return cb(e)

  # Discards the error, keeping only the success value (if any).

  fun ok(self) -> Option[T] =

    match self

      Ok(v) =>

        return Some(v)

      Err(_) =>

        return None

  # Discards the success value, keeping only the error (if any).

  fun err(self) -> Option[E] =

    match self

      Ok(_) =>

        return None

      Err(e) =>

        return Some(e)

  # Transforms the success value with `cb`, leaving `Err` untouched. `U` is

  # `map`'s OWN generic param, separate from `Result[T, E]`'s own `T`/`E` —

  # resolved per CALL SITE, same mechanism as `List.map`/`Option.map`.

  fun map(self, cb: fn(T) -> U) -> Result[U, E] =

    match self

      Ok(v) =>

        return Ok(cb(v))

      Err(e) =>

        return Err(e)

  # Transforms the error value with `cb`, leaving `Ok` untouched. `F` is

  # `mapErr`'s OWN generic param, separate from `Result[T, E]`'s own `T`/`E`.

  fun mapErr(self, cb: fn(E) -> F) -> Result[T, F] =

    match self

      Ok(v) =>

        return Ok(v)

      Err(e) =>

        return Err(cb(e))

  # No implicit `toStr(self) -> Str` — see the identical note on

  # `Option.toOptionStr` in `libs/std/option.plum`: a method that assumes

  # `T`/`E: ToStr` gets compiled for EVERY specialization of `Result`

  # anywhere in the program (there's no lazy/on-demand method compilation),

  # so an implicit bound like this can break an unrelated specialization

  # whose payload doesn't support it. Explicit stringifier callbacks instead.

  fun toResultStr(self, okToStr: fn(T) -> Str, errToStr: fn(E) -> Str) -> Str =

    match self

      Ok(v) =>

        return "Ok({okToStr(v)})"

      Err(e) =>

        return "Err({errToStr(e)})"

fun makeOkForResultTest() -> Result[Int, Str] =

  return Ok(5)

fun makeErrForResultTest() -> Result[Int, Str] =

  return Err("bad")

test "map transforms an Ok value and leaves Err untouched"

  assert makeOkForResultTest().map(|v| v * 2).unwrap() == 10

  assert makeErrForResultTest().map(|v| v * 2).isErr() == True

test "mapErr transforms an Err value and leaves Ok untouched"

  assert makeErrForResultTest().mapErr(|e| e + "!").unwrapErr() == "bad!"

  assert makeOkForResultTest().mapErr(|e| e + "!").unwrap() == 5