Weird syntax in golang math/big library

Question

I'm using the math/big library in golang to perform operations on bit strings. Everything is working fine but I'm puzzled at why, for most of this library's functions, the syntax is:

var num1 big.Int
var num2 big.Int
var result big.Int

// Set num1 and num2 

result.And(&num1,&num2)

Instead of:

var num1 big.Int
var num2 big.Int

// Set num1 and num2 

result = num1.And(num2)

Since functions such as And also return the result of the operation (https://golang.org/src/math/big/int.go?s=18912:18945#L798).

Why do you think this was the chosen implementation?

Could this be because of performance or well-known bad garbage collection? This is just plain curiosity, thanks in advance!

Answer 1

The functions are dealing with structures taking a lot of memory (otherwise you would use just int64), so the simplest optimization is not to make useless allocations. Therefore they use pointers and put the result in allready allocated memory.

Answer 2

I don't know what is weird, this is consistent with how non-big operations work. E.g. using bitwise AND on int operands does not change the operands:

a, b := 3, 15
c := a & b
fmt.Println(c) // Prints 3

x, y := big.NewInt(3), big.NewInt(15)
z := new(big.Int).And(x, y)
fmt.Println(z) // Prints 3

This also means if you have a variable prepared, you can use it as the "target", to store the result. Just like you can use an existing int variable to store the result of the above a & b expression:

c = a & b

z.And(x, y)

Which means you don't need to reallocate a new big.Int value to get the result (performance implications).

And the methods usually return the same pointer so you can chain specific operations.

Methods of this form typically return the incoming receiver as well, to enable simple call chaining.

So you can also do something like:

fmt.Println(z.And(x, y).BitLen())  // Prints 2

Try the examples on the Go Playground.