Result with Exceptions

[sideeffffect]

Hello, would you consider restricting Result[+T, +E] to Result[+T, +E <: Exception]?
If something is a result, the Err case should communicate some information about what went wrong. And Exceptions are the way to do that in Scala: Exceptions can be chained with causality relation and also contain stack traces. Plus have other advantages, like interop with Java and related tooling and can be (re)thrown and caught.

Generally speaking, using Exception for things like Result is the best practice within the wider software engineering Scala world, so it would be nice if steps/Result nudged its users in the right direction.

[lbialy]

seconded, albeit with a caveat: I thought that the idea of introducing Result was to bring Scala's flow control closer to how Rust does things (given the safe scoped .ok thing) and that's basically "return values from functions" (and do controlled, structural jumps where it's safe to do them - cc is there to prevent .ok in a block escaping to another thread, for example) which is good, great even. the thing with Exceptions, however, is that by the sheer amount of experience of throwing them they are going to nudge users toward not returning them in Results and just throwing them (the same goes for LLMs!). this is not the case when E is an enum that does not implement Throwable or extend Exception. this might be worth considering from the perspective of what's important - being compatible with the wider (and older, legacy so to say) ecosystem and ways of doing things or being consistent in how things ought to be done in the brave new world.

that's, of course, assuming I'm correct in my read of where we want to move. if I'm mistaken and the idea is to embrace exceptions with something like CanThrow, I'd be against introduction of Result altogether, just choose one way of doing things (retvals with error channel vs throwing with a capability) and keep doing it consistently.

[sideeffffect]

they are going to nudge users toward not returning them in Results and just throwing them

This is important point: both should (must!) be possible, because each serves a different purpose.
Returning via Result is for expected "errors". Throwing is for "unexpected"/fatal errors/bugs.

[bishabosha]

tracing seems important

[lbialy]

we could have a compiler plugin that would scream at user for using throw and suggest using panic(RuntimeException("that's a bug"))

where panic:

inline def panic(inline e: -> Exception): Nothing = throw e

to really drive the point home