go error handling proposals

overview of error handling proposals in go

go error handling proposals

overview of error handling proposals in go

note: updated 12023-11-17

error handling

1if err != nil {
2        // handle error
3}

Error handling seems to be a recurring theme in go, but most proposals get nowhere.

• Go2ErrorHandlingFeedback
• label:error-handling

proposals

baseline code

1x, err := foo()
2if err != nil {
3        return nil, wrap(err)
4}

handling

note: almost all the ones that claim to use "plain functions" as error handlers have an implicit nonlocal return

predeclared handlers

• handle err { return _, wrap(err) }
x := check foo()
• [catch (err error) { return _, wrap(err) }
x := catch foo()]
• handle err { return _, wrap(err) }
x, # := foo():
• handle func(err error) (T, error) { return _, wrap(err) }
x, ? := foo()
• watch err { if err != nil { return _, wrap(err) } }
x, err != foo()
• expect err != nil { return _, wrap(err) }
x, err := foo()
• with { return _, wrap(err) }
handle err { x, err := foo() }

call specific handler

• x, #err := foo()
catch err { return _, wrap(err) }: tagged error handlers
• x, @err := foo()
err: return _, wrap(err): goto label
• grab err() { if err != nil { return _, wrap(err) } }
x, err() := foo(): assign to handler
• err := inline(err error){ if err != nil { return _, wrap(err) } }
x, err := foo(): assign to handler
• err := func(err error) (T, error) { return _, wrap(err) }
x, #err := foo(): block scoped
• _check = func(err error) (T, error) { return _, wrap(err) }
x, ?err := foo(): not fully formed idea on return
• handler := func(err error) (T, error) { return _, wrap(err) }
x, #handler(_) := foo(): implicit nil check
• handler := func(err error) (T, error) { return^2 _, wrap(err) }
x, handler(err) := foo(): note nonlocal return
• handler := func(err error) (T, error) { eject _, wrap(err) }
x, err := foo()
inject handler(err)
• x, !err := foo() throw handler
catch handler { return wrap(err) }
• goto x, err := foo()
r:
return _, wrap(err)
• trap func(err2 error) { err = wrap(err2) }
x, _ := foo(): like defer, triggers on every error

wrapping

some rely on wrap being smart and passing through nil (so not fmt.Errorf),

• x, err := foo()
reflow _, wrap(err): implicit err != nil and return
• x, err := foo()
refuse _, wrap(err)
• x, err := foo()
pass wrap(err)
• x, err := foo()
ereturn _, wrap(err)
• x, err := foo()
err ?: return _, wrap(err)
• x, err := foo()
on err, return _, wrap(err)
• x, err := foo()
on err return handler()
• x, err := foo()
err ? { return _, wrap(err) }
• x, err := foo()
onErr { return _, wrap(err) }
• x, err := foo()
try err: _, wrap(err)
• x, err := foo()
try err, wrap
• x, err := foo()
if err != nil { return _, wrap(err) }, also: if ... on 1 line
• x, err := foo()
if err != nil { return wrap(err) }: implicit zero values for other returns
• x, err := foo()
if !err { return _, wrap(err) }
• x, err := foo()
if err { return _, wrap(err) }, also
• x, err := foo()
if err? { return _, wrap(err) }
• x, err := foo()
if err != nil: return _, wrap(err)
• x, err := foo()
if err != nil return _, wrap(err)
• x, err := foo()
return wrap(err) if err != nil, also
• x, err := foo()
return if err != nil { _, wrap(err) }, also
• x, err := foo()
return(err) wrap(err)
• x, err := foo()
\ nil, wrap(err)
• x, err := foo(); if err != nil { return _, wrap(err) }, also, also, also, also: everything on 1 line
• x, err := foo() ?? { return _, wrap(err) }
• x, err := foo() else { return _, wrap(err) } x, err := foo() orelse { return _, wrap(err) }
• x, err := foo() /* err */ { return _, wrap(err) },
• x, err := foo() { return _, wrap(err) }, also
• x, err := foo(); err.return wrap(err)
• x, err := foo() err? wrap(err)
• x, wrap() := foo()
• x, wrap(err) := foo()
• x, #wrap(_) := foo()
• x := foo() or err: return _, wrap(err)
• x := foo() ?err return _, wrap(err)
• x := check wrap() foo(), also
• x := check foo() with wrap(err)
• x := check foo(); err { return _, wrap(err) }
• x := foo() ? wrap()
• x := foo() or wrap
• x := foo() || wrap(err)
• x := foo() on_error err fail wrap(err)
• x := foo() onerr return _, wrap(err)
• x := foo() // error: err => wrap(err) error handling in comments
• x := try(foo(), wrap)
• x := try foo() or return _err
• x := try foo(), wrap
• x := collect(&err, foo(), wrap)
• abort? x, err := foo(); _, wrap(err)
• if x, err := foo(); err != nil then return _, wrap(err)
• try x, err := foo() { return _, wrap(err) }

