In Go, to swap simply write:
*xPtr, *yPtr = *yPtr, *xPtr
The Go Programming Language Specification
Assignments
A tuple assignment assigns the individual elements of a multi-valued
operation to a list of variables. There are two forms. In the first,
the right hand operand is a single multi-valued expression such as a
function call, a channel or map operation, or a type assertion. The
number of operands on the left hand side must match the number of
values.
In the second form, the number of operands on the left must equal the
number of expressions on the right, each of which must be
single-valued, and the nth expression on the right is assigned to the
nth operand on the left:
one, two, three = '一', '二', '三'
The assignment proceeds in two phases. First, the operands of index
expressions and pointer indirections (including implicit pointer
indirections in selectors) on the left and the expressions on the
right are all evaluated in the usual order. Second, the assignments
are carried out in left-to-right order.
The assignment proceeds in two phases. First, the operands of pointer
indirections on the left and the expressions on the right are all
evaluated in the usual order. Second, the assignments are carried out
in left-to-right order.
For example, swapping to and fro:
package main
import "fmt"
func main() {
xPtr, yPtr := new(int), new(int)
*xPtr, *yPtr = 1, 2
fmt.Println(*xPtr, *yPtr)
// Swap - idiomatic Go
*xPtr, *yPtr = *yPtr, *xPtr
fmt.Println(*xPtr, *yPtr)
// is equivalent to
// RHS - evaluate
ty := *yPtr
tx := *xPtr
// LHS - assign
*xPtr = ty
*yPtr = tx
fmt.Println(*xPtr, *yPtr)
// is equivalent to
// Optimized
t := *xPtr
*xPtr = *yPtr
*yPtr = t
fmt.Println(*xPtr, *yPtr)
// is not equivalent to
// Error: No swap
*xPtr = *yPtr
*yPtr = *xPtr
fmt.Println(*xPtr, *yPtr)
}
Playground: https://play.golang.org/p/Ph4Dsc_jsJJ
Output:
1 2
2 1
1 2
2 1
1 1