Привет, Хабр!

Дженерики (или generics) существуют во многих языках, таких как Java, C#, и Rust, но для Go это относительно новая фича, введенная в версии 1.18.

До версии 1.18 Go был известен своим строгим и простым подходом к типизации. Однако, с ростом сообщества стало очевидно, что нужен более гибкий инструмент для работы с различными типами данных. Все вечно сталкивались с проблемами, когда им приходилось писать много шаблонного кода для разных типов данных или использовать интерфейсы и пустые интерфейсы.

Go представила предложение по введению дженериков, которое после долгих обсуждений и тестирований было реализовано в версии 1.18. Это был ответ на просьбу сообщества. + к карме

Дженерики позволяют писать более чистый и понятный код. Вы определяете общую структуру один раз, и затем можете использовать её с любым типом данных.

Кратко пройдемся по базе:

Типы как параметры

Допустим, вы хотите написать функцию, которая возвращает первый элемент из любого слайса. Без дженериков вам пришлось бы писать отдельную функцию для каждого типа данных. Но с Type Parameters вы пишете всего одну функцию:

func First[T any](s []T) T {
    return s[0]
}

T — это type parameter. Он может быть чем угодно: int, string, вашим пользовательским типом, чем угодно. А any — это ограничение, которое в данном случае может быть абсолютно любым типом

Type set

Type Sets (в Go версиях ниже 1.18 назывались Contracts) — это способ описания ограничений на типы, которые могут быть использованы с дженериками.

Допустим, вы пишете универсальную функцию, которая должна работать только с числами. Без Contracts вы были бы вынуждены полагаться на добросовестность других разработчиков (и мы знаем, как это бывает ненадежно). Но с Contracts вы можете явно указать, что ваша функция работает только с типами, которые поддерживают арифметические операции:

type Number interface {
    int | float64 // только целые и вещественные числа.
}

func Sum[T Number](a, b T) T {
    return a + b
}

Type inference

Type inference пытается угадать, что вы имеете в виду, не заставляя вас перечислять каждую мелочь. Когда вы вызываете функцию с дженериками, Go смотрит на аргументы и пытается вывести типы из контекста:

package main

import "fmt"

// Generic функция, которая работает с любым типом.
func Print[T any](s T) {
    fmt.Println(s)
}

func main() {
    // Go выводит тип параметра T как int.
    Print(123)

    // Go выводит тип параметра T как string.
    Print("Hello, Generics!")
}

Иногда Go может сказать: "У тебя слишком много вариантов, я не могу выбрать." Это происходит, когда информации недостаточно для однозначного вывода, или когда ваш код настолько загадочен, что даже умный компилятор в ступоре:

package main

import "fmt"

func Merge[T any, U any](first T, second U) {
    fmt.Println(first, second)
}

func main() {
    // явное указание типов необходимо, так как Go не может однозначно вывести их
    Merge[int, string](42, "The answer is")
}

Если Go не может самостоятельно вывести тип, вы можете дать ему подсказку, явно указав тип при вызове функции как в 11 строчке кода выше.

Все это звучит классно, но нужно помнить, что дженерики — это не просто синтаксический сахар, они могут влиять на производительность вашего кода. Потому что каждая специализация дженерик-функции или типа создает новую версию этой функции или типа для каждого используемого набора типов.

Дженерики в Go

Constraints и type sets

Constraints, или ограничения типов - это способ указать, какие типы данных могут быть использованы в наших дженериках.

Допустим, вы хотите создать функцию, которая работает с числами. Без дженериков, вам пришлось бы писать отдельные функции для int, float64, и так далее. Но с дженериками и constraints, вы можете сделать это в одном маху. Вот как:

package main

import "fmt"

// Определяем наш собственный constraint.
type Number interface {
    int | float64 // Может быть int или float64.
}

// UniversalAdd принимает два параметра любого типа, определенного в Number.
func UniversalAdd[T Number](a, b T) T {
    return a + b
}

func main() {
    // Работает с int.
    fmt.Println(UniversalAdd[int](1, 2))

    // Работает с float64.
    fmt.Println(UniversalAdd[float64](1.5, 2.3))
}

UniversalAdd - это функция, которая может складывать числа любого типа, определенного в Number. Это оч. удобно. Одна функция для всех числовых типов.

Вам не нужно писать отдельные функции для каждого типа данных.

comparable, any

comparable - это специальный интерфейс, который говорит нам, что типы данных могут быть сравнены с помощью операторов == и !=:

package main

import "fmt"

// Distinct позволяет нам убедиться, что все эементы в слайсе уникальны
func Distinct[T comparable](list []T) []T {
    unique := make(map[T]bool)
    var result []T
    for _, item := range list {
        if !unique[item] {
            unique[item] = true
            result = append(result, item)
        }
    }
    return result
}

func main() {
    // Работает с любым сравнимым типом
    fmt.Println(Distinct([]int{1, 2, 2, 3, 4, 4, 4, 5}))
    fmt.Println(Distinct([]string{"котик", "кошечка", "кот", "кошка"}))
}

