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

Go выведет для T тип int. Нетипизированная целочисленная константа получает тип по умолчанию int, если это значение представимо в int и полученный тип удовлетворяет ограничению.

Ограничение ~int | ~float64 задаёт допустимое множество типов, но не заставляет Go выбирать float64 и не превращает аргумент в абстрактный тип объединения.

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

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

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

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

Нетипизированная константа не имеет обычного конкретного типа до контекста использования. Поэтому одна и та же запись может участвовать в выражениях как int, float64 или другой числовой тип.

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

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

При выводе T Go учитывает тип аргумента. Для нетипизированной целочисленной константы без более конкретного контекста используется её тип по умолчанию — int. Затем проверяется, входит ли int в множество типов, заданное ограничением ~int | ~float64.

int удовлетворяет терму ~int, поэтому вызов корректен, а T становится именно int. Символ ~ означает, что разрешены не только сам int или float64, но и именованные типы с соответствующим базовым типом; он не меняет тип, выбранный для конкретной нетипизированной константы.

package main

import "fmt"

type Number interface { ~int | ~float64 }

func addOne[T Number](x T) T { return x + 1 }

func main() {
	v := addOne(1)
	fmt.Printf("%T
", v) // int
}

Вызов addOne(1.0) обычно выводит T как float64, поскольку нетипизированная константа с дробной частью имеет тип float64 по умолчанию. Явное указание аргумента типа, например addOne[float64](1), отменяет необходимость такого вывода и требует преобразуемости аргумента к выбранному типу.

Важное последствие: результат addOne(1) имеет тип int, а не float64. Если вызывающий код ожидает именно float64, тип следует указать явно или передать аргумент, уже имеющий тип float64.

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

Допустим, библиотека предоставляет обобщённую функцию нормализации числового значения. Разработчик вызывает её с литералом 1 и затем пытается передать результат в функцию, принимающую float64.

Первый вариант — полагаться на вывод типа. Он краток, но результатом будет int, поэтому неявного преобразования в float64 не произойдёт. Второй вариант — передать переменную типа float64; это явно задаёт нужный тип, но требует заранее объявить переменную. Третий вариант — явно указать параметр типа float64; он наиболее заметно фиксирует намерение прямо в месте вызова.

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

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

Выбирает ли ограничение ~int | ~float64 тип float64, если константа записана как 1?

Нет. Ограничение только проверяет допустимость уже выведенного кандидата. Запись 1 — нетипизированная целочисленная константа, и при отсутствии более сильного контекста её типом по умолчанию становится int. Поскольку int удовлетворяет ~int, выбор float64 не требуется.

Что произойдёт, если нетипизированная константа не представима в типе по умолчанию?

Вызов завершится ошибкой компиляции, если компилятор не сможет выбрать допустимый тип, в который значение можно представить. Например, слишком большая целочисленная константа не помещается в int; наличие ~int | ~float64 не гарантирует автоматический выбор float64, если форма константы и правила вывода не дают подходящего однозначного результата. Явное указание параметра типа может изменить контекст проверки, но само значение всё равно должно быть представимо в выбранном типе.

Можно ли получить именованный тип с базовым типом int из нетипизированной константы автоматически?

Нет. Ограничение с ~int допускает именованные типы, например пользовательский тип на основе int, но само по себе не заставляет выводить такой тип. Без явного указания параметра типа или аргумента уже именованного типа Go выберет обычный int. Поэтому сохранение семантики пользовательского типа требует передать значение этого типа или явно задать параметр типа.