Функциональный объект - Function object

Эта статья о концепции компьютерного программирования. О функторах в математике см. Функтор.

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

Описание

Типичное использование объекта функции в письменной форме Перезвоните функции. Обратный звонок в процедурные языки, Такие как C, может быть выполнено с помощью указатели на функции.[2] Однако может быть сложно или неудобно передавать состояние в функцию обратного вызова или из нее. Это ограничение также препятствует более динамичному поведению функции. Функциональный объект решает эти проблемы, поскольку функция на самом деле фасад для полноценного объекта, несущего собственное состояние.

Многие современные (и некоторые более старые) языки, например C ++, Эйфель, Groovy, Лисп, Болтовня, Perl, PHP, Python, Рубин, Scala, и многие другие, поддерживают первоклассная функция предметы и даже могут существенно их использовать.[3] Функциональное программирование языки дополнительно поддерживают закрытие, то есть первоклассные функции, которые могут "закрывать" переменные в окружающей их среде во время создания. Во время компиляции преобразование, известное как лямбда-лифтинг преобразует замыкания в функциональные объекты.

В C и C ++

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

#включают <stdlib.h>/ * функция обратного вызова qsort (), возвращает <0, если a  0, если a> b, 0, если a == b * /int сравнить(const пустота* а, const пустота* б){    возвращаться (*(int *)а - *(int *)б));}...// прототип qsort// void qsort (void * base, size_t nel, size_t width, int (* compare) (const void *, const void *));...int главный(пустота){    int Предметы[] = { 4, 3, 1, 2 };    qsort(Предметы, размер(Предметы) / размер(Предметы[0]), размер(Предметы[0]), сравнить);    возвращаться 0;}

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

// предикат компаратора: возвращает true, если a структура IntComparator{  bool оператор()(const int &а, const int &б) const  {    возвращаться а < б;  }};int главный(){    стандартное::вектор<int> Предметы { 4, 3, 1, 2 };    стандартное::Сортировать(Предметы.начинать(), Предметы.конец(), IntComparator());    возвращаться 0;}

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