Distinct использует comparable для создания универсального метода удаления дубликатов из слайса.

Теперь перейдем к any. Это базовый интерфейс в Go, который, по сути, может быть чем угодно:

package main

import "fmt"

// PrintAny принимает слайс любых элементов и печатает их.
func PrintAny(items []any) {
    for _, item := range items {
        fmt.Println(item)
    }
}

func main() {
    // Можем смешивать разные типы данных!
    PrintAny([]any{1, "apple", true, 3.14})
}

PrintAny принимает слайс элементов любого типа и печатает их.

Универсальные функции

Начнем с классики - функции обмена значениями, Swap. Без дженериков, вам нужно было бы писать отдельную функцию для каждого типа данных, но с ними все гораздно удобнее:

package main

import "fmt"

// Swap меняет местами значения двух переменных любого типа.
func Swap[T any](a, b *T) {
    *a, *b = *b, *a
}

func main() {
    x := 1
    y := 2
    Swap(&x, &y)
    fmt.Println(x, y) // Выведет: 1 2

    s1 := "Hello"
    s2 := "Habr"
    Swap(&s1, &s2)
    fmt.Println(s1, s2) // Выведет: Hello Habr
}

Swap использует any, что означает, что она может работать с любым типом данных. Это как универсальный ключ к миру переменных!

Создадим что-то более сложное - универсальную структуру кэша:

package main

import "fmt"

// Cache - универсальная структура кэша.
// T - тип хранимых значений.
type Cache[T any] struct {
    store map[string]T
}

// NewCache создает новый экземпляр Cache.
func NewCache[T any]() *Cache[T] {
    return &Cache[T]{store: make(map[string]T)}
}

// Set добавляет значение в кэш.
func (c *Cache[T]) Set(key string, value T) {
    c.store[key] = value
}

// Get возвращает значение из кэша.
func (c *Cache[T]) Get(key string) (T, bool) {
    val, found := c.store[key]
    return val, found
}

func main() {
    // Создаем кэш для int.
    intCache := NewCache[int]()
    intCache.Set("key1", 10)
    fmt.Println(intCache.Get("key1")) // Выведет: 10 true

    // Создаем кэш для string.
    stringCache := NewCache[string]()
    stringCache.Set("hello", "world")
    fmt.Println(stringCache.Get("hello")) // Выведет: world true
}

Cache - это универсальная структура, которая может хранить значения любого типа. Вы можете создать кэш для целых чисел, строк, или чего угодно, что захотите.

Применение

Слайсы:

Слайсы могут растягиваться и сжиматься, принимая на себя все, что вы им предложите. Используя дженерики, мы можем создать универсальные функции для работы со слайсами любых типов, к примеру создадим функцию фильтрации:

package main

import "fmt"

// Filter принимает слайс и функцию-предикат, возвращая новый слайс с элементами, удовлетворяющими условию.
func Filter[T any](slice []T, predicate func(T) bool) []T {
    var result []T
    for _, v := range slice {
        if predicate(v) {
            result = append(result, v)
        }
    }
    return result
}

func main() {
    // Фильтруем слайс целых чисел.
    ints := []int{1, 2, 3, 4, 5}
    even := Filter(ints, func(n int) bool { return n%2 == 0 })
    fmt.Println(even) // Выведет: [2 4]

    // Фильтруем слайс строк.
    strings := []string{"apple", "banana", "cherry"}
    withA := Filter(strings, func(s string) bool { return s[0] == 'a' })
    fmt.Println(withA) // Выведет: ["apple"]
}

Очереди и стеки

Очередь следует принципу FIFO, а стек — LIFO. С дженериками, мы можем создать эти структуры так, чтобы они работали с любыми типами данных:

package main

import "fmt"

// Stack представляет собой универсальный стек.
type Stack[T any] struct {
    elements []T
}

// Push добавляет элемент в стек.
func (s *Stack[T]) Push(value T) {
    s.elements = append(s.elements, value)
}

// Pop удаляет и возвращает верхний элемент стека.
func (s *Stack[T]) Pop() (T, bool) {
    if len(s.elements) == 0 {
        var zero T // Возвращаем нулевое значение для типа T.
        return zero, false
    }
    last := s.elements[len(s.elements)-1]
    s.elements = s.elements[:len(s.elements)-1]
    return last, true
}

func main() {
    stack := Stack[int]{}
    stack.Push(1)
    stack.Push(2)
    fmt.Println(stack.Pop()) // Выведет: 2 true
    fmt.Println(stack.Pop()) // Выведет: 1 true
    fmt.Println(stack.Pop()) // Выведет: 0 false (стек пуст)
}

Деревья

С дженериками, мы можем создать универсальные деревья, которые могут хранить любые данные. Универсальное бинарное дерево поиска выглядит так:

package main

import "fmt"

