Типы функций и функции высшего порядка на Go

Введение

В мире программирования благодаря обращению с функциями как объектами первого класса открывается много возможностей.

Так, в Go имеется поддержка функций первого класса и типов функций, поэтому разработчики пишут более чистый, модульный, гибкий код.

Когда мы говорим, что функции считаются объектами первого класса, имеем в виду именно это.

Это означает, что они могут присваиваться переменным, передаваться как аргументы другим функциям и возвращаться из функций. Такая возможность связана с определением типов функций.

Рассмотрим концепции типов функций и функций высшего порядка на Go, как они определяются и применяются для повышения эффективности и удобства восприятия кодовой базы.

Что такое «функции высшего порядка»?

Это функции, которыми в качестве аргументов принимаются другие функции и/или возвращаются функции. С ними разработчики пишут более универсальный и переиспользуемый код.

Изучим варианты применения, в которых задействуются функции высшего порядка.

Обратные вызовы

Допустим, с каждым элементом списка функцией выполняется некая операция.

Если делать это не напрямую из функции, а через ее аргумент  —  другую функцию, в одной и той же функции можно выполнять различные операции в зависимости от условий:

package main

import "fmt"

func Process(list []int, callback func(int)) {
    for _, item := range list {
        callback(item)
    }
}

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    Process(numbers, func(num int) {
        fmt.Println(num * 2)
    })
}

// Вывод
2
4
6
8
10

Анонимные функции

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

package main

import (
  "sort"
  "fmt"
)

func main() {
    words := []string{"apple", "banana", "orange", "grape"}
    sort.Slice(words, func(i, j int) bool {
        return len(words[i]) < len(words[j])
    })
    fmt.Println(words) // Вывод: [apple grape banana orange]
}

Преимущество: это лаконичный, гибкий способ встроенного определения функций, не нужны отдельные их объявления.

Замыкание

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

package main

import "fmt"

func counter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}

func main() {
    increment := counter()
    fmt.Println(increment()) // Вывод: 1
    fmt.Println(increment()) // Вывод: 2
    fmt.Println(increment()) // Вывод: 3
}

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

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

Композиция функций

Композиция функций  —  это объединение нескольких функций в одну. 
Вот пример, в котором из двух функций формируется новая:

package main

import "fmt"

func addOne(num int) int {
    return num + 1
}

func double(num int) int {
    return num * 2
}

func main() {
    addOneThenDouble := func(num int) int {
        return double(addOne(num))
    }

    result := addOneThenDouble(5)
    fmt.Println(result) // Вывод: 12
}

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

Обработка ошибок

Функциями высшего порядка распространяются ошибки. 
Вот пример, где такой функцией оборачивается функция и обрабатываются ошибки:

package main

import (
 "errors"
 "fmt"
)

func handleErrors(fn func() error) error {
 if err := fn(); err != nil {
  return fmt.Errorf("error occurred: %v", err)
 }
 return nil
}

func main() {
 err := handleErrors(func() error {
  // Моделирование операции, при которой возвращается ошибка
  return errors.New("something went wrong")
 })
 if err != nil {
  fmt.Println("Error handled:", err)
 } else {
  fmt.Println("No error occurred")
 }
}

// Вывод
Error handled: error occurred: something went wrong

Тестирование

С помощью функций высшего порядка получаются функции-заглушки для тестирования. 
Вот пример, где функция-заглушка передается в тестируемую функцию:

package main

import "fmt"

type DependencyFunc func(int) int

func FunctionUnderTest(dep DependencyFunc, num int) int {
    return dep(num) * 2
}

func main() {
    result := FunctionUnderTest(func(num int) int {
        return num + 1 // Имитированная зависимость
    }, 5)
    fmt.Println(result) // Вывод: 12
}

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

Главное удобство применения заключается в получении из одной функции разных выходных данных в зависимости от окружения или исходя из условий.

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

Производительность оптимизируется минимизацией лишних вызовов функций. Вот пример, в котором накладные расходы сокращаются при помощи замыкания:

package main

import "fmt"

func main() {
    sum := 0
    add := func(num int) {
        sum += num
    }

    for i := 0; i < 100; i++ {
        add(i)
    }

    fmt.Println(sum) // Вывод: 4950
}

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

Совместимость и взаимозаменяемость

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

package main

import "fmt"

type Operator interface {
    Operate(int, int) int
}

type Adder struct{}

func (a Adder) Operate(x, y int) int {
    return x + y
}

type Multiplier struct{}

func (m Multiplier) Operate(x, y int) int {
    return x * y
}

func main() {
    var op Operator
    op = Adder{}
    fmt.Println(op.Operate(2, 3)) // Вывод: 5

    op = Multiplier{}
    fmt.Println(op.Operate(2, 3)) // Вывод: 6
}

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

Но у каждой медали есть оборотная сторона. В зависимости от ряда факторов функции высшего порядка тоже влияют на производительность.

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

Накладные расходы вызова функции

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

При использовании функций высшего порядка, которыми принимаются или возвращаются функции, появляются дополнительные накладные расходы, связанные с передачей указателей функции или замыканий.

Накладные расходы замыканий

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

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

Встраивание

В некоторых случаях простые функции высшего порядка встраиваются компиляторами, вызов функции фактически заменяется телом функции.

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

Возможности оптимизации

Функциями высшего порядка предоставляются возможности оптимизации, такие как объединение циклов или специализация функций.

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

Однако при проведении этих оптимизаций требуется тщательное рассмотрение вопросов проектирования и реализации.

Повышенный расход памяти

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

Это сказывается на объеме занимаемой памяти и локальности кэша, а в перспективе  —  на производительности системы в целом, особенно в средах с ограниченной памятью.

Тестирование производительности и профилирование

Чтобы оценить влияние функций высшего порядка на производительность, требуется тщательное ее тестирование и профилирование.

Чтобы выявить узкие места производительности, настоятельно рекомендуется измерить время выполнения и расход ресурсов в сегментах кода с функциями высшего порядка и без них.

Заключение

Функциями высшего порядка в качестве аргументов принимаются другие функции и/или возвращаются функции, они применяются с интерфейсами и дженериками.

Благодаря этому появляется возможность переиспользовать код и манипулировать его поведением в промежутках между выполнениями, имитируя нужные зависимости или функциональность.

Функции высшего порядка, несмотря на мощь и гибкость, сказываются на производительности из-за накладных расходов, связанных с вызовами функций и замыканиями.

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

Читайте также:

• Что такое Recover в Golang?
• Как использовать перечисления в Golang
• Топ-10 самых распространенных ошибок в проектах Go. Часть 2

Читайте нас в Telegram, VK и Дзен

---

Перевод статьи Nidhi D: Function Types and Higher-Order Functions in Go + полная версия статьи