Анонимные функции c: C#. Делегаты. Анонимные функции и методы. Примеры кода

Содержание

Kotlin. Анонимные функции

Статья проплачена кошками — всемирно известными производителями котят.

Если статья вам понравилась, то можете поддержать проект.

В Kotlin часто используется особый вид функций — анонимные функции. Функции можно не давать имя после ключевого слова fun и она станет анонимной.

val a: (Int) -> Int = fun(i: Int) = i + 3
println(a(4)) // 7

Анонимная функция прибавляет к заданному значению число 3.

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

В стандартной библиотеке есть функция count() для подсчёта числа символов в строке.

val charNumber = "Васька".count()
println(charNumber) // выводит 6

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

val charNumber = "Васька".  count({letter -> letter == 'а'})
println(charNumber) // выводит 2

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

Если заглянуть под капот, то увидим, что функция принимает анонимную функцию в аргументе типа (Char) -> Boolean с именем predicate. Функция predicate принимает аргумент Char и возвращает булево значение.

public inline fun CharSequence.count(
    predicate: (Char) → Boolean
): Int

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

println(
        {
            val year = 2019
            "Добро пожаловать в $year год"
        }()
)

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

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

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

val messageFunction: () -> String =
        {
            val year = 2019
            "Добро пожаловать в $year год"
        }
println(messageFunction())

Разберём синтаксис. Сначала объявляется переменная messageFunction. После имени переменной идёт двоеточие и функциональный тип. Функциональный тип объявляется в виде конструкции

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

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

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

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

val messageFunction =
        {
            val year = 2019
            "Добро пожаловать в $year год"
        }
println(messageFunction())

Разберём случаи с аргументами. Перепишем предыдущий пример, добавив один аргумент.

val messageFunction: (String) -> String =
        {
            catName ->
            val year = 2019
            "$catName! Добро пожаловать в $year год"
        }
println(messageFunction("Васька"))

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

Здесь также можно использовать автоматическое определение типов и сократить код. Но в этом случае у параметров следует указать тип.

val messageFunction =
        {
            catName: String ->
            val year = 2019
            "$catName! Добро пожаловать в $year год"
        }
println(messageFunction("Васька"))

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

Ключевое слово it

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

it.

Переделаем предыдущий пример. Удаляем имя параметра и стрелку в начале анонимной функции и добавляем it.

val messageFunction: (String) -> String =
        {
            val year = 2019
            "$it! Добро пожаловать в $year год"
        }
println(messageFunction("Васька"))

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

// другой вариант примера из начала статьи
val charNumber = "Васька". count({it -> it == 'а'})
println(charNumber) // выводит 2
// оптимизированный вариант без круглых скобок
val charNumber = "Васька".count { it -> it == 'а'}
println(charNumber) // выводит 2

Несколько аргументов

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

val messageFunction: (String, Int) -> String =
        { catName, age ->
            val year = 2019
            "$catName! Добро пожаловать в $year год. Вам исполнилось $age лет"
        }
println(messageFunction("Васька", 5))

Выражение теперь объявляет два параметра, catName и age, и принимает два аргумента. Так как теперь больше одного параметра в выражении, ключевое слово it использовать нельзя.

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

Дополнительное чтение

Функции в языке программирования Erlang

Главная

Туториалы
Программирование
Erlang

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

Синтаксис объявления функции выглядит следующим образом:


FunctionName(Pattern1… PatternN) ->
Body;

FunctionName — имя функции — это атом.
Pattern1 … PatternN — Каждый аргумент является шаблоном. Число аргументов N — это арность функции. Функция уникально определяется именем модуля, именем функции и arity. То есть две функции с одним и тем же именем и в одном модуле, но с разными уровнями — две разные функции.
Body — состоит из последовательности выражений, разделенных запятой (,):

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


-module(helloworld). 
-export([add/2,start/0]). 

add(X,Y) -> 
   Z = X+Y, 
   io:fwrite("~w~n",[Z]). 
   
start() -> 
   add(5,6).

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

Мы определяем две функции: один называется add, который принимает 2 параметра, а другой — функцию начала
Обе функции определяются с помощью функции экспорта. Если мы этого не сделаем, мы не сможем использовать эту функцию
Одна функция может быть вызвана внутри другой. Здесь мы вызываем функцию add из функции start

Анонимные функции

Анонимная функция — это функция, у которой нет имени, связанного с ней. У Erlang есть возможность определять анонимные функции. Следующая программа является примером анонимной функции.


-module(helloworld). 
-export([start/0]). 

start() -> 
   Fn = fun() -> 
      io:fwrite("Anonymous Function") end, 
   Fn().

