After reading the proposed draft design I was very glad that there are some upcoming changes to the errorhandling in go.
I have also read a lot of similar proposals and you may argue this is a clone of some other proposal. My intention behind this is to offer my oppinion as a scriptingwise go-dependant engineer. Speed, readability and reusability are very much the things I am looking for.
The general idea behind check and handle will address the current issues with readability very well.

The example in the draft design explains the usage of check and handle:

func printSum(a, b string) error {
	handle err { return err }
	x := check strconv.Atoi(a)
	y := check strconv.Atoi(b)
	fmt.Println("result:", x + y)
	return nil
}

This adresses readablility a lot, but repetitive code not by much:

• to use a different handle you would have to redefine it each time
• there would be at most one default handle

Named dicts or structs are being used in various languages.
As an addition to check handle I am now proposing - similar to labled handles - named pairs of these keywords. A named pair would have the following syntax:
handle.<name>
check.<name>
Rewriting the given example you could then name the handle:

func printSum(a, b string) error {
	handle.chain err { return err } 
	x := check.chain strconv.Atoi(a)
	...
}

I know that that assigning to an attribute of a keyword like handle.<name> is unwanted by most and this needs to be adressed, but this code would be very readable and very reusable. There could also be standard definitions of named pairs like check.chain, check.panic, etc. or exported handles like handle.Chain or Handle.Chain.
I believe this would integrate very well with the current go language and would make at least my life easier.

Thanks for reading! I'm looking forward to the upcoming changes!