Чи є причина, чому функції в більшості (?) Мов програмування розроблені для підтримки будь-якої кількості вхідних параметрів, але лише одного зворотного значення?

У більшості мов це обмеження можливо "обійти", наприклад, за допомогою використання параметрів, повернення покажчиків або шляхом визначення / повернення структур / класів. Але здається дивним, що мови програмування не були розроблені для підтримки декількох повернених значень більш "природним" способом.

Чи є для цього пояснення?

Деякі мови, як-от Python , підтримують кілька повернених значень на самому собі, тоді як деякі мови, такі як C #, підтримують їх через свої базові бібліотеки.

Але загалом, навіть у мовах, які їх підтримують, кілька повернених значень використовуються не часто, оскільки вони неохайні:

• Функції, що повертають кілька значень, важко чітко назвати .

• Легко помилитися з порядком повернутих значень

  (password, username) = GetUsernameAndPassword()  
  

  (З цієї ж причини багато людей уникають занадто великої кількості параметрів для функції; деякі навіть приймають її, якщо говорити, що функція ніколи не повинна мати двох параметрів одного типу!)

• Мови OOP вже мають кращу альтернативу декільком повернутим значенням: класи.
  Вони більш сильно набрані, вони зберігають повернені значення, згруповані як одна логічна одиниця, і зберігають імена (властивості) повернених значень у всіх напрямках.

Єдине місце , вони є дуже зручно в мовах (як Python) , де кілька значень, що повертаються з однієї функції можуть бути використані в якості декількох вхідних параметрів до іншого. Але випадки використання, коли це кращий дизайн, ніж використання класу, досить тонкі.

Тому що функції - це математичні конструкції, які виконують обчислення та повертають результат. Дійсно, багато що "під капотом" не декількох мов програмування фокусується виключно на одному вході та одному виході, при цьому кілька входів є лише тонкою обгорткою навколо входу - і коли вихід одного значення не працює, використовуючи єдиний когезивна структура (або кортеж, або Maybe) - вихід (хоча це "єдине" повернене значення складається з багатьох значень).

Це не змінилося, оскільки програмісти знайшли outпараметри незграбними конструкціями, корисними лише для обмеженого набору сценаріїв. Як і в багатьох інших речах, підтримки немає, тому що потреби / попиту немає.

У математиці "чітко визначеною" функцією є функція , де для даного входу є лише 1 вихід (як бічна примітка, ви можете мати лише одні вхідні функції, і все ще семантично отримувати кілька входів за допомогою currying ).

Для багатозначних функцій (наприклад, квадратний корінь додатного цілого числа, наприклад) достатньо повернути колекцію чи послідовність значень.

Для типів функцій, про які ви говорите (тобто функції, які повертають кілька значень, різних типів ), я бачу це дещо інакше, ніж вам здається: я бачу необхідність / використання параметів як вирішення для кращого дизайну чи більш корисна структура даних. Наприклад, я вважаю за краще, щоб *.TryParse(...)методи повернули Maybe<T>монаду, а не використовувати парам. Подумайте цей код у F #:

let s = "1"
match tryParse s with
| Some(i) -> // do whatever with i
| None -> // failed to parse

Підтримка компілятора / IDE / аналізу дуже хороша для цих конструкцій. Це дозволило б вирішити більшу частину "потреби" у парамах. Якщо чесно сказати, я не можу придумати жодних інших методів з власної сторони, де це не було б рішенням.

Для інших сценаріїв - тих, яких я не пам'ятаю - достатньо простого кортежу.

На додаток до того, що вже було сказано, коли ви дивитеся на парадигми, що використовуються при складанні, коли функція повертається, вона залишає вказівник на об'єкт, що повертається, у конкретному реєстрі. Якщо вони використовували змінні / кілька регістрів, функція виклику не знала б, де отримати повернене значення (і), якщо ця функція знаходилась у бібліотеці. Таким чином, це ускладнить зв'язок із бібліотеками, і замість того, щоб встановити довільну кількість покажчиків, що повертаються, вони пішли з одним. Мови вищого рівня не зовсім однакові виправдання.

