Замыкания в функциональном программировании

Замыкания в Groovy

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

Концепцию замыканий поддерживают и многие другие языки, включая Javascript и Python. Однако в разных языках характеристики и функционирование замыканий различаются.

Мы рассмотрим ключевые аспекты замыканий в Groovy, попутно демонстрируя примеры их использования.

2. Что такое замыкание?

Замыкание — это анонимный блок кода. В Groovy он является экземпляром класса Closure. Замыкания могут принимать 0 или более параметров и всегда возвращают значение.

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

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

3. Объявление замыкания

Замыкание Groovy содержит параметры, стрелку -> и код для выполнения. Параметры являются необязательными и, если они указаны, то разделены запятыми.

3.1. Базовая декларация

Здесь замыкание printWelcome при вызове печатает выражение. Приведем небольшой пример унарного замыкания:

Замыкание print принимает один параметр ( name ) и при вызове печатает его.

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

def formatToLowerCase(name) < return name.toLowerCase() >def formatToLowerCaseClosure = < name ->return name.toLowerCase() >

Здесь у метода и соответствующего замыкания поведение схожее. Однако между ними есть тонкие различия, которые мы рассмотрим далее в разделе «Замыкания и методы».

3.2. Выполнение

Мы можем выполнить замыкание двумя способами — вызвать его, как любой другой метод, или воспользоваться методом call .

Например, как в случае с обычным методом:

print("Hello! Closure") formatToLowerCaseClosure("Hello! Closure")

И выполнение с помощью метода call :

print.call("Hello! Closure") formatToLowerCaseClosure.call("Hello! Closure")

4. Параметры

Параметры замыканий Groovy аналогичны параметрам обычных методов.

4.1. Неявный параметр

Мы можем определить унарное замыкание без параметра, поскольку, когда они не заданы, Groovy предполагает наличие неявного параметра под именем «it»:

def greet = < return "Hello! $" > assert greet("Alex") == "Hello! Alex"

4.2. Перемножение параметров

Вот замыкание, которое принимает два параметра и возвращает результат их перемножения:

def multiply = < x, y ->return x*y > assert multiply(2, 4) == 8

4.3. Типы параметров

В примерах, рассмотренных до сих пор, тип параметров не задавался. Тем не менее, мы можем задать тип параметров замыкания. Например, перепишем метод multiply с учетом других операций:

def calculate = def result = 0 switch(operation) < case "ADD": result = x+y break case "SUB": result = x-y break case "MUL": result = x*y break case "DIV": result = x/y break >return result > assert calculate(12, 4, "ADD") == 16 assert calculate(43, 8, "DIV") == 5.375

4.4. Varargs (Variable Arguments)

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

def addAll = < int. args ->return args.sum() > assert addAll(12, 10, 14) == 36

5. Замыкание как аргумент

Мы можем передать Closure в качестве аргумента в обычный метод Groovy. Это позволяет методу вызывать наше замыкание для выполнения своей задачи, что позволяет настраивать его поведение.

Рассмотрим простой пример: вычисление объема правильных фигур.

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

Поэтому мы напишем метод volume , который в качестве аргумента принимает замыкание areaCalculator , а реализацию вычисления площади будем передавать при вызове:

def volume(Closure areaCalculator, int. dimensions) < if(dimensions.size() == 3) < return areaCalculator(dimensions[0], dimensions[1]) * dimensions[2] >else if(dimensions.size() == 2) < return areaCalculator(dimensions[0]) * dimensions[1] >else if(dimensions.size() == 1) < return areaCalculator(dimensions[0]) * dimensions[0] >> assert volume( < l, b ->return l*b >, 12, 6, 10) == 720

Найдем объем конуса тем же способом:

assert volume( < radius ->return Math.PI*radius*radius/3 >, 5, 10) == Math.PI * 250/3

6. Вложенные замыкания

Мы можем объявлять и вызывать замыкания внутри замыкания.

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

def calculate = def log = < println "Performing $it" >def result = 0 switch(operation) < case "ADD": log("Addition") result = x+y break case "SUB": log("Subtraction") result = x-y break case "MUL": log("Multiplication") result = x*y break case "DIV": log("Division") result = x/y break >return result >

7. Ленивая оценка строк

Strings (Строки) Groovy обычно оцениваются и интерполируются во время их создания. Например:

def name = "Samwell" def welcomeMsg = "Welcome! $name" assert welcomeMsg == "Welcome! Samwell"

Даже если мы модифицируем значение переменной name, сообщение welcomeMsg не изменится:

