proposal: Go 2: new syntax for abbreviation of if err != nil { return ..., err }

[lance6716]

Author background

• Would you consider yourself a novice, intermediate, or experienced Go programmer?
  experienced
• What other languages do you have experience with?

Related proposals

• Has this idea, or one like it, been proposed before?
  I can't find a precise searching keyword in GitHub issue. I have read some proposals which will list below

  • If so, how does this proposal differ?
    proposal: Go 2: introduce "then" keyword in if statement to allow one liner if statement for better error handling. #46717 , proposal: allow implicit conversion of error to bool in if statements, fmt on one line #38151 My proposal is more concise. It does not need to write if
    proposal: Go 2: onErr simple macro for common case error handling. A #32437 counter-proposal. #32946 My proposal applies to less scenarios but more clear

• Does this affect error handling?
  Yes

  • If so, how does this differ from previous error handling proposals?
    See above

• Is this about generics?
  No

  • If so, how does this relate to the accepted design and other generics proposals?

Proposal

• What is the proposed change?
  One line introduce: Go will expand some Function()? to equivalent if err != nil { return ..., err }

  An example from my demo https://github.com/lance6716/errhell

func manyReturn() (
	complex64,
	*int,
	<-chan struct{},
	[]float32,
	interface{},
	func(error) error,
	map[string]interface{},
	error,
) {
	returnError()?
	return 0, nil, nil, nil, nil, nil, nil, nil
}

will be converted to

func manyReturn() (
	complex64,
	*int,
	<-chan struct{},
	[]float32,
	interface{},
	func(error) error,
	map[string]interface{},
	error,
) {
	_err0 := returnError()
	if _err0 != nil {
		return 0, nil, nil, nil, nil, nil, nil, _err0
	}
	return 0, nil, nil, nil, nil, nil, nil, nil
}

• Who does this proposal help, and why?
  Developer can write less code 😄

• Please describe as precisely as possible the change to the language.
  The new token ? can only be legal appended to such a function call, name it fn:

  • the fn has one or more return values, and only one return value implements error interface
  • the caller of the fn has no more than one return values which implements error interface

  If it's legal, the effect is equivalent to a if statement being inserted after the call of fn. The returned error of fn will be nil-checked, and there's a return statement in then-body to fill the return values of caller of fn with the error and/or zero values.

  I have made a demo: https://github.com/lance6716/errhell , the test input can be found in https://github.com/lance6716/errhell/blob/936cdcb459015fd5ce066b3f9b4325dcff6a8430/test/input/input.go and equivalent output can be found in https://github.com/lance6716/errhell/blob/936cdcb459015fd5ce066b3f9b4325dcff6a8430/test/expected/expected.go

• What would change in the language spec?

• Please also describe the change informally, as in a class teaching Go.
  I think my demo and example is clear to explain it.

• Is this change backward compatible?
  No

  • Breaking the Go 1 compatibility guarantee is a large cost and requires a large benefit.
    Show example code before and after the change.
  • Before
  • After

• Orthogonality: how does this change interact or overlap with existing features?
  No

• Is the goal of this change a performance improvement?
  No

  • If so, what quantifiable improvement should we expect?
  • How would we measure it?

Costs

• Would this change make Go easier or harder to learn, and why?
  No change if don't use it
• What is the cost of this proposal? (Every language change has a cost).
  compiling is a bit more complex?
• How many tools (such as vet, gopls, gofmt, goimports, etc.) would be affected?
  I'm not sure about how they work, but they should be able to re-use the syntax
• What is the compile time cost?
  I'm not an expert 😢 But I think as my demo it only requires checking the current stack.
• What is the run time cost?
  Only affects compiling
• Can you describe a possible implementation?
  See my demo https://github.com/lance6716/errhell
• Do you have a prototype? (This is not required.)
  https://github.com/lance6716/errhell

[seankhliao]

similar to #39451 and https://gist.github.com/yaxinlx/1e013fec0e3c2469f97074dbf5d2e2c0

[ianlancetaylor]

Also similar to #21155.

As it says at #40432 these kinds of changes are typically rejected because they are cryptic: a single ? leads to a change in flow control.

[lance6716]

nothing new under the sun 😂