return

• x := try(foo())
• x := must(foo()): panic instead of return
• x := handle foo()
• x := guard foo()
• x := must foo()
• x := foo!()
• x := foo()?, also, also
• x := #foo()
• x :=. foo()
• x, # := foo(): panic instead of return
• x, ~ := foo(): wrap with stacktraces
• x, - := foo()
• x, ? := foo(), also, also
• x, ! := foo(), also, panic
• x, !! := foo()
• x, !err := foo(), also
• x, ^err := foo()
• x, ?err := foo()
• x, err? := foo()
• x, err! := foo()
• x, err := foo() throws err
• x, check err := foo()
• x, err := foo(): builtin implicit nil check
• x, err := foo()
check(err): builtin if err != nil { return ..., err } macro
• x, err := foo()
catch(err): builtin if err != nil { return ..., err } macro
• x := foo().handleErr(): builtin if err != nil { return ..., err } macro
• x := foo() -> throw err
• x := if foo(); return

try..catch

• try { x := foo() } catch(e Exception) { ??? }, also: literally try catch
• try err != nil { x, err := foo() } except { return _, wrap(err) }
• try { x := foo(); if err != nil { return _, wrap(err) } }
• try { x, $ := foo() } catch(err) { return _, wrap(err) }
• until err != nil { check x, err := foo() } else { return _, wrap(err) }: insert after every check
• break err != nil { step: x, err := foo() }: insert after every repeatable label
• break err != nil { try x, err := foo() }: insert after every try
• if x, err := foo(); err != nil { return _, wrap(err) } else { ... } undo { ??? } done { ??? } defer { ??? }
• handler := func(err error) error { return wrap(err) }
check(handler){ x := foo() }
• check { x := check foo() } handle err { return _, wrap(err) }
• check { x, err1 := foo() } catch err { return _, wrap(err) }
• check { x, err := foo()
catch: return _, wrap(err) }
• x, err := foo() !!!
fail: return _, wrap(err): goto label
• handle err { x, err := foo()
case err != nil: return _, wrap(err) }
• throw "err"
catch func(err error) { return _, wrap(err) }

others

• x, (err) := foo(): only assign to LHS if () content is not currently nil
• collect err { x, _! := foo() }
if err != nil { return _, wrap(err) }: err is an value that accumulates errors? does it continue?
• errorhandling(err){ x, err := foo() }: err is an accumulator? messes with types
• x, err := foo()
handle err1 || err2 || err3 { return _, wrap(err) }: shorter if chain?
• nonlocal return
• nonlocal return with return type
• returnfrom label, err: nonlocal return
• result type: box of value|err allows passthrough
• if x, err := foo().bar().baz(); err != nil { return _, wrap(err) }: chaining method calls with return type (T, error)
• func foo() (return, string): return is a type of bool that does... something
• ErrorOr[T]: new convention instead of return T, err
• x := foo()
if x@error != nil { ... }
• template handler(err error, x expression) { if err != nil { inline(x); panic(err) } }
x, err := foo()
handler(err, { err = wrap(err) })
• tryfunc func(...){ x := foo() }: new function type, implicit error checks, implicit error return value