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

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

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

Swift разделяет два назначения параметров: типизация вызова и читаемость API. Метка делает место вызова понятнее человеку, но для передачи функции как значения достаточно знать типы её параметров и результата.

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

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

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

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

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

Метки аргументов не являются частью записи типа вроде (Int, Int) -> String. Они задают форму вызова функции и учитываются при разрешении перегрузок, но после получения значения функции вызывающий код работает с её типом без этих меток.

func describe(_ value: Int) -> String {
    "позиционный: \(value)"
}

func describe(value: Int) -> String {
    "именованный: \(value)"
}

print(describe(1))
print(describe(value: 1))

let positional: (Int) -> String = describe(_:)
print(positional(2))

В первых двух вызовах метки выбирают разные перегрузки. В последнем выражении describe(_:) явно выбирает позиционную перегрузку, а переменная positional имеет тип (Int) -> String; вызвать её можно без исходной метки.

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

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

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

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

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

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

Можно ли объявить две функции, различающиеся только меткой аргумента?

Да, такие объявления могут быть перегрузками. Например, process(_:) и process(value:) имеют разные формы вызова, хотя тип значения каждой функции может быть (Int) -> Result. Компилятор выбирает перегрузку по контексту вызова и указанной метке.

Почему аннотация типа не всегда разрешает перегрузку при передаче функции?

Потому что перегруженные функции могут иметь одинаковый тип функции, если различаются только метками. Тип (Int) -> String не содержит информации, нужна ли метка _ или value. В такой ситуации требуется явная ссылка вроде process(_:) или process(value:).

Нарушит ли переименование метки совместимость с вызывающим кодом?

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