Стратегия оценки

редактировать

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

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

На практике многие современные языки программирования, такие как C # и Java, сошлись на стратегии оценки вызова по значению / вызову по ссылке для вызовов функций. Некоторые языки, особенно языки нижнего уровня, такие как C ++, сочетают в себе несколько понятий передачи параметров. Исторически вызов по значению и вызов по имени восходят к АЛГОЛу 60, который был разработан в конце 1950-х годов. Вызов по ссылке используется системами PL / I и некоторыми системами Fortran. Чисто функциональные языки, такие как Haskell, а также не чисто функциональные языки, такие как R, используют вызов по необходимости.

Стратегия оценки определяется определением языка программирования и не является функцией какой-либо конкретной реализации.

Содержание
  • 1 Строгая оценка
    • 1.1 Аппликативный порядок
    • 1.2 Вызов по значению
      • 1.2.1 Неявные ограничения
    • 1.3 Вызов по ссылке
    • 1.4 Вызов посредством совместного использования
    • 1.5 Вызов путем копирования-восстановления
    • 1.6 Частичная оценка
  • 2 Нестрогий анализ
    • 2.1 Обычный порядок
    • 2.2 Вызов по имени
    • 2.3 Вызов по необходимости
    • 2.4 Вызов по раскрытию макроса
  • 3 Недетерминированные стратегии
    • 3.1 Полное β-редукция
    • 3.2 Зов будущего
    • 3.3 Оптимистическая оценка
  • 4 См. Также
  • 5 Ссылки
Строгая оценка

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

В кодировке Черча, нетерпеливое вычисление операторов сопоставляется со строгим вычислением функций; по этой причине строгую оценку иногда называют «нетерпеливой». Большинство существующих языков программирования используют строгое вычисление функций.

Аппликативный порядок

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

Вызов по значению

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

Вызов по значению - это не отдельная стратегия оценки, а скорее семейство стратегий оценки, в которых аргумент функции оценивается перед передачей в функцию. В то время как многие языки программирования (такие как Common Lisp, Eiffel и Java), которые используют вызов по значению, оценивают аргументы функции слева направо, некоторые оценивают функции и их аргументы справа налево, а другие (например, как схема, OCaml и C) не указывают порядок.

Неявные ограничения

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

Причина передачи ссылки часто заключается в том, что язык технически не обеспечивает представление значения сложных данных, а вместо этого представляет их как структуру данных, сохраняя при этом некоторое подобие внешнего вида значения в исходном коде. Часто трудно предсказать, где именно проходит граница между правильными значениями и маскирующимися под них структурами данных. В C массив (из которых строки являются особыми случаями) является структурой данных , но имя массива обрабатывается как (имеет как значение) ссылку на первый элемент массив, а имя переменной структуры struct относится к значению, даже если у него есть поля, которые являются векторами. В Maple вектор - это частный случай таблицы и, следовательно, структуры данных, но список (который отображается и может быть проиндексирован точно так же) является значением. В Tcl значения являются «двухпортовыми», так что представление значения используется на уровне сценария, а сам язык управляет соответствующей структурой данных, если таковая требуется. Изменения, внесенные через структуру данных, отражаются обратно в представление значения и наоборот.

Описание «вызов по значению, где значение является ссылкой» является общим (но не должно пониматься как вызов по ссылке); другой термин - вызов с разделением. Таким образом, поведение вызова по значению Java или Visual Basic и вызова по значению C или Pascal существенно отличается: в C или Pascal вызов функции с большой структурой в качестве аргумента будет вызывает копирование всей структуры (кроме случаев, когда это действительно ссылка на структуру), что потенциально может вызвать серьезное снижение производительности, а изменения структуры невидимы для вызывающей стороны. Однако в Java или Visual Basic копируется только ссылка на структуру, что происходит быстро, а изменения структуры видны вызывающему.

Вызов по ссылке

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

Обычно это означает, что функция может изменять (т. Е. назначать ) переменную, используемую в качестве аргумента, - то, что будет видно вызывающему. Таким образом, вызов по ссылке может использоваться для обеспечения дополнительного канала связи между вызываемой функцией и вызывающей функцией. Язык вызова по ссылке затрудняет программисту отслеживание эффектов вызова функции и может вносить небольшие ошибки. Простая лакмусовая бумажка для определения того, поддерживает ли язык семантику вызова по ссылке, - это возможность написать традиционную функцию swap (a, b)на языке.

