Краткий ответ

Значения функционального типа в Go можно сравнивать только с nil. Сравнение двух значений-функций запрещено на этапе компиляции, даже если они имеют одинаковую сигнатуру или ссылаются на одну функцию.

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

Исторический контекст

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

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

Постановка проблемы

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

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

Подробное решение

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

package main

import "fmt"

type Handler func(string)

func main() {
	var h Handler
	fmt.Println(h == nil)
	// fmt.Println(h == Handler(nil)) // допустимо: сравнение с nil
	// fmt.Println(h == another)      // ошибка компиляции
}

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

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

Функции также нельзя использовать как ключи map и нельзя включать в сравнение структур через ==. Структура с полем функционального типа сама становится несравнимой.

Если требуется определить, зарегистрирован ли обработчик, следует сравнивать не функции, а внешний идентификатор: строку, целое число, перечисление или отдельный объект-дескриптор. Это делает критерий идентичности явным, но требует поддерживать соответствие между идентификатором и обработчиком.

Ситуация из практики

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

Второй вариант — использовать reflect.ValueOf(handler).Pointer(). Он может дать адрес точки входа функции, но разные замыкания с одной реализацией могут иметь одинаковый адрес кода. Поэтому такой подход не решает задачу идентификации экземпляров и связывает логику с техническим представлением значения.

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

Что кандидаты часто упускают

Можно ли сравнить функцию с типизированным nil того же функционального типа?

Да. Это всё ещё сравнение значения функции с nil, а не сравнение двух функций. Например, переменную типа Handler можно сравнить с Handler(nil); результат показывает, установлено ли функциональное значение.

Что произойдёт при сравнении двух интерфейсов, содержащих функции?

Интерфейсы сначала сравниваются по динамическим типам. Если типы различаются, значения не равны; если совпадают, Go пытается сравнить динамические значения. Функциональный тип несравним, поэтому сравнение интерфейсов с таким одинаковым динамическим типом приводит к панике во время выполнения, а не к обычному результату false.

Почему структуру с полем-функцией нельзя сравнивать оператором ==?

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