Introducing a Result<ok, err> type

[rvcas]

No reference to error below means the keyword/plutus error. This would all be done via code gen.

The idea

We've been talking about introducing a new type defined as:

pub type Result<ok, err> {
  Ok(ok),
  Err(err),
}

and also:

pub type Either<left, right> = Result<right, left>

Mostly for convenience to people coming from other functional languages.

From there we can perhaps do a few extra things.

Maybe validators now return Result<Void, Error>

fn spend(datum, redeemer, ctx) -> Result<Void, Error>

Example

I'm not particularly in favor of this because having APIs based on Result can be a slippery slope for increasing the compiler scope.

We can imagine there will be many Error types defined across many libraries. We can also imagine like in rust many times you'll want to just unwrap the Ok and let Err bubble up.

type Error {
  SomethingFailed
  SpendFailed
}

fn something() -> Result<Int, Error> {
  Ok(1)
}

fn spend(datum, redeemer, ctx) -> Result<Void, Error> {
  try x = something()
  
  Ok(())
}

Issues

1. This seems fine if you are only working with one error type but breaks down when different error types need to be merged.

It's such a thing that Rust's thiserror crate has a special #[from] macro to make handling many Errors of different types actually ergonomic.

2. Not only do we have that problem we also then need extra code gen for the constr Ok

type SomethingError {
  SomethingFailed
}


fn something() -> Result<Int, SomethingError> {
  Ok(1)
}

type Error {
  SpendFailed
}

fn spend(datum, redeemer, ctx) -> Result<Void, Error> {
  try x = something()
  
  Ok(())
}

The above would be a type mismatch.

My suggestion

• definitely introduce Result
• If we allow validators to return result I would like Bool to still be an option. So that means validators could have two possible return types
• If we introduce Result and want APIs to be based on them I think it's a bad idea not to have error type merging and that will take some thought and time. We could look into how zig or roc does it but it'll be fairly nontrivial type system work either way.

[MicroProofs]

Considering now(bls and conversion to string excluded) builtin errors are now caught and a traced error is thrown. I wonder how possible this might be?