Обобщения в Go 1.18

Введение

В этом лабе представляется концепция обобщений в Golang. Начиная с версии 1.18, Golang добавил поддержку обобщений, что позволяет нам писать более гибкий и повторно используемый код.

Обобщения

Проблема, которую нужно решить в этом лабе - это понять, как определять и использовать обобщенные функции и типы в Golang.

• Разобраться с концепцией обобщений в Golang.
• Знать, как определять обобщенные функции с параметрами типа и ограничениями.
• Знать, как определять обобщенные типы с параметрами типа.
• Разобраться, как определять методы для обобщенных типов.
• Знать, как вызывать обобщенные функции с выводом типа.

$ go run generics.go
keys: [4 1 2]
list: [10 13 23]

Ниже представлен полный код:

// Начиная с версии 1.18, Go добавил поддержку
// _обобщений_, также известных как _параметры типа_.

package main

import "fmt"

// В качестве примера обобщенной функции, `MapKeys`
// принимает карту любого типа и возвращает срез ее ключей.
// Эта функция имеет два параметра типа - `K` и `V`;
// `K` имеет ограничение `comparable`, что означает, что
// мы можем сравнивать значения этого типа с помощью операторов `==` и `!=`.
// Это необходимо для ключей карты в Go.
// `V` имеет ограничение `any`, что означает, что оно не ограничено никак (`any` - это псевдоним для `interface{}`).
func MapKeys[K comparable, V any](m map[K]V) []K {
    r := make([]K, 0, len(m))
    for k := range m {
        r = append(r, k)
    }
    return r
}

// В качестве примера обобщенного типа, `List` - это
// односвязный список с значениями любого типа.
type List[T any] struct {
    head, tail *element[T]
}

type element[T any] struct {
    next *element[T]
    val  T
}

// Мы можем определять методы для обобщенных типов так же,
// как и для обычных типов, но мы должны сохранить параметры типа на месте.
// Тип - это `List[T]`, а не `List`.
func (lst *List[T]) Push(v T) {
    if lst.tail == nil {
        lst.head = &element[T]{val: v}
        lst.tail = lst.head
    } else {
        lst.tail.next = &element[T]{val: v}
        lst.tail = lst.tail.next
    }
}

func (lst *List[T]) GetAll() []T {
    var elems []T
    for e := lst.head; e!= nil; e = e.next {
        elems = append(elems, e.val)
    }
    return elems
}

func main() {
    var m = map[int]string{1: "2", 2: "4", 4: "8"}

    // При вызове обобщенных функций мы часто можем полагаться
    // на _вывод типа_. Обратите внимание, что мы не должны
    // указывать типы для `K` и `V` при вызове `MapKeys` - компилятор автоматически выводит их.
    fmt.Println("keys:", MapKeys(m))

    //... хотя мы могли бы также указать их явно.
    _ = MapKeys[int, string](m)

    lst := List[int]{}
    lst.Push(10)
    lst.Push(13)
    lst.Push(23)
    fmt.Println("list:", lst.GetAll())
}

Резюме

Обобщения - это мощный инструмент, который позволяет нам писать более гибкий и повторно используемый код в Golang. С использованием обобщений мы можем определять функции и типы, которые работают с любым типом, при условии, что они удовлетворяют определенным ограничениям. Используя обобщения, мы можем уменьшить дублирование кода и повысить читаемость и поддерживаемость кода.