Почему в Go нет встроенной структуры данных "множество" (set) и как её реализовать?

Почему в Go нет встроенного set: философия языка

Отсутствие отдельного типа set в Go — это осознанное дизайнерское решение, а не недоработка. Go придерживается принципа минимализма: если функциональность можно элегантно реализовать с помощью существующих конструкций, то отдельный тип не добавляется. Разработчики языка (Роб Пайк, Кен Томпсон) считают, что map[K]struct{} — это и есть "канонический" set в Go.

Основные причины:

• Простота компилятора и runtime: Поддержка отдельного типа set потребовала бы добавления нового синтаксиса, методов, оптимизаций в garbage collector. map уже делает 90% работы.
• Единообразие: В Go нет дженериков (до версии 1.18), поэтому set пришлось бы делать либо под конкретный тип, либо через interface{} с потерей производительности. map[string]struct{} решает проблему без дженериков.
• Композиция: map легко превращается в set — достаточно использовать пустую структуру struct{} как значение. Она занимает 0 байт памяти, что оптимально.

Идиоматическая реализация set через map[K]struct{}

Вот как правильно использовать map в качестве множества:

package main

import "fmt"

func main() {
    // Создаём set для строк
    names := map[string]struct{}{}

    // Добавление элементов
    names["Alice"] = struct{}{}
    names["Bob"] = struct{}{}
    names["Alice"] = struct{}{} // повторно — ничего не изменится

    // Проверка наличия
    if _, exists := names["Alice"]; exists {
        fmt.Println("Alice найдена")
    }

    // Удаление
    delete(names, "Bob")

    // Размер
    fmt.Println("Размер set:", len(names)) // 1
}

Почему именно struct{}{}? Потому что пустая структура не выделяет память. Сравните с map[string]bool — там каждое значение занимает 1 байт (bool), что для больших множеств даёт избыточность. struct{}{} — это zero-size value.

Утилитарные функции для работы с set

Вы можете обернуть map в удобные функции:

// Создание set из слайса
func NewSet[T comparable](items ...T) map[T]struct{} {
    set := make(map[T]struct{}, len(items))
    for _, item := range items {
        set[item] = struct{}{}
    }
    return set
}

// Проверка вхождения
func Contains[T comparable](set map[T]struct{}, item T) bool {
    _, exists := set[item]
    return exists
}

// Пересечение двух множеств
func Intersect[T comparable](a, b map[T]struct{}) map[T]struct{} {
    result := make(map[T]struct{})
    for k := range a {
        if _, exists := b[k]; exists {
            result[k] = struct{}{}
        }
    }
    return result
}

// Пример использования (Go 1.18+ с дженериками)
func main() {
    set1 := NewSet("a", "b", "c")
    set2 := NewSet("b", "c", "d")
    intersection := Intersect(set1, set2)
    fmt.Println(intersection) // map[b:{} c:{}]
}

Если ваш проект на Go до версии 1.18, используйте конкретные типы (например, map[string]struct{}). С дженериками код становится универсальным.

Производительность и альтернативы

Для большинства задач map[K]struct{} достаточно. Однако если вам нужны:

• Упорядоченные множества — используйте сторонние библиотеки (например, github.com/emirpasic/gods/sets).
• Потокобезопасные множества — оберните map в sync.RWMutex.
• Огромные наборы данных — рассмотрите bitset (битовые массивы) для чисел.

Но в 95% случаев идиоматический map[K]struct{} — это то, что нужно. Привыкайте к этой парадигме — она отражает философию Go: "меньше магии, больше явности".

import (
    "fmt"
    mapset "github.com/deckarep/golang-set/v2"
)

func main() {
    // Создание set
    set1 := mapset.NewSet[string]()
    set1.Add("apple", "banana", "cherry")

    set2 := mapset.NewSet[string]("banana", "date")

    // Операции
    union := set1.Union(set2)
    intersection := set1.Intersect(set2)

    fmt.Println(union)          // {apple, banana, cherry, date}
    fmt.Println(intersection)   // {banana}
    fmt.Println(set1.Contains("apple")) // true
}