Необходимо отметить следующие моменты в приведенном выше примере.

Анонимная функция определяется ключевым словом fun ()
Функция назначается переменной Fn.
Функция вызывается через имя переменной.

Функции с несколькими аргументами

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


-module(helloworld). 
-export([add/2,add/3,start/0]). 

add(X,Y) -> 
   Z = X+Y, 
   io:fwrite("~w~n",[Z]). 
   
add(X,Y,Z) -> 
   A = X+Y+Z, 
   io:fwrite("~w~n",[A]). 
 
start() ->
   add(5,6), 
   add(5,6,6).

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

Функции с охранными последовательностями

Функции в Erlang также могут иметь защитные последовательности. Это не что иное, как выражения, которые только при оценке на true вызовут функцию. Синтаксис функции с защитной последовательностью показан в следующей программе.


FunctionName(Pattern1… PatternN) [when GuardSeq1]->
Body;

FunctionName — имя функции — это атом.
Pattern1 … PatternN — Каждый аргумент является шаблоном. Число аргументов N — это арность функции. Функция уникально определяется именем модуля, именем функции и arity. То есть две функции с одним и тем же именем и в одном модуле, но с разными уровнями — две разные функции.
Body — предложения — состоит из последовательности выражений, разделенных запятой (,).
GuardSeq1 — это выражение, которое оценивается при вызове функции.

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


-module(helloworld). 
-export([add/1,start/0]). 

add(X) when X>3 -> 
   io:fwrite("~w~n",[X]). 

start() -> 
   add(4).

Самовстраиваемые анонимные функции в C++

Дополнительные ресурсы

Мой последний пост о встраивании лямбда-выражений в C++.
Мой интерпретатор лямбда-исчисления как шаблонная метапрограмма C++.
Шаблоны C++: полное руководство, которое я используется для этих постов.

Короткая версия

Каждый лямбда-терм складывает свое определение в свой тип, например, лямбда. (x, x * x) имеет тип Sum < Arg, Arg > , где A — тип метапеременная x . Таким образом, везде, где применяется термин лямбда, достаточно информация для метапрограммы шаблона, чтобы развернуть тип обратно в тело функции.

Разбираем

Чтобы понять, как это работает, давайте разберем пример:

 интегрировать (лямбда (х, х * х), 0,0, 1,0, 10000) ;

Передача анонимных функций как типов

Прототип интегрировать функция:

шаблон <имя типа F>
статический встроенный
двойное интегрирование (F f, двойное a, двойное b, int n) ;

Здесь опытный программист на C++ может быть озадачен: тип параметра функции ( F ) кажется неограниченным. На практике тип, который мы передаем для этого параметра, будет кодировать все информация, необходимая для реконструкции функции, которую мы хотим вызывать. Поскольку шаблоны расширяются лениво, если мы передаем тип, который не кодировать функцию, мы получим ошибку времени компиляции, когда она попытается встроить его.

Вызов анонимных функций

Заглянув внутрь функции , интегрируем , мы увидим как это делается; вместо вызова f(x) мы видим:

 ... Встроенный::at(x) ...

На самом деле компилятор предупреждает, что параметр времени выполнения f даже не используется! (Это хороший показатель того, что все, что происходит, происходит во время компиляции.)

Итак, ясно, что Inline — это шаблон метапрограмма, которая реконструирует выражение, эквивалентное функция описывается F и на статических функция-член встраивает это выражение со своим аргументом вместо аргумент функции.

Построение анонимных функций

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

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

Мы будем использовать базовый класс Exp для представления выражения с синтаксическим деревом, закодированным как тип T :

шаблон <имя типа T>
структура опыта {
  шаблон <имя типа M>
  Оператор Prod * (M m) ;
  шаблон <имя типа M>
  Оператор суммы + (M m) ;
} ;

Обратите внимание, как оператор вложенного члена шаблона перегружается для сложение и умножение сохраняют структуру вычисления в полученном типе. Итак, если у нас есть два выражения e1 и e2 типы которых представляют выражения времени компиляции, то тип e1 + e1 представляет выражение времени компиляции, которое вычисляет их сумму.

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

// Целочисленная константа:
шаблон 
структура I: public Exp > {
  статический I v ;
} ;
// Аргумент функции типа T:
шаблон <имя типа T>
struct Arg : public Exp< Arg > {} ;
// Сумма двух выражений:
шаблон <имя типа R1, имя типа R2>
struct Sum: public Exp > {};
// Произведение двух выражений:
шаблон <имя типа R1, имя типа R2>
struct Prod: public Exp > {};