Дуже багато випадків використання, коли ви раніше використовували кілька повернених значень, просто не потрібні в сучасних мовних функціях. Хочете повернути код помилки? Накиньте виняток або поверніть його Either<T, Throwable>. Хочете повернути необов’язковий результат? Повернути Option<T>. Хочете повернути один із декількох типів? Повернути Either<T1, T2>або теговане союз.

І навіть у випадках, коли вам справді потрібно повернути декілька значень, сучасні мови зазвичай підтримують кортежі або якусь структуру даних (список, масив, словник) або об’єкти, а також певну форму руйнування прив'язки чи узгодження шаблону, що робить упаковку ваші множинні значення в одне значення, а потім знову їх зруйнування на багатозначні значення.

Ось кілька прикладів мов, які не підтримують повернення кількох значень. Я не розумію, як додавання підтримки для декількох значень повернення зробить їх значно виразнішими, щоб компенсувати вартість нової мовної функції.

Рубін

def foo; return 1, 2, 3 end

one, two, three = foo

one
# => 1

three
# => 3

Пітон

def foo(): return 1, 2, 3

one, two, three = foo()

one
# >>> 1

three
# >>> 3

Скала

def foo = (1, 2, 3)

val (one, two, three) = foo
// => one:   Int = 1
// => two:   Int = 2
// => three: Int = 3

Хаскелл

let foo = (1, 2, 3)

let (one, two, three) = foo

one
-- > 1

three
-- > 3

Perl6

sub foo { 1, 2, 3 }

my ($one, $two, $three) = foo

$one
# > 1

$three
# > 3

Справжньою причиною того, що одне повернене значення є настільки популярним, є вирази, які використовуються у багатьох мовах. Будь-якою мовою, де ви можете мати вираз, як x + 1ви вже думаєте, з точки зору єдиних повернутих значень, оскільки ви оцінюєте вираз у голові, розбиваючи його на шматки та визначаючи значення кожної частини. Ви дивитесь xі вирішуєте, що його значення дорівнює 3 (наприклад), і ви дивитесь на 1, а потім на васx + 1і складемо все разом, щоб вирішити, що значення цілого дорівнює 4. Кожна синтаксична частина виразу має одне значення, а не будь-яке інше число значень; це природна семантика виразів, яких очікують усі. Навіть коли функція повертає пару значень, вона все-таки дійсно повертає одне значення, яке виконує роботу двох значень, тому що уявлення про функцію, яка повертає два значення, які якимось чином не згорнуті в одну колекцію, надто дивна.

Люди не хочуть мати справу з альтернативною семантикою, яка потрібна, щоб функції повернули більше ніж одне значення. Наприклад, на мові, що базується на стеці, як Forth, ви можете мати будь-яку кількість повернених значень, тому що кожна функція просто модифікує верхню частину стека, спливає входи та натискає виходи за бажанням. Ось чому Forth не має такого виразу, як у звичайних мов.

Perl - це ще одна мова, яка іноді може діяти так, як функції повертають кілька значень, хоча зазвичай це просто вважається поверненням списку. Способи списку "інтерполяції" в Perl дають нам такі списки, (1, foo(), 3)які можуть містити 3 елементи, як це очікувала більшість людей, які не знають Perl, але так само легко можуть мати лише 2 елементи, 4 елементи або будь-яку більшу кількість елементів, залежно від foo(). Списки в Perl сплющені так, що синтаксичний список не завжди має семантику списку; це може бути просто шматок більшого списку.

Іншим способом, щоб функції повертали кілька значень, було б мати альтернативну семантику вираження, де будь-яке вираження може мати кілька значень, і кожне значення представляє можливість. Візьміть x + 1ще раз, але на цей раз уявіть, що xмає два значення {3, 4}, тоді значення x + 1будуть {4, 5}, а значення x + xбуде {6, 8}, а може бути {6, 7, 8} , залежно від того, чи дозволяється однією оцінкою використовувати кілька значень для x. Мова подібної може бути реалізована за допомогою зворотного відстеження, як і Prolog, щоб дати кілька відповідей на запит.