name = "Tarly" assert welcomeMsg != "Welcome! Tarly"

Интерполяция замыкания позволяет обеспечить ленивую оценку Strings , пересчитанную из текущих значений вокруг них. Например:

def fullName = "Tarly Samson" def greetStr assert greetStr == "Hello! Tarly Samson"

Только в этот раз изменение переменной влияет и на значение интерполированной строки:

fullName = "Jon Smith" assert greetStr == "Hello! Jon Smith"

8. Замыкания в коллекциях

Коллекции Groovy используют замыкания во многих своих API. Например, определим список элементов и выведем его на печать с помощью унарного замыкания each , которое имеет неявный параметр:

def list = [10, 11, 12, 13, 14, true, false, "BUNTHER"] list.each < println it >assert [13, 14] == list.findAll< it instanceof Integer && it >= 13 >

Зачастую у нас может возникнуть необходимость создать список по карте, основываясь на каком-либо критерии. Например:

def map = [1:10, 2:30, 4:5] assert [10, 60, 20] == map.collect

9. Замыкания и методы

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

В отличие от обычного метода Groovy:

• Мы можем передавать Closure в качестве аргумента методу.
• Унарные замыкания могут использовать неявный параметр it
• Мы можем присвоить Closure переменной и выполнить его позже, как метод или с помощью call
• Groovy определяет возвращаемый тип замыканий во время рантайма
• Мы можем объявлять и вызывать замыкания внутри самого замыкания
• Замыкания всегда возвращают значение

Таким образом, замыкания имеют преимущества перед обычными методами и являются мощной фичей Groovy.

10. Заключение

В этой статье мы рассмотрели, как создавать замыкания в Groovy, и выяснили способы их применения.

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

Как всегда, код и юнит-тесты из этой статьи доступны на GitHub.

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

Источник

Что такое замыкание в программировании

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

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

Область видимости определяет, к каким переменным функция, команда или другая переменная может получить доступ, а к каким нет. Проще говоря, что каждая функция «видит» — видит ли она те переменные и объекты, которые созданы за её пределами? Видит ли она то, что вложено в функции, которые запускаются внутри неё?

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

Стек — это как список задач при выполнении программы. Сначала компьютер исполняет один код, внутри которого появляется какая-то функция — это как будто отдельная программа. Компьютер откладывает текущую программу, делает себе в стеке пометку «вернуться сюда, когда доделаю новую программу» и исполняет эту новую функцию. Исполнил — смотрит в стек, куда вернуться. Возвращается туда.

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

Что такое замыкание

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

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

Звучит сложно, объясним на примерах.

Пример замыкания в коде

Сделаем функцию, которая вернёт нам фразу «Привет, …» вместе с именем, которое мы в него отправим. Но сделаем это через замыкание — чтобы посмотреть, как именно всё устроено.

Обратите внимание на две переменные в конце: mike и maxim. По сути, эти переменные — ссылки на вызов результата функции hello(), но с конкретным параметром.

// внешняя функция function hello(name) < // внутренняя функция-замыкание // возвращаем её как результат работы внешней return function() < // внутренняя функция выводит сообщение на экран console.log("Привет, " + name); >> // создаём новые переменные, используя замыкание mike = hello("Миша"); maxim = hello("Максим") // запускаем внутреннюю функцию с нашими параметрами, просто указав имена переменной mike(); maxim();

Ещё один пример, посложнее

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

Для примера сделаем замыкание и заведём две переменные — каждая будет выдавать сообщение со своим началом фразы, а продолжение будем передавать им в виде параметра:

// внешняя функция, у которой есть свой параметры function greeting(hi) < // внутренняя функция-замыкание, тоже со своим параметром // возвращаем её как результат работы внешней return function(name) < // внутренняя функция выводит сообщение на экран console.log(hi + ", " + name); >> // создаём новые переменные, используя замыкание morning = greeting("Доброе утро"); thnx = greeting("Спасибо за комментарий") // запускаем внутреннюю функцию с нашими параметрами, указав параметры вызова morning("коллеги"); thnx("Павел");

Причём здесь область видимости

Из последнего примера видно, что объявление переменных происходит так:

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

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

Всё дело в том, что при замыкании создаётся как бы виртуальное окружение, в котором и хранится значение из внешней функции. А вот как это работает с точки зрения области видимости:

Зачем нужны замыкания

На замыканиях строится около половины алгоритмов в функциональном программировании. А ещё на них можно построить много разного:

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

Что дальше

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

Источник