// TreeNode представляет узел в бинарном дереве поиска.
type TreeNode[T any] struct {
    Value T
    Left  *TreeNode[T]
    Right *TreeNode[T]
}

// Insert добавляет значение в бинарное дерево поиска.
func (n *TreeNode[T]) Insert(value T, compare func(a, b T) int) {
    if compare(value, n.Value) < 0 {
        if n.Left == nil {
            n.Left = &TreeNode[T]{Value: value}
        } else {
            n.Left.Insert(value, compare)
        }
    } else {
        if n.Right == nil {
            n.Right = &TreeNode[T]{Value: value}
        } else {
            n.Right.Insert(value, compare)
        }
    }
}

// InOrder обходит дерево в порядке возрастания.
func (n *TreeNode[T]) InOrder(visit func(T)) {
    if n == nil {
        return
    }
    n.Left.InOrder(visit)
    visit(n.Value)
    n.Right.InOrder(visit)
}

func main() {
    root := &TreeNode[int]{Value: 5}
    root.Insert(3, func(a, b int) int { return a - b })
    root.Insert(7, func(a, b int) int { return a - b })
    root.Insert(1, func(a, b int) int { return a - b })
    root.Insert(9, func(a, b int) int { return a - b })

    root.InOrder(func(value int) {
        fmt.Println(value)
    })
    // Выведет числа в порядке возрастания: 1, 3, 5, 7, 9
}

Сортировка

QuickSort — это база, которую знает каждый. Он быстр, эффективен и, благодаря дженерикам, может быть адаптирован для работы с любым типом данных:

package main

import "fmt"

// QuickSort сортирует слайс любого сравнимого типа.
func QuickSort[T any](data []T, compare func(a, b T) bool) {
    if len(data) < 2 {
        return
    }
    left, right := 0, len(data)-1
    pivot := len(data) / 2
    data[pivot], data[right] = data[right], data[pivot]
    for i := range data {
        if compare(data[i], data[right]) {
            data[left], data[i] = data[i], data[left]
            left++
        }
    }
    data[left], data[right] = data[right], data[left]
    QuickSort(data[:left], compare)
    QuickSort(data[left+1:], compare)
}

func main() {
    slice := []int{9, 4, 6, 2, 10, 3}
    QuickSort(slice, func(a, b int) bool { return a < b })
    fmt.Println(slice) // Выведет: [2 3 4 6 9 10]
}
=

Binary search

package main

import "fmt"

// BinarySearch ищет элемент в отсортированном слайсе и возвращает его индекс.
func BinarySearch[T any](data []T, target T, compare func(a, b T) int) int {
    low, high := 0, len(data)-1
    for low <= high {
        mid := (low + high) / 2
        comparison := compare(data[mid], target)
        if comparison == 0 {
            return mid
        } else if comparison < 0 {
            low = mid + 1
        } else {
            high = mid - 1
        }
    }
    return -1
}

func main() {
    slice := []int{2, 3, 4, 6, 9, 10}
    fmt.Println(BinarySearch(slice, 6, func(a, b int) int { return a - b })) // Выведет: 3
}

Фабрики

С дженериками, мы можем создать универсальные фабрики, способные порождать объекты любого типа:

package main

import "fmt"

// Creator определяет интерфейс для фабрики.
type Creator[T any] func() T

// NewInstance создает новый экземпляр типа T.
func NewInstance[T any](create Creator[T]) T {
    return create()
}

// Примеры типов, которые мы можем создавать.
type (
    Book struct{ Title string }
    Game struct{ Name string }
)

func main() {
    bookCreator := func() Book { return Book{Title: "The Go Programming Language"} }
    gameCreator := func() Game { return Game{Name: "Cyberpunk 2077"} }

    book := NewInstance(bookCreator)
    game := NewInstance(gameCreator)

    fmt.Println(book.Title) // Выведет: The Go Programming Language
    fmt.Println(game.Name)  // Выведет: Cyberpunk 2077
}

Декораторы

Декоратор позволяет динамически добавлять новую функциональность объектам. С дженериками, мы можем создать универсальные декораторы, которые работают с любыми типами:

package main

import "fmt"

// Decorator оборачивает функцию, добавляя новую функциональность.
func Decorator[T any](fn func(T), decorator func(T) T) func(T) {
    return func(input T) {
        fn(decorator(input))
    }
}

func main() {
    print := func(n int) { fmt.Println("Number:", n) }
    double := func(n int) int { return n * 2 }

    decorated := Decorator(print, double)
    decorated(5) // Выведет: Number: 10
}

Дженерики позволяют создавать более абстрактные и универсальные компоненты.

Новички, помните о том, что дженерики - это не панацея и не стоит их использовать везде. Иногда лучше простой код.

Подробнее с дженериками можно ознакомиться на официальном сайте golang. А если вы хотите освоить конкретный язык программирования, заглядывайте в каталог онлайн-курсов OTUS, от ведущих экспертов индустрии.

Keep coding, keep improving, и до новых встреч на Хабре.

и... с наступающим Новым Годом! ????