How to omit a secondary return from a function call during a struct value assignment

I would like to assign a value within a variable declaration of type struct, however, I need to call a function that returns a secondary value (an error) which I would like to disregard in the assignment.

Is there a way to do so? For example:

type myStruct struct{
	address common.Address
}


func main() {
	newVar := myStruct{
	  address: common.HexToAddress("xyz") 
	}
}

The issue is that common.HexToAddress() returns 2 values, a common.Address as well as an error. I would like to omit the error and assign it as above. I would prefer not to have to do:

var newVar2 myStruct
myStruct,_ = common.HexToAddress("xyz") 

It's usually not exactly recommended to ignore errors, which may be one reason why the language does not make this easy.

That being said, a pattern you see sometimes is a package offering a Must function, for those cases where just doing a panic() on an error is the right thing to do; e.g., when initializing package-level variables.

For example, there's text/template.Must. The implementation simply tests the error and panics if it is not nil. You can consider adding such a function as well (possibly local to your file), allowing you to write your struct initialization as:

newVar := myStruct{
  address: must(common.HexToAddress("xyz")),
}
// ...
func must(address common.Address, err error) common.Address { ... }

This relies on the feature that if a function returns multiple values, and another function takes the same amount of parameters, you can invoke the latter directly on the return values of the former.

If you don't want to go that far, you do need to explicitly ignore the second return value by assigning it to the blank identifier _. You could of course do that separately, so that you still get to use a structure literal, but it may not be any cleaner than what you suggested originally:

address, _ := common.HexToAddress("xyz")
newVar := myStruct{address: address}

You're probably looking for some kind of syntactic sugar. Go is intentionally sparse on such things, because in the opinion of the language designers, it tends to make things less obvoius, thus less readable. So you have limited options here.

If you really don't care about the error, here are your options:

Assign to a temporary variable as you suggested (usually the most natural/readable option):

addr, _ := common.HexToAddress("xyz")
newVar := myStruct{
    address: addr,
}

Use the return value of an anonymous function:

newVar := myStruct{
    address: func() common.Address { addr, _ := common.HexToAddress("xyz"); return addr }(),
}

If you control the common package, consider adding a variant that ignores (or panics on) errors:

newVar := myStruct{
    address: common.MustHexToAddress("xyz"),
}

Write your own wrapper function:

func hexToAddress(hex string) common.Address {
    addr, _ := common.HexToAddress(hex)
    return addr
}

newVar := myStruct{
    address: hexToAddress("xyz"),
}