It's not redundant, as the Go language rules make it harder than you think to subtract a signed positive constant value. To subtract a variable value, you can simply write AddUint32(&x, -v). That doesn't work for constant values because the resulting untyped constant can not be assigned to uint32.

Closing because I don't think we should change this.

How is it possible to call AddUint32(&x, -v) for an uint32 variable v?
Compiler will report error.

[edit] sorry, no errors are reported. Surprise!

btw, there are many a uintxxx uses in sync/atomic doc.
Should they be an uintxxx?

@ianlancetaylor I still think signed is redundant, why are unsigned constants excluded?
I can't find ways to subtract unsigned constant values, except the ^uint32(c-1) way.

Example

package main

import (
	"fmt"
	"sync/atomic"
)

func main() {
	var n uint32 = 100
	const d uint32 = 100
	// atomic.AddUint32(&n, -d) // constant -100 overflows uint32.
	atomic.AddUint32(&n, ^uint32(d - 1)) // this one is ok.
	fmt.Println(n)
}

Oh yeah, I found another way to subtract unsigned constant, if the unsigned constant is typed and its type is same as the second parameter type.

atomic.AddUint32(&n, ^(d - 1))

But if the type of the typed unsigned constant doesn't match he second parameter type, then the ^uint32(c-1) way still needs to be used.

@ianlancetaylor

That doesn't work for constant values because the resulting untyped constant can not be assigned to uint32.

but the doc says ... subtract a signed positive constant value c ..., "a signed constant" implies c is a typed constant, an operation with a typed constant c involved will always result a constant with the same type as c. So I think the reason of the trick ^uint32(c-1) is not for untyped constant can not be assigned to uint32.

Thanks for the comments. Let's agree to disagree.

but the docs really doesn't mention how to subtract an unsigned constant.

Go doesn't really have the concept of an unsigned constant. Go constants are untyped. Numeric constants are positive or negative. They are always signed. See https://golang.org/blog/constants.