Some thoughts:

• for all proposals like this, I think it's slightly unfortunate that check (or try, or whatever) appears before the function being called. It means that reading the code tends to emphasize the error handling. Though no doubt people would get used to overlooking the check keyword.
• The example handler := formattedError(fmt.Sprintf("copy %s %s: %w", src, dst)) can't be right, as there is no argument corresponding to %w in the call to fmt.Sprintf. I guess it should be %%w, although that is a little subtle.
• I don't think I understand how this syntax handles the error value returned by a with function. The example shows check io.Copy(w, r) with func(err error) error {return os.Remove(dst)}, but that seems to imply that we will return the error returned by os.Remove. That can't be right. Should this be with func(err error) error { os.Remove(dst); return err }?
• If I understand the order of execution correctly, on error the function will remove the file and then close it, but that ordering doesn't work on Windows. We need to close first, then remove.

Thanks for the quick reply! My thoughts inline below

for all proposals like this, I think it's slightly unfortunate that check (or try, or whatever) appears before the function being called. It means that reading the code tends to emphasize the error handling. Though no doubt people would get used to overlooking the check keyword.

I think syntax highlighting helps here as well. One alternative is using single characters, which I know has some pushback, although it could bare similarity to = vs :=. Something like @= has been proposed before. Mixing single symbols with words would be odd, so would likely change with as well. I'm not too picky in this area, as I agree folks would get used to it. Check/with has a nice sound to it though.

The example handler := formattedError(fmt.Sprintf("copy %s %s: %w", src, dst)) can't be right, as there is no argument corresponding to %w in the call to fmt.Sprintf. I guess it should be %%w, although that is a little subtle.

Yup, good catch. Even %%w, remains escaped in future calls so that wouldn't work. that solution would need to become:

func formattedError(fmtStr string, args ...interface{}) func(err error) error {
	return func(err error) error{
		args = append(args, err)
		return fmt.Errorf(fmtStr, args...)
	}
}

and the call to it: handler := formattedError("copy %s %s: %w", src, dst)

I don't think I understand how this syntax handles the error value returned by a with function. The example shows check io.Copy(w, r) with func(err error) error {return os.Remove(dst)}, but that seems to imply that we will return the error returned by os.Remove. That can't be right. Should this be with func(err error) error { os.Remove(dst); return err }?

If I understand the order of execution correctly, on error the function will remove the file and then close it, but that ordering doesn't work on Windows. We need to close first, then remove.

That is correct. The intent was less to show "good code", and more to show how the semantics of this proposal would work

check on its own with a function that returns no values but an error looks clean to me. However, I don't like the with syntax as it is if err != nil { handler(...) } in disguise; it's just less straightforward. Also, when there are other return values, check is buried in the middle of the line, while most other keywords are usually in the beginning or are in lines that began with keywords, which makes them easier to notice.

Thanks for the suggestion, but based on the discussion above, and the emoji voting, this is a likely decline. Leaving open for four weeks for final comments.

No further comments.