Development
go-data-types
Guides the agent to avoid common Go mistakes with basic data types, slices, and maps. Use when writing or reviewing Go code that involves integer literals, numeric overflow, floating-point arithmetic, slice initialization/slicing/appending/copying, map initialization, or value comparison. Covers mistakes #17-#29 from "100 Go Mistakes and How to Avoid Them."
v0lka · Static checks on file
Installation
Read the source and dependencies before running a command. Copying does not install or execute anything.
npx skills add v0lka/skills --skill go-data-typesAbout this skill
name: go-data-types description: > Guides the agent to avoid common Go mistakes with basic data types, slices, and maps. Use when writing or reviewing Go code that involves integer literals, numeric overflow, floating-point arithmetic, slice initialization/slicing/appending/copying, map initialization, or value comparison. Covers mistakes #17-#29 from "100 Go Mistakes and How to Avoid Them."
Go Data Types: Slices, Maps, and Numeric Pitfalls
Octal Literals (#17)
- Integer literals starting with
0are octal (base 8).010 == 8, not10. - Always use the explicit
0oprefix for octal numbers to prevent confusion:
// Bad - readers may think this is decimal 644
file, err := os.OpenFile("foo", os.O_RDONLY, 0644)
// Good - explicitly octal
file, err := os.OpenFile("foo", os.O_RDONLY, 0o644)
- Other literal prefixes:
0b(binary),0x(hex),isuffix (imaginary). - Use
_as a digit separator for readability:1_000_000_000.
Integer Overflows (#18)
- Integer overflow and underflow are silent at runtime in Go. No panic occurs.
- Compile-time overflow (e.g.,
var x int32 = math.MaxInt32 + 1) is caught, but runtime overflow is not. - When overflow matters (conversions, large numbers, constrained integer sizes), guard explicitly:
// Increment
func Inc32(counter int32) int32 {
if counter == math.MaxInt32 {
panic("int32 overflow")
}
return counter + 1
}
// Addition
func AddInt(a, b int) int {
if a > math.MaxInt-b {
panic("int overflow")
}
return a + b
}
// Multiplication
func MultiplyInt(a, b int) int {
if a == 0 || b == 0 {
return 0
}
result := a * b
if a == 1 || b == 1 {
return result
}
if a == math.MinInt || b == math.MinInt {
panic("integer overflow")
}
if result/b != a {
panic("integer overflow")
}
return result
}
- Use
math/bigwhenint64is insufficient.
Floating Points (#19)
float32andfloat64are approximations (IEEE-754). They cannot represent all decimal values exactly.- Never compare floats with
==. Compare within a delta:
// Bad
if f1 == f2 { ... }
// Good
const epsilon = 1e-9
if math.Abs(f1-f2) < epsilon { ... }
- Floating-point error accumulates across operations. To reduce it:
- Addition/subtraction: group values of similar magnitude together.
- Mixed operations: perform multiplication and division before addition and subtraction.
// Better accuracy: add small values first, then add large value
result := 0.0
for i := 0; i < n; i++ {
result += 1.0001
}
result += 10_000.0
// Better accuracy: multiply/divide before add/subtract
// Prefer: a*b + a*c over a*(b+c) when magnitudes differ
- Special values:
+Inf,-Inf,NaN. Check withmath.IsInf,math.IsNaN. - NaN is the only float where
f != fis true.
Slice Length vs. Capacity (#20)
- Length: number of accessible elements. Capacity: size of backing array.
make([]int, 3, 6)creates a slice with length 3, capacity 6.- Accessing beyond length panics even if capacity allows it; use
appendto grow into capacity. - When capacity is exhausted,
appendallocates a new backing array (doubles until 1024 elements, then grows ~25%). - Slicing (
s1[1:3]) shares the backing array. Mutations via one slice are visible through the other. - After enough appends cause a new backing array, the slices decouple.
Inefficient Slice Initialization (#21)
- If the output length is known, always preallocate:
// Bad - causes repeated allocations and copies
bars := make([]Bar, 0)
for _, foo := range foos {
bars = append(bars, fooToBar(foo))
}
// Good (fastest) - given length + direct index
bars := make([]Bar, len(foos))
for i, foo := range foos {
bars[i] = fooToBar(foo)
}
// Good (slightly slower, sometimes more readable) - given capacity + append
bars := make([]Bar, 0, len(foos))
for _, foo := range foos {
bars = append(bars, fooToBar(foo))
}
- Given-length is ~4% faster than given-capacity due to avoiding
appendoverhead. - Use given-capacity +
appendwhen index math would be complex (e.g., two appends per iteration). - If exact length is unknown but an upper bound exists, prefer setting capacity to the upper bound.
Nil vs. Empty Slices (#22)
- A nil slice (
var s []string):s == nilis true,len(s) == 0. - An empty slice (
s := []string{}ormake([]string, 0)):s == nilis false,len(s) == 0. - Nil slice requires zero allocation. Prefer
var s []Twhen the slice may remain empty. appendworks on nil slices. No need to defensively initialize to non-nil.- Do not return non-nil empty slices for defensive reasons. Return nil slices instead.
// Good - returns nil if nothing appended (zero allocation)
func f() []string {
var s []string
if foo() { s = append(s, "foo") }
if bar() { s = append(s, "bar") }
return s
}
- Avoid
[]string{}without initial elements; it allocates unnecessarily. - Beware:
encoding/jsonmarshals nil slices asnulland empty slices as[].reflect.DeepEqualdistinguishes nil from empty. Know your downstream consumers.
Initialization cheat sheet:
| Form | Nil? | When to use |
|---|---|---|
var s []T | yes | Default; final length unknown, may be empty |
[]T(nil) | yes | Inline nil slice (e.g., append([]int(nil), 42)) |
make([]T, n) | no | Known length |
make([]T, 0, n) | no | Known capacity, use with append |
[]T{} | no | Only when providing initial elements |
Checking if a Slice is Empty (#23)
- Always check
len(s) == 0, nevers == nil. lenworks correctly for both nil and non-nil empty slices.- Same rule applies to maps: check
len(m) == 0, notm == nil. - When designing APIs, do not distinguish between nil and empty slices.
Slice Copy (#24)
copy(dst, src)copiesmin(len(dst), len(src))elem