Замыкание (программирование)

Замыкание (англ. closure) в программировании — это различные методики передачи в функцию первого класса (она же callback) информации о переменных вне её тела^[1]. Другими словами, замыкание состоит из 1) ссылки на функцию, и 2) пакета данных, показывающего, при каких обстоятельствах функцию вызвали — и наоборот, функция может модифицировать этот пакет, чтобы передать наружу, что случилось при её исполнении. Простейший пример: операция сортировки массива принимает функцию сравнения, в эту функцию окольным путём передаётся, по какому полю сортировать, и тем же окольным путём функция накапливает статистику, сколько было сравнений.

Замыкание, так же как и экземпляр объекта, есть способ представления функциональности и данных, связанных и упакованных вместе.

Существуют различные методики создания замыканий:

• Глобальная переменная, с той скидкой, что теряется реентерабельность — стандартная библиотека Си вроде qsort.
• Дополнительный параметр, который гарантированно передаётся неизменным и позволяет упаковать небольшой объект или передать по ссылке большой — низкоуровневые библиотеки наподобие WinAPI^[2];
• Объект с операцией «вызов», создаваемый каждый раз,— Си++, Java. Такой объект также может перехватывать локальные переменные и/или ссылаться на текущий объект this, связывая внутреннюю функцию с местом, где она определена в коде.
  • Чтобы разнотипные объекты можно было однообразно вызывать, существуют несколько разных подходов: они поддерживают один и тот же интерфейс (Java), метапрограммирование (немалая часть Си++ вроде std::sort), промежуточный объект std::function и более лёгкие вроде function_ref, берущие тонкости типа на себя (тоже Си++).
• Нужные данные автоматически содержатся в любой ссылке на функцию — PHP, JavaScript^[1], Ruby.
• Метод объекта вместе с указателем на сам объект — Delphi.

Основное назначение замыкания (в любом виде) — разделение ответственности между слоями кода: «библиотечная» функция готовит данные, функция с «пользовательского» слоя обрабатывает. Примерные сценарии: при наступлении события вызвать пользовательскую функцию^[3], обойти несколько объектов и для каждого вызвать пользовательскую функцию^[2], провести сортировку в пользовательском порядке^[4]… Чтобы библиотека не теряла общность, «пользовательская» функция обязана иметь нейтральную сигнатуру, не выдающую, какими сторонними данными происходит обмен.

Условный пример: библиотечная функция-генератор пройтиПростыеЧисла умеет отыскивать среди чисел простые, но ничего с ними не делает и взамен вызывает для обработки пользовательскую функцию-потребителя добавитьВСписок. (Замыкание сделано дополнительным параметром на манер WinAPI — даже такой примитивной конструкции хватает, чтобы разделить ответственность. Стрелкой ↑ будем обозначать ссылки там, где важна именно такая передача данных.)

функция добавитьВСписок(x : целое, замык : ↑объект) (замык → ↑список).добавь(x) y : список пройтиПростыеЧисла(1000, добавитьВСписок, y)

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

1. Программирование в структурном стиле — внешний вызов и внутреннее тело напоминают составной оператор. В частности, генераторы данных и итераторы^[3].

   y : список пройтиПростыеЧисла(1000, [↑y](x : целое) → y.добавь(x) )

   Такая конструкция отличается от оператора for лишь тем, что внутри тело функции, а не тело цикла. Аналогом continue будет return, а аналога break в общем случае нет.

2. Программирование в функциональном стиле — функции первого класса, карринг, композиция функций^[3].

   функция форматироватьВалюту(валюта : строка, точность : целое) вернуть [валюта, точность](x : дробное) → форматировать(x, точность) + " " + валюта форматироватьЕвро := форматироватьВалюту("€", 2) // получаем объект-функцию дробное → строка

3. Один из способов сделать скрытые (доступные только объекту-владельцу) данные, не пересекающиеся ни с другими объектами, ни с глобальными переменными^[3].

   функция сделатьСчётчик() n := 0 вернуть [изменяемая n]() → n++ // объект-функция без параметров возвращает числа 0, 1, 2…, // даже после того, как локальная переменная n исчезнет

   Принцип действует и в Си++, и в JavaScript/Ruby, но несколько по-разному: в Си++ переменная n, перехваченная по копии, находится внутри объекта и никак не связана с локальной n. JavaScript и Ruby перехватывают по ссылке, но запоминают контекст, откуда была создана функция, и сколько функций, столько контекстов^[5].

4. Для принципа «не повторяйся». В Си нередко повторяющийся код оформляют как макрос препроцессора, потому что иначе трудоёмко перехватить локальные переменные. Замыкания снимают всю трудоёмкость:

   s := "alpha,bravo,charlie" начало := 0 сброс := [s, ↑начало](конец : целое) → напечатать s[начало..конец)  // или иным образом обработать кусок строки цикл i := [0..|s|) если s[i] = ',' сброс(i) начало := i + 1 сброс(|s|)

5. Чтобы оформить небольшой объект как функцию — для кэширования предыдущих вызовов, фильтрации ввода и другого^[3].

Больше примеров смотрите в викиучебнике.

(define (make-adder n)       ; возвращает замкнутое лямбда-выражение  (lambda (x)                ; в котором x - связанная переменная,    (+ x n)                  ; а n - свободная (захваченная из внешнего контекста)  ))(define add1 (make-adder 1)) ; делаем процедуру для прибавления 1(add1 10)                    ; вызываем её, возвращает 11(define sub1 (make-adder -1)); делаем процедуру для вычитания 1(sub1 10)                    ; вызываем её, возвращает 9

'use strict';const add = function(x) {  return function(y) {    const z = x + y;    console.log(x + '+' + y + '=' + z);    return z;  };};const res = add(3)(6); // вернёт 9 и выведет в консоль 3+6=9console.log(res);

'use strict';const add = x => y => {  const z = x + y;  console.log(x + '+' + y + '=' + z);  return z;};const res = add(3)(6); // вернёт 9 и выведет в консоль 3+6=9console.log(res);

'use strict';const add = x => y => {  const z = x + y;  console.log(x + '+' + y + '=' + z);  return add(z);};const res = add(1)(4)(6)(9);console.log(res);/* 1+4=5   5+6=11   11+9=20   [Function]*/

functionadd($x){returnfunction($y)use($x){// <-- анонимная функция (замыкание)return$x+$y;};// <-- эта точка с запятой здесь нужна!}echoadd(3)(5).PHP_EOL;// Выведет: 8$f=add(3);var_dump($f);// Выведет: object(Closure)echo$f(6).PHP_EOL;// Выведет: 9

functionpower($arr,$exp){// переменная $func будет хранить ссылку на объект класса Closure, который описывает наше замыкание$func=function($el)use($exp){return$el**$exp;};returnarray_map($func,$arr);}$list=[1,3,4];var_dump(power($list,2));// Выведет: array(3) {[0]=>int(1) [1]=>int(9) [2]=>int(16)}var_dump(power($list,3));// Выведет: array(3) {[0]=>int(1) [1]=>int(27) [2]=>int(64)}

• Анонимная функция
• Лямбда-исчисление с типами
• Подстановка
• Модель акторов