Коротше кажучи, виклик функції - це єдина синтаксична одиниця, а одна синтаксична одиниця має єдине значення в семантиці вираження, яку ми всі знаємо і любимо. Будь-яка інша семантика змусить вас до дивних способів вчинити такі дії, як Perl, Prolog або Forth.

Як запропоновано у цій відповіді , мова йде про технічну підтримку, хоча традиція в мовному дизайні також грає певну роль.

коли функція повертається, вона залишає вказівник на об'єкт, що повертається, у певному регістрі

З трьох перших мов, Fortran, Lisp та COBOL, перша використовувала єдине повернене значення, як воно моделювалося з математики. Другий повертав довільну кількість параметрів так само, як і отримував їх: як список (можна також стверджувати, що він лише передав і повертав один параметр: адресу списку). Третє поверне нуль або одне значення.

Ці перші мови сильно вплинули на дизайн мов, які слідували за ними, хоча єдиний, який повернув кілька значень, Лісп, ніколи не набирав великої популярності.

Коли C з'явився під впливом мов, що передували йому, він зосередив увагу на ефективному використанні апаратних ресурсів, підтримуючи тісну зв'язок між тим, що зробив мова С та машинним кодом, який його реалізував. Деякі з найдавніших його функцій, такі як змінні "auto" та "register", є результатом цієї філософії дизайну.

Слід також зазначити, що мова складання була широко популярною до 80-х років, коли її нарешті почали виводити з лайн розвитку. Люди, які писали компілятори та створювали мови, були знайомі зі складанням, і здебільшого дотримувались того, що там найкраще працювало.

Більшість мов, які відходили від цієї норми, ніколи не знаходили великої популярності, а отже, ніколи не відігравали сильної ролі, що впливали на рішення дизайнерів мови (які, звичайно, були натхнені тим, що вони знали).

Тож давайте розглянемо мову складання. Давайте спочатку розглянемо 6502 , мікропроцесор 1975 року, який знаменито використовували мікрокомп'ютери Apple II та VIC-20. Це було дуже слабко порівняно з тим, що використовувалося в мейнфреймі та мінікомп'ютерах того часу, хоча й потужним порівняно з першими комп’ютерами за 20, 30 років до цього, на зорі мов програмування.

Якщо ви подивитесь на технічний опис, у нього є 5 регістрів плюс кілька однобітних прапорів. Єдиним "повним" реєстром був лічильник програм (ПК) - той регістр вказує на наступну інструкцію, яку потрібно виконати. Інші регістри, де акумулятор (A), два "індексні" регістри (X і Y) і вказівник стека (SP).

Виклик підпрограми вводить ПК у пам'ять, на яку вказує SP, а потім зменшує SP. Повернення з підпрограми працює в зворотному порядку. На стеку можна натиснути та витягнути інші значення, але важко посилатися на пам'ять щодо SP, тому писати підпрограми для повторного вступу було важко. Ця річ, яку ми сприймаємо як належне, викликаючи підпрограму в будь-який час, коли нам здається, не була такою поширеною в цій архітектурі. Часто створюється окремий "стек", щоб параметри та повернення підпрограми залишалися окремими.

Якщо ви подивитеся на процесор, який надихнув 6502, 6800 , він мав додатковий регістр, індекс регістру (IX), ширину як SP, який міг отримати значення від SP.

На машині виклик підпрограми повторного учасника полягав у натисканні параметрів на стеку, натисканні ПК, зміні ПК на нову адресу, і тоді підпрограма підштовхує свої локальні змінні на стек . Оскільки кількість локальних змінних і параметрів відома, їх адресація може бути виконана відносно стека. Наприклад, функція, яка отримує два параметри і має дві локальні змінні, виглядатиме так:

SP + 8: param 2
SP + 6: param 1
SP + 4: return address
SP + 2: local 2
SP + 0: local 1

Його можна назвати будь-яку кількість разів, оскільки весь тимчасовий простір знаходиться на стеці.

8080 , який використовується на ТРС-80 і безліч CP / M мікрокомп'ютерів на основі могли б зробити що - щось схоже на 6800, натиснувши SP на стек , а потім вискакують його на непрямому регістрі, HL.

Це дуже поширений спосіб реалізації речей, і він отримав ще більшу підтримку більш сучасних процесорів, з базовим покажчиком, який робить демпінг усіх локальних змінних перед поверненням простий.

Проблема полягає в тому, як повернути щось ? Реєстри процесорів були не дуже численні на ранніх етапах, і часто потрібно було використовувати деякі з них навіть для того, щоб дізнатися, до якого фрагмента пам'яті потрібно звернутися. Повернення речей у стеку було б складним: вам доведеться вискакувати все, зберегти ПК, натиснути параметри повернення (які зберігатимуться там, де тим часом?), Потім знову натиснути ПК та повернутися.

Тож зазвичай робилося резервування одного регістра для значення повернення. Код, що викликає, знав, що повернене значення буде в певному реєстрі, яке повинно бути збережене, поки воно не може бути збережене або використане.

Давайте розглянемо мову, яка дійсно дозволяє отримати кілька повернених значень: Forth. Що Форт робить, це зберігати окремий стек повернення (RP) та стек даних (SP), так що вся функція повинна була виконати поп всі його параметри і залишити значення повернення на стеку. Оскільки стек повернення був окремим, він не заважав.

Як хтось, хто навчився мовою складання та Forth за перші шість місяців досвіду роботи з комп’ютерами, багатозначні повернені значення мені здаються цілком нормальними. Такі оператори, як Forth /mod, які повертають ціле поділ та інші, здаються очевидними. З іншого боку, я легко бачу, як хтось, чий ранній досвід був розумом С, вважає цю концепцію дивною: це суперечить їх вродженим очікуванням, що таке "функція".

Що стосується математики ... ну, я програмував комп'ютери так, перш ніж потрапити на функції на уроках математики. Там є цілий розділ CS і мов програмування , який під впливом математики, але, знову ж , є цілий розділ , який не є.

Таким чином, у нас є сукупність факторів, коли математика впливала на раннє мовне проектування, де обмеження в техніці диктували те, що легко реалізувати, і де популярні мови впливали на розвиток екіпірування обладнання (машинні процесори Lisp і машинні процесори Forth були справжніми труднощами в цьому процесі).

Функціональні мови, про які я знаю, можуть легко повертати кілька значень за допомогою використання кортежів (у динамічно набраних мовах ви навіть можете використовувати списки). Також кортежі підтримуються іншими мовами:

f :: Int -> (Int, Int)
f x = (x - 1, x + 1)

// Even C++ have tuples - see Boost.Graph for use
std::pair<int, int> f(int x) {
  return std::make_pair(x - 1, x + 1);
}

У наведеному вище прикладі f- це функція, що повертає 2 вставки.

Аналогічно, ML, Haskell, F # тощо можуть також повертати структури даних (покажчики занадто низькі для більшості мов). Я не чув про сучасну мову GP з таким обмеженням:

data MyValue = MyValue Int Int

g :: Int -> MyValue
g x = MyValue (x - 1, x + 1)

Нарешті, outпараметри можна імітувати навіть у функціональних мовах за допомогою IORef. Є кілька причин, чому немає вбудованої підтримки для змінних більшості мов:

• Незрозуміла семантика : чи відображається наступна функція 0, або 1? Я знаю мови, які надрукували б 0, і ті, які друкувалимуться 1. Є користь для обох (як з точки зору продуктивності, так і відповідності ментальній моделі програміста):

  int x;
  
  int f(out int y) {
    x = 0;
    y = 1;
    printf("%d\n", x);
  }
  f(out x);
  

• Не локалізовані ефекти : Як і в наведеному вище прикладі, ви можете виявити, що у вас може бути довгий ланцюг, і найпотужніша функція впливає на глобальний стан. Загалом, це ускладнює міркування про те, які вимоги функції є, і якщо зміна є законною. Зважаючи на те, що більшість сучасних парадигм намагаються або локалізувати ефекти (інкапсуляція в ООП), або усунути побічні ефекти (функціональне програмування), це суперечить цим парадигмам.