структура Сравнить{    const стандартное::нить SORT_FIELD;    Сравнить(const стандартное::нить& sort_field="имя")      : SORT_FIELD(sort_field)    {        / * проверка поля sort_field * /    }        bool оператор()(const Наемный рабочий& а, const Наемный рабочий& б)    {        если (SORT_FIELD == "имя")            возвращаться а.имя < б.имя;        еще если (SORT_FIELD == "возраст")            возвращаться а.возраст < б.возраст;        еще если (SORT_FIELD == "иднум")            возвращаться а.idnum < б.idnum;        еще            / * выбросить исключение или что-то в этом роде * /    }};int главный(){    стандартное::вектор<Наемный рабочий> эмпс;        / * код для заполнения базы данных * /        // Сортируем базу по идентификационному номеру сотрудника    стандартное::Сортировать(эмпс.начинать(), эмпс.конец(), Сравнить("иднум"));        возвращаться 0;}

В C ++ 11 лямбда-выражение предоставляет более сжатый способ сделать то же самое.

int главный(){    стандартное::вектор<Наемный рабочий> эмпс;    / * код для заполнения базы данных * /    const стандартное::нить sort_field = "иднум";    стандартное::Сортировать(эмпс.начинать(), эмпс.конец(), [&sort_field](const Наемный рабочий& а, const Наемный рабочий& б){ / * код для выбора и сравнения поля * / });    возвращаться 0;}


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

IntComparator cpm;bool результат = cpm(а, б);

В дополнение к функторам типов классов в C ++ возможны и другие типы объектов функций. Они могут воспользоваться указателем-членом C ++ или шаблон удобства. Выразительность шаблонов позволяет некоторым функциональное программирование методы, которые будут использоваться, такие как определение функциональных объектов в терминах других функциональных объектов (например, функциональная композиция ). Большая часть C ++ Стандартная библиотека шаблонов (STL) активно использует функциональные объекты на основе шаблонов.

Поддержание состояния

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

#включают <algorithm>#включают <iostream>#включают <iterator>учебный класс Считать от { общественный:  Считать от(int считать) : считать_(считать) {}    int оператор()() { возвращаться считать_++; } частный:  int считать_;};int главный() {  const int государственный(10);  стандартное::generate_n(стандартное::ostream_iterator<int>(стандартное::cout, " п"), 11,                  Считать от(государственный));}

В C ++ 14 или новее приведенный выше пример можно переписать как:

#включают <algorithm>#включают <iostream>#включают <iterator>int главный() {  стандартное::generate_n(стандартное::ostream_iterator<int>(стандартное::cout, " п"), 11,                  [считать=10]() изменчивый { возвращаться считать++; });}

В C #

В C #, функциональные объекты объявляются через делегаты. Делегат может быть объявлен с использованием именованного метода или лямбда-выражение. Вот пример использования именованного метода.

с помощью Система;с помощью System.Collections.Generic;общественный учебный класс ComparisonClass1{    общественный статический int Сравнить(int Икс, int у)    {        возвращаться Икс - у;    }    общественный статический пустота Главный()    {        вар Предметы = новый Список<int> { 4, 3, 1, 2 };        Сравнение<int> дель = Сравнить;        Предметы.Сортировать(дель);    }}

Вот пример использования лямбда-выражения.

с помощью Система;с помощью System.Collections.Generic;общественный учебный класс ComparisonClass2{    общественный статический пустота Главный()    {        вар Предметы = новый Список<int> { 4, 3, 1, 2 };        Предметы.Сортировать((Икс, у) => Икс - у);    }}

В D

D предоставляет несколько способов объявления объектов функций: в стиле Lisp / Python через закрытие или в стиле C # через делегаты, соответственно:

bool найти(Т)(Т[] стог сена, bool делегировать(Т) игла_тест) {  для каждого (солома; стог сена) {    если (игла_тест(солома))      возвращаться истинный;  }  возвращаться ложный;}пустота главный() {    int[] стог сена = [345, 15, 457, 9, 56, 123, 456];    int   иголка = 123;    bool NeedleTest(int п) {      возвращаться п == иголка;    }    утверждать(найти(стог сена, &NeedleTest));}

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

пустота главный() {    int[] стог сена = [345, 15, 457, 9, 56, 123, 456];    int   иголка = 123;    утверждать(найти(стог сена, (int п) { возвращаться п == иголка; }));}

Чтобы компилятор мог встроить код (см. Выше), функциональные объекты также могут быть указаны в стиле C ++ через перегрузка оператора:

bool найти(Т, F)(Т[] стог сена, F игла_тест) {  для каждого (солома; стог сена) {    если (игла_тест(солома))      возвращаться истинный;  }  возвращаться ложный;}пустота главный() {    int[] стог сена = [345, 15, 457, 9, 56, 123, 456];    int   иголка = 123;    учебный класс NeedleTest {      int иголка;      это(int п) { иголка = п; }      bool opCall(int п) {        возвращаться п == иголка;      }    }    утверждать(найти(стог сена, новый NeedleTest(иголка)));}

В Эйфеле

в Эйфель метод и язык разработки программного обеспечения, операции и объекты всегда рассматриваются как отдельные понятия. Тем не менее агент Механизм облегчает моделирование операций как объектов времени выполнения. Агенты удовлетворяют диапазону применения, приписываемому объектам функций, например, передаются в качестве аргументов в процедурных вызовах или указываются как процедуры обратного вызова. Дизайн механизма агента в Eiffel пытается отразить объектно-ориентированную природу метода и языка. Агент - это объект, который обычно является прямым экземпляром одного из двух библиотечных классов, которые моделируют два типа подпрограмм в Eiffel: ПРОЦЕДУРА и НАЗНАЧЕНИЕ. Эти два класса происходят от более абстрактных РУТИНА.

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

my_button.select_actions.продлевать (агент my_gauge.шаг вперед)

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

В других классах библиотеки агенты используются для разных целей. В библиотеке, поддерживающей структуры данных, например, класс, моделирующий эффекты линейных структур. универсальная количественная оценка с функцией для всех типа BOOLEAN который принимает агента, экземпляр НАЗНАЧЕНИЕ, как аргумент. Итак, в следующем примере my_action выполняется только если все члены мой список содержать символ '!':

    мой список: LINKED_LIST [НИТЬ]        ...            если мой список.для всех (агент {НИТЬ}.имеет ('!')) тогда                my_action            конец        ...

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

Когда цель агента остается открытой, имя класса ожидаемой цели, заключенное в фигурные скобки, заменяется ссылкой на объект, как показано в тексте. агент {STRING}. имеет ('!') в примере выше. Когда аргумент остается открытым, знак вопроса ('?') Кодируется как заполнитель для открытого аргумента.

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

    print_on_new_line (s: НИТЬ)            - Вывести букву `s 'перед новой строкой        делать            Распечатать ("% N" + s)        конец

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

    мой список: LINKED_LIST [НИТЬ]        ...            мой список.сделай все (агент print_on_new_line (?))            мой список.сделай все (агент {НИТЬ}.снизить)            мой список.сделай все (агент print_on_new_line (?))        ...

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

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

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

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

мой список.сделай все (агент my_multi_arg_procedure (closed_arg_1, ?, closed_arg_2, closed_arg_3)

Механизм агента Эйфеля подробно описан в Стандартный документ Eiffel ISO / ECMA.

В Java

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

Для примера из стандартной библиотеки Java, java.util.Collections.sort () занимает Список и функтор, роль которого заключается в сравнении объектов в списке. Без функций первого класса функция является частью интерфейса Comparator. Это можно было бы использовать следующим образом.

Список<Нить> список = Массивы.asList("10", "1", "20", "11", "21", "12");		Компаратор<Нить> numStringComparator = новый Компаратор<Нить>() {    общественный int сравнивать(Нить str1, Нить ул2) {        возвращаться Целое число.значение(str1).сравнить с(Целое число.значение(ул2));    }};Коллекции.Сортировать(список, numStringComparator);

В Java 8+ это можно записать как:

Список<Нить> список = Массивы.asList("10", "1", "20", "11", "21", "12");		Компаратор<Нить> numStringComparator = (str1, ул2) -> Целое число.значение(str1).сравнить с(Целое число.значение(ул2));Коллекции.Сортировать(список, numStringComparator);

В JavaScript

В JavaScript, функции являются объектами первого класса. JavaScript также поддерживает замыкания.

Сравните следующее с последующим примером Python.

функция Аккумулятор(Начните) {  вар Текущий = Начните;  возвращаться функция (Икс) {    возвращаться Текущий += Икс;  };}

Пример использования:

вар а = Аккумулятор(4);вар Икс = а(5);   // x имеет значение 9Икс = а(2);       // x имеет значение 11вар б = Аккумулятор(42);Икс = б(7);       // x имеет значение 49 (current = 49 в замыкании b)Икс = а(7);       // x имеет значение 18 (current = 18 в замыкании a)

В Юлии

В Юля, методы связаны с типами, поэтому любой произвольный объект Julia можно сделать «вызываемым», добавив методы к его типу. (Такие «вызываемые» объекты иногда называют «функторами».)

Примером может служить изменяемая структура аккумулятора (основанная на Пола Грэма изучение синтаксиса и ясности языка программирования):[4]

Юля> изменчивый структура Аккумулятор           п::Int       конецЮля> функция (соотв::Аккумулятор)(n2)           соотв.п += n2       конецЮля> а = Аккумулятор(4)Аккумулятор(4)Юля> а(5)9Юля> а(2)11Юля> б = Аккумулятор(42)Аккумулятор(42)Юля> б(7)49

Такой аккумулятор также можно реализовать с помощью замыкания:

Юля> функция Аккумулятор(n0)           п = n0           функция(n2)               п += n2           конец       конецАккумулятор (общий функция с 1 метод)Юля> а = Аккумулятор(4)(::# 1) (общая функция с 1 методом)Юля> а(5)9Юля> а(2)11Юля> б = Аккумулятор(42)(::# 1) (общая функция с 1 методом)Юля> б(7)49

В Лиспе и Схеме

В языках семейства Lisp, таких как Common Lisp, Схема и др., функции являются объектами, как строки, векторы, списки и числа. Оператор построения замыкания создает функциональный объект из части программы: часть кода, заданная в качестве аргумента для оператора, является частью функции, как и лексическая среда: привязки лексически видимых переменных захвачен и хранится в функциональном объекте, который чаще называют закрытие. Захваченные привязки играют роль переменные-члены, а кодовая часть замыкания играет роль анонимная функция-членточно так же, как operator () в C ++.

Конструктор закрытия имеет синтаксис (лямбда (параметры ...) код ...). В (параметры ...) part позволяет объявить интерфейс, так что функция принимает объявленные параметры. В код ... Часть состоит из выражений, которые вычисляются при вызове функтора.

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

Объект-функция, использующий систему классов, без использования замыканий:

(defclass прилавок ()  ((ценить : initarg :ценить : аксессуар значение)))(defmethod вызов функтора ((c прилавок))  (incf (значение c)))(defun счетчик (Первоначальный значение)  (make-instance 'прилавок :ценить Первоначальный значение));;; используйте счетчик:(defvar * c * (счетчик 10))(вызов функтора * c *) --> 11(вызов функтора * c *) --> 12

Поскольку в Лиспе нет стандартного способа создания функционально вызываемых объектов, мы подделываем его, определяя общую функцию под названием FUNCTOR-CALL. Это может быть специализировано для любого класса. Стандартная функция FUNCALL не является универсальной; он принимает только функциональные объекты.

Именно эта универсальная функция FUNCTOR-CALL дает нам функциональные объекты, которые конструкция компьютерного программирования, позволяющая вызывать или вызывать объект, как если бы это была обычная функция, обычно с тем же синтаксисом. У нас есть почти тот же синтаксис: FUNCTOR-CALL вместо FUNCALL. Некоторые Lisps предоставляют забавный объекты как простое расширение. Сделать объекты вызываемыми с использованием того же синтаксиса, что и функции, - довольно тривиальное дело. Заставить оператор вызова функции работать с разными типами функциональные вещи, будь то объекты класса или замыкания, не сложнее, чем создание оператора +, который работает с разными типами чисел, такими как целые, действительные или комплексные числа.

Теперь счетчик реализован с помощью замыкания. Это гораздо более кратко и прямо. Аргумент INITIAL-VALUE функции MAKE-COUNTER заводская функция захватывается и используется напрямую. Его не нужно копировать в какой-либо объект вспомогательного класса через конструктор. Это является счетчик. Вспомогательный объект создается, но такое бывает за кулисами.

(defun счетчик (ценить)  (лямбда () (incf ценить)));;; использовать счетчик(defvar * c * (счетчик 10))(веселье * c *) ; --> 11(веселье * c *) ; --> 12

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

(определять (счетчик ценить)  (лямбда () (набор! ценить (+ ценить 1)) ценить));;; использовать счетчик(определять c (счетчик 10))(c) ; --> 11(c) ; --> 12

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

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

В Objective-C

В Цель-C, функциональный объект может быть создан из NSInvocation учебный класс. Для создания функционального объекта требуется подпись метода, целевой объект и целевой селектор. Вот пример создания вызова к текущему объекту myMethod:

// Создание функционального объектаSEL сел = @selector(myMethod);NSInvocation* inv = [NSInvocation invocationWithMethodSignature:                     [себя methodSignatureForSelector:сел]];[inv setTarget:себя];[inv setSelector:сел];// Выполняем фактический вызов[inv вызывать];

Преимущество NSInvocation заключается в том, что целевой объект может быть изменен после создания. Один NSInvocation могут быть созданы и затем вызваны для каждого из любого количества целей, например, из наблюдаемого объекта. An NSInvocation может быть создан только на основе протокола, но это не так просто. Видеть Вот.

В Perl

В Perl, объект функции может быть создан либо из конструктора класса, возвращающего функцию, закрытую над данными экземпляра объекта, благословленную в класс:

упаковка Acc1;суб новый {    мой $ класс = сдвиг;    мой $ arg = сдвиг;    мой $ obj = суб {        мой $ num = сдвиг;        $ arg += $ num;    };    благословить $ obj, $ класс;}1;

или путем перегрузки &{} оператор, чтобы объект можно было использовать как функцию:

упаковка Acc2;использовать перегрузка    '&{}' =>        суб {            мой $ self = сдвиг;            суб {                мой $ num = сдвиг;                $ self->{аргумент} += $ num;            }        };суб новый {    мой $ класс = сдвиг;    мой $ arg = сдвиг;    мой $ obj = { аргумент => $ arg };    благословить $ obj, $ класс;}1;

В обоих случаях функциональный объект можно использовать либо с помощью синтаксиса стрелки разыменования. $ ref -> (@ аргументы):

использовать Acc1;мой $ а = Acc1->новый(42);Распечатать $ а->(10), " п";    # отпечатков 52Распечатать $ а->(8), " п";     # отпечатков 60

или используя синтаксис разыменования coderef & $ ref (@arguments):

использовать Acc2;мой $ а = Acc2->новый(12);Распечатать &$ а(10), " п";     # отпечатков 22Распечатать &$ а(8), " п";      # отпечатков 30

В PHP

PHP 5.3+ имеет первоклассные функции которые можно использовать, например, в качестве параметра функции usort ():

$ а = множество(3, 1, 4);усорт($ а, функция ($ x, $ y) { возвращаться $ x - $ y; });

PHP 5.3+, поддерживает также лямбда-функции и замыкания. 

функция Аккумулятор($ start){    $ текущий = $ start;    возвращаться функция($ x) использовать(&$ текущий)    {        возвращаться $ текущий += $ x;    };}

Пример использования:

$ а = Аккумулятор(4);$ x = $ а(5);эхо "x = $ x
 ";	// x = 9$ x = $ а(2);эхо "x = $ x
 ";	// x = 11

В PHP 5.3+ также возможно сделать объекты вызываемыми, добавив к их классу волшебный метод __invoke ():[5]

учебный класс Минус{    общественный функция __invoke($ x, $ y)    {        возвращаться $ x - $ y;    }}$ а = множество(3, 1, 4);усорт($ а, новый Минус());

В PowerShell

в Windows PowerShell На языке, блок сценария - это набор операторов или выражений, которые можно использовать как единое целое. Блок скрипта может принимать аргументы и возвращаемые значения. Блок скрипта - это экземпляр Microsoft .NET Framework Тип System.Management.Automation.ScriptBlock.

Функция Get-Accumulator($ x) {    {        парам($ y)        возвращаться $ x += $ y    }.GetNewClosure()}
PS C: >$ а = Get-Accumulator 4PS C: >& $ а 59PS C: >& $ а 211PS C: >$ млрд = Get-Accumulator 32PS C: >& $ млрд 1042

В Python

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

Примером может служить этот класс аккумулятора (на основе Пола Грэма изучение синтаксиса и ясности языка программирования):[6]

учебный класс Аккумулятор:    def __в этом__(себя, п) -> Никто:        себя.п = п    def __вызов__(себя, Икс):        себя.п += Икс        возвращаться себя.п

Пример этого в использовании (с использованием интерактивного интерпретатора):

>>> а = Аккумулятор(4)>>> а(5)9>>> а(2)11>>> б = Аккумулятор(42)>>> б(7)49

Поскольку функции являются объектами, они также могут быть определены локально, с заданными атрибутами и возвращены другими функциями, [7] как показано в следующем примере:

def Аккумулятор(п):    def inc(Икс):        нелокальный п        п += Икс        возвращаться п    возвращаться inc

В Ruby

В Рубин, несколько объектов могут считаться функциональными объектами, в частности, объектами Method и Proc. В Ruby также есть два типа объектов, которые можно рассматривать как полуфункциональные объекты: UnboundMethod и block. UnboundMethods сначала должен быть привязан к объекту (таким образом, становясь методом), прежде чем их можно будет использовать в качестве объекта функции. Блоки могут вызываться как функциональные объекты, но для использования в любом другом качестве в качестве объекта (например, переданного в качестве аргумента) они должны сначала быть преобразованы в Proc. В последнее время символы (доступ к которым осуществляется через буквальный унарный индикатор :) также можно преобразовать в Procс. Использование унарного языка Ruby & оператор - эквивалент вызова to_proc на объекте, и при условии, что метод существует - Проект расширений Ruby создал простой хак.

учебный класс Символ  def to_proc    proc { |объект, *аргументы| объект.Отправить(себя, *аргументы) }  конецконец

Теперь метод фу может быть функциональным объектом, т.е. Proc, через &: foo и используется через принимает_a_functor (&: foo). Symbol.to_proc был официально добавлен в Ruby 11 июня 2006 г. во время RubyKaigi2006. [1]

Из-за разнообразия форм термин Functor обычно не используется в Ruby для обозначения объекта Function. Просто тип отправки. делегация представленный Рубиновые грани проект называется Functor. Самое основное определение этого:

учебный класс Функтор  def инициализировать(&func)    @func = func  конец  def method_missing(op, *аргументы, &черный)    @func.вызов(op, *аргументы, &черный)  конецконец

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

Другие значения

В более теоретическом контексте функциональный объект может рассматриваться как любой экземпляр класса функций, особенно в таких языках, как Common Lisp в каких функциях первоклассные объекты.

В ML семья функциональное программирование языки используют термин функтор представлять отображение от модулей к модулям или от типов к типам - это метод повторного использования кода. Функторы, используемые таким образом, аналогичны исходному математическому значению функтор в теория категорий, или к использованию общего программирования на C ++, Java или Ада.

В Haskell, этот термин используется в том же смысле, что и в теории категорий.

В Пролог и родственные языки, функтор это синоним символ функции.

Смотрите также

Примечания

  1. ^ В C ++ функционоид это объект, у которого есть один главный метод, а функтор является частным случаем функционоида.[1] Они похожи на функциональный объект, но не то же самое.

Рекомендации

  1. ^ В чем разница между функционоидом и функтором?
  2. ^ Силан Лю. «Учебник по C ++, часть I - базовая: 5.10 Указатели функций в основном используются для достижения техники обратного вызова, которая будет обсуждаться сразу после». ШТАТИВ: Учебники по программированию Copyright © Silan Liu 2002. Получено 2012-09-07. Указатели функций в основном используются для реализации техники обратного вызова, о которой мы поговорим сразу после.
  3. ^ Павел Турлейски (02.10.2009). «Учебник по C ++, часть I - Базовая: 5.10 Указатели функций в основном используются для достижения техники обратного вызова, которая будет обсуждаться сразу после». Всего несколько строк. Получено 2012-09-07. PHP 5.3, наряду со многими другими функциями, представил закрытие. Итак, теперь мы, наконец, можем делать все классные вещи, которые могут делать ребята из Ruby / Groovy / Scala / any_modern_language, верно? Что ж, можем, но, наверное, не будем… Вот почему.
  4. ^ Аккумуляторный Генератор
  5. ^ Документация PHP по магическим методам
  6. ^ Аккумуляторный Генератор
  7. ^ Справочное руководство Python - Определения функций

дальнейшее чтение

  • Дэвид Вандевурде и Николай М. Йосаттис (2006). Шаблоны C ++: полное руководство, ISBN  0-201-73484-2: В частности, глава 22 посвящена функциональным объектам.

внешняя ссылка