Многие языки поддерживают вызов по ссылке в той или иной форме, но мало кто использует ее по умолчанию. FORTRAN II - ранний пример языка вызова по ссылке. Некоторые языки, такие как C ++, PHP, Visual Basic.NET, C# и REALbasic, по умолчанию вызывают по значению, но предлагают специальный синтаксис для параметров вызова по ссылке. C ++ дополнительно предлагает вызов по ссылке на const.

Вызов по ссылке может быть смоделирован на языках, которые используют вызов по значению и точно не поддерживают вызов по ссылке, используя ссылки (объекты которые относятся к другим объектам), например, указатели (объекты, представляющие адреса памяти других объектов). Такие языки, как C, ML и Rust, используют эту технику. Это не отдельная стратегия оценки - язык вызывает по значению, - но иногда ее называют «вызов по адресу» или «передача по адресу». В ML используются ссылки type- и безопасный для памяти, аналогично Rust.

Аналогичный эффект достигается вызовом путем совместного использования (передача объекта, который затем может быть изменен), используемого в таких языках, как Java, Python и Ruby.

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

Ниже приведен пример, демонстрирующий вызов по ссылке на языке программирования E :

def modify (var p, q) {p: = 27 # передается по значению: изменяется только локальный параметр q: = 27 # передано по ссылке: изменена используемая в вызове переменная}? var a: = 1 # значение: 1? var b: = 2 # значение: 2? изменить (a, b)? a # значение: 1? b # value: 27

Ниже приведен пример вызова по адресу, который имитирует вызов по ссылке в C :

void modify (int p, int * q, int * r) {p = 27; // передается по значению: изменяется только локальный параметр * q = 27; // передается по значению или ссылке, проверяем сайт вызова, чтобы определить, какой * r = 27; // передается по значению или ссылке, проверяем сайт вызова, чтобы определить, какой} int main () {int a = 1; int b = 1; int x = 1; int * c = x; изменить (a, b, c); // a передается по значению, b передается по ссылке путем создания указателя (вызов по значению), // c - указатель, передаваемый по значению // b и x изменяются return 0; }

Вызов посредством совместного использования

Вызов посредством совместного использования (также известный как «вызов посредством объекта» или «вызов посредством совместного использования объекта») - это стратегия оценки, впервые отмеченная Барбарой Лисков в 1974 для языка CLU. Он используется такими языками, как Python, Java (для ссылок на объекты), Ruby, JavaScript, Scheme, OCaml, AppleScript и многие другие. Однако термин «вызов путем совместного использования» не является общепринятым; терминология в разных источниках противоречива. Например, в сообществе Java говорят, что Java - это вызов по значению. Вызов путем совместного использования подразумевает, что значения в языке основаны на объектах, а не на примитивных типах , т. Е. Все значения имеют «упаковку ». Поскольку они упакованы в коробку, можно сказать, что они передаются по копии ссылки (где примитивы упаковываются перед передачей и распаковываются в вызываемой функции).

Семантика вызова путем совместного использования отличается от вызова по ссылке: «В частности, это не вызов по значению, потому что изменения аргументов, выполняемые вызываемой процедурой, будут видны вызывающему. И это не вызов по ссылке. потому что доступ предоставляется не к переменным вызывающего, а только к определенным объектам ". Так, например, если переменная была передана, невозможно смоделировать присвоение этой переменной в области действия вызываемого. Однако, поскольку функция имеет доступ к тому же объекту, что и вызывающий объект (копия не создается), изменения этих объектов, если объекты являются изменяемыми, внутри функции видны вызывающей стороне, что может отображаться отличаться от вызова семантикой значения. Мутации изменяемого объекта внутри функции видны вызывающему, потому что объект не копируется и не клонируется - он является общим.

Например, в Python списки изменяемы, поэтому:

def f (list): list.append (1) m = f (m) print (m)

output [1], потому что метод appendизменяет объект, для которого он вызывается.

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

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

def f (list): list = [1] m = f (m) print (m)

выводит , поскольку оператор list = [1]переназначает новый список переменной, а не месту, на которое она ссылается.

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

Хотя этот термин широко используется в сообществе Python, идентичная семантика в других языках, таких как Java и Visual Basic, часто описывается как вызов по значению, где подразумевается, что значение является ссылкой на

Вызов путем копирования-восстановления

Вызов путем копирования-восстановления - также известный как «копирование-в-копирование-выход», «вызов по результату значения», «вызов по возврату значения» (как это называется в сообществе Fortran ) - это особый случай вызова по ссылке, где предоставленная ссылка уникальна для вызывающего. Этот вариант привлек внимание в контекстах multiprocessing и Удаленный вызов процедуры : если параметр вызова функции является ссылкой, которая может быть доступна другому потоку выполнения, его содержимое может быть скопировано к новой ссылке, которой нет; когда вызов функции возвращается, обновленное содержимое этой новой ссылки копируется обратно в исходную ссылку («восстанавливается»).

Семантика вызова путем копирования-восстановления также отличается от семантики вызова по ссылке, где два или более аргумента функции псевдоним друг друга (т. Е. Указывают на одну и ту же переменную в среде вызывающего). При обращении по ссылке, письмо одному повлияет на другое; вызов методом копирования-восстановления позволяет избежать этого, предоставляя функции отдельные копии, но оставляет результат в среде вызывающего undefined в зависимости от того, какой из аргументов с псевдонимом копируется первым - будут ли копии делаться слева направо -правильный заказ как при въезде, так и при возвращении?

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

Частичная оценка

При частичной оценке оценка может продолжаться в теле функции, которая не была применена. Все подвыражения, не содержащие несвязанных переменных, оцениваются, а приложения-функции, значения аргументов которых известны, могут быть сокращены. Если есть побочные эффекты, полная частичная оценка может дать непредвиденные результаты, поэтому системы, поддерживающие частичную оценку, как правило, делают это только для «чистых» выражений (т. Е. Без побочных эффектов) внутри функций.

Нестрогая оценка

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

В кодировке Черча, ленивое вычисление операторов отображается на нестрогое вычисление функций; по этой причине нестрогие оценки часто называют «ленивыми». Булевы выражения во многих языках используют форму нестрогой оценки, называемую оценкой короткого замыкания, где оценка возвращается, как только может быть определено, что результатом будет однозначное логическое значение - например, в дизъюнктивном выражении ( ИЛИ), где встречается истина, или в конъюнктивном выражении (И), где встречается ложьи т. Д. Условные выражения также обычно используют ленивое вычисление, при котором вычисление возвращается, как только в результате возникает однозначная ветвь.

Нормальный порядок

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

Вызов по имени

Вызов по имени - это стратегия оценки, при которой аргументы функции не оцениваются до того, как функция вызывается - скорее, они подставляются непосредственно в тело функции (с использованием подстановки, предотвращающей захват ), а затем остаются для оценки всякий раз, когда они появляются в функции. Если аргумент не используется в теле функции, он никогда не вычисляется; если он используется несколько раз, он пересматривается каждый раз, когда появляется. (См. Устройство Дженсена.)

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

. Раннее использование было АЛГОЛ 60. Сегодняшние языки.NET могут моделировать вызов по имени с использованием делегатов или параметров Expression. Последнее приводит к тому, что функции передается абстрактное синтаксическое дерево . Eiffel предоставляет агентов, которые представляют операцию, которая должна быть оценена при необходимости. Seed7 обеспечивает вызов по имени с параметрами функции. Программы на Java могут выполнять аналогичные отложенные вычисления, используя лямбда-выражения и интерфейс java.util.function.Supplier.

Вызов по необходимости

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

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

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

Ленивая оценка - наиболее распространенная реализация семантики вызова по необходимости, но существуют такие варианты, как оптимистическая оценка. Языки.NET реализуют вызов по необходимости с использованием типа Ленивый .

Вызов по раскрытию макроса

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

Недетерминированные стратегии

Полное β-редукция

При «полном β-редукции » любое приложение функции может быть сокращено (подставив аргумент функции в функция, использующая замену без захвата) в любое время. Это можно сделать даже внутри непримененной функции.

Вызов по будущему

«Вызов по будущему», также известный как «параллельный вызов по имени», представляет собой стратегию параллельной оценки, в которой значение Выражение future вычисляется одновременно с потоком остальной части программы с обещаниями, также известными как Futures. Когда требуется значение обещания, основная программа блокируется до тех пор, пока обещание не получит значение (обещание или одно из обещаний завершает вычисление, если оно еще не было выполнено к тому времени).

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

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

Если реализовано с помощью сопрограммы, как в.NET async / await, создание будущего вызывает сопрограмму (асинхронная функция), которая может уступить вызывающей стороне, и, в свою очередь, возвращаться к использованию значения при совместной работе в многозадачном режиме.

Оптимистическая оценка

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

См. Также
Ссылки
Последняя правка сделана 2021-05-19 08:17:14
Содержание доступно по лицензии CC BY-SA 3.0 (если не указано иное).
Обратная связь: support@alphapedia.ru
Соглашение
О проекте