• Зайві : якщо у вас є кортежі, у вас 99% функціональності outпараметрів і 100% ідіоматичного використання. Якщо ви додасте вказівники до суміші, ви покриєте решту 1%.

У мене виникають проблеми з назвою однієї мови, яка не могла повернути кілька значень за допомогою кортежу, класу чи outпараметра (і в більшості випадків дозволено 2 або більше цих методів).

Я думаю, це через вирази , наприклад (a + b[i]) * c.

Вирази складаються з "однини" значень. Таким чином, функція, що повертає особливе значення, може бути безпосередньо використана в виразі замість будь-якої з чотирьох змінних, показаних вище. Багатовивірна функція є принаймні дещо незграбною у виразі.

Я особисто вважаю , що це річ , що особливого особливої повертається. Ви могли б обходити це, додаючи синтаксис, щоб вказати, яке з кількох повернених значень ви хочете використовувати в виразі, але воно, мабуть, буде більш незграбним, ніж старі добрі математичні позначення, які є стислими і знайомі всім.

Це трохи ускладнює синтаксис, але на рівні реалізації не існує вагомих причин не допустити цього. На відміну від деяких інших відповідей, повернення кількох значень, якщо вони доступні, призводить до більш чіткого та ефективного коду. Я не можу підрахувати, як часто я хотів би повернути X і Y, або булевий "успіх" і корисне значення.

У більшості мов, де підтримуються функції, ви можете використовувати виклик функції в будь-якому місці, де може використовуватися змінна цього типу: -

x = n + sqrt(y);

Якщо функція повертає більше одного значення, це не працюватиме. Динамічно набрані мови, такі як python, дозволять вам це зробити, але, в більшості випадків, це призведе до помилки часу запуску, якщо не вдасться зробити щось розумне зробити з кортежем посеред рівняння.

Я просто хочу спиратися на відповідь Гарві. Я спочатку знайшов це запитання на веб-сайті новин (arstechnica) і знайшов дивовижне пояснення того, що я відчуваю, що дійсно відповідає суті цього питання і не має всіх інших відповідей (крім Harvey's):

Походження єдиного повернення від функцій полягає в машинному коді. На рівні машинного коду функція може повернути значення в регістрі А (акумулятор). Будь-які інші значення повернення будуть на стеку.

Мова, яка підтримує два значення повернення, буде компілювати її як машинний код, який повертає одне, а друге кладе в стек. Іншими словами, друге повернене значення в будь-якому випадку закінчиться як вихідний параметр.

Це як запитати, чому присвоєння є однією змінною за раз. Ви можете мати мову, яка дозволяє, наприклад, a, b = 1, 2. Але це закінчилося б на рівні машинного коду a = 1, а потім b = 2.

Існує певна аргументація того, що конструкції мови програмування мають певну схожість з тим, що буде насправді, коли код буде зібраний і запущений.

Почалося з математики. FORTRAN, названий "Переклад формули", був першим компілятором. FORTRAN був і орієнтується на фізику / математику / техніку.

COBOL, майже такий як старий, не мав явного повернення; У нього ледь не було підпрограм. З тих пір пройшло переважно за інерцією.

Go , наприклад, має кілька значень, що повертаються, і результат стає чистішим і менш двозначним , ніж при використанні «вихід» параметри. Після невеликого використання, це дуже природно і ефективно. Я рекомендую враховувати кілька повернених значень для всіх нових мов. Можливо, і для старих мов.

Це, мабуть, має більше спільного з спадщиною того, як здійснюються виклики функцій в інструкціях на процесорній машині, і тим, що всі мови програмування походять від машинного коду: наприклад, C -> Assembly -> Machine.

Як процесори виконують функціональні дзвінки

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

Тепер щодо того, чому процесори були розроблені таким чином ... це, швидше за все, було питання про обмеження ресурсів.