Exploring the Go slices and maps packages

In this blog post we are going to explore the maps and slices packages from the Go standard library. These two packages were introduced in Go 1.21 and got new methods in Go 1.23 with the introduction of Iterators. The two packages provide useful and convenient methods to work with slices and maps.

Builtin ¶

Go provides us with three builtin types to work with collections of data:

array is a fixed-size, sequentially stored data structure containing elements of the same type.
slice is a dynamically sized view of an underlying array.
map is a data structure that associates keys with values.

The language provides a set of builtin functions to work with these types:

append adds elements to the end of a slice, resizing the slice if necessary. This method either returns the original slice if it has enough capacity, or a new slice with the added elements.

cap returns the capacity of a variable depending on its type (array, slice, channel).

clear removes all elements from a map or sets all elements of a slice to their zero value.

copy copies elements from a source slice to a destination slice.

delete removes the element with the specified key from the map.

len returns the number of elements in various types like arrays, slices, maps, and strings.

make allocates and initializes an object of type slice, map, or channel.

comparable Type Constraint ¶

Before we dive into the slices and maps packages, let's talk about the comparable type constraint. Most methods in these two packages are generic, and quite a few of them use parameters constrained to the comparable type constraint.

The comparable constraint specifies that a generic type parameter must support the == and != operators. Most types in Go fulfill this constraint, including all basic types (e.g., int, string, bool), pointers, arrays, structs, and channels composed solely of comparable types, and interface types.

However, there are some types that are not comparable:

Slices: Comparing two slices directly will result in a compile-time error.

Maps: Cannot be compared, except to nil.

Functions: Are not comparable, as they represent code references rather than concrete values.

Interfaces with non-comparable dynamic values
Interface types (e.g., any) can be compared syntactically, but if their dynamic (underlying) values are non-comparable, a runtime panic occurs:

var x, y any = []int{1}, []int{1}
fmt.Println(x == y) // Runtime Panic

Structs/Arrays: Containing non-comparable types
Composite types like structs or arrays are only comparable if all their fields/elements are comparable.

This example does not compile because slices are not comparable:

type Person struct {
    Hobbies []string
}
a := Person{Hobbies: []string{"Reading"}}
b := Person{Hobbies: []string{"Swimming"}}
fmt.Println(a == b) // Compile Time Error

But this example works because all fields in the struct are comparable and Go compares them field by field:

type Person struct {
    Name string
    Age  int
}
a := Person{Name: "Alice", Age: 25}
b := Person{Name: "Alice", Age: 25}
fmt.Println(a == b) // true

Pointers are always comparable, even when they point to non-comparable types. The following example compiles and runs without errors. Important to note that comparing pointers compares the memory address, not the values they point to.

type Person struct {
    Hobbies *[]string
}
a := Person{Hobbies: &[]string{"Reading"}}
b := Person{Hobbies: &[]string{"Reading"}}
fmt.Println(a == b) // false

hobbies := &[]string{"Reading"}
c := Person{Hobbies: hobbies}
d := Person{Hobbies: hobbies}
fmt.Println(c == d) // true

Assignments ¶

Some methods we will look at later internally use assignments to copy values from one slice or map to another.

In Go, variables hold values, and this value can be either a "value type" or a "reference type".

Value types (e.g., int, float64, bool, string, structs, arrays):
When you assign a value type variable to another, or pass it to a function, a copy of the actual value is made. Changes to the copy do not affect the original variable.
Reference types (e.g., slices, maps, channels, pointers, functions):
When you assign a reference type variable to another or pass it to a function, the address structure is copied, not the full data itself. Both variables then reference the same underlying data. Changes made through one variable will affect the data seen by the other variable. Maps and slices technically contain a header that is a value type, but the header contains a pointer to the underlying data. So when you assign a slice or map to another variable, Go copies the header, but because the header contains a pointer, both variables point to the same underlying data structure.

Value types are copied, changing one does not affect the other:

type address struct {
  city string
}

type person struct {
  name string
  age  int
  addr address
}

func main() {
  pv1 := person{
    name: "Alice",
    age:  30,
    addr: address{
      city: "Wonderland",
    },
  }

  pv2 := pv1

  pv2.name = "Bob"
  pv2.addr.city = "Builderland"

  println(pv1.name, pv1.age, pv1.addr.city) // Alice 30 Wonderland
  println(pv2.name, pv2.age, pv2.addr.city) // Bob 30 Builderland

  v1 := 10
  v2 := v1
  v2 = 20

  println(v1) // 10
  println(v2) // 20

Builtin ¶

comparable Type Constraint ¶

Assignments ¶

Slices ¶

Iterator methods ¶

Creating and populating ¶

Copying and cloning ¶

Searching ¶

Comparing ¶

Sorting ¶

Mutation ¶

Utility methods ¶

Maps ¶

Iterator methods ¶

Collecting ¶

Cloning ¶

Comparing ¶

Mutation ¶

Conclusion ¶