8: Функциональное программирование

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

Функциональное программирование объясняется на примере диалекта Common Lisp языка LISP. Этот диалект наиболее распространен и имеет официальный стандарт. Common Lisp может работать не только в пакетном режиме (когда он запускается как обычная программа), но и в режиме диалога.

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

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

Лямбда-абстракции

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

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

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

Основная операция — символьное вычисление применения функции к аргументу:  преобразуется в t[u]. Но эта операция может применяться в любом месте выражения, так что никакая конкретная дисциплина вычислений не фиксируется. Более того, функции могут вычисляться точно так же, как аргументы. Уже эта маленькая тонкость приводит к принципиальному расширению возможностей  -исчисления по сравнению с обычными вызовами процедур. Если мы желаем ограничиться лишь ею, рассматривается типизированное  -исчисление, в котором, как принято в большинстве современных систем программирования, значения строго разделены по типам. В типизированном  -исчислении есть только типы функций, но этого хватает, поскольку функции могут принимать в качестве параметров и выдавать функции.

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

вычисляется бесконечно, а чуть более сложное выражение

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

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

Списки и функциональные выражения

Основной единицей данных для LISP -системы является список.

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

1. Пустой список () (обозначаемый также nil ) является списком.
2. Если l₁,. . . , l_n, n >= 1 — атомы либо списки, то (l₁, . . . , l_n) — также список.

Элементами списка (l₁, . . . , l_n) называются l₁, . . . , l_n. Равенство списков задается следующим индуктивным определением.

1. l = nil тогда и только тогда, когда l также есть nil.
2. (l₁, . . . , l_n) = (k₁, . . . , k_m) тогда и только тогда, когда n = m и соответствующие l_i = k_i.

Пример 8.2.2. Все списки (), (()), ((())) и т. д. различны. Различны также и списки nil, (nil, nil), (nil, nil, nil) и так далее. Попарно различны и списки ((A,B), C), (A, (B,C)), (A,B,C), где A, B, C — различные атомы.

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

Вершины списка L задаются следующим индуктивным определением.

1. Элементы списка являются его вершинами.
2. Вершины элементов списка являются его вершинами.

Длиной списка называется количество элементов в нем. Глубиной списка называется максимальное количество вложенных пар скобок в нем. Соединением списков (l₁, . . . , l_n) и (k₁, . . . , k_m) называется список

(l₁, . . . , l_n, k₁, . . . , k_m).

Замена вершины a списка L на атом либо список M получается заменой поддерева L, соответствующего a, на дерево для M. Замена обозначается L[a | M]. Через L[a || M] будем обозначать результат замены нескольких вхождений вершины a на M.

Атомами в языке LISP являются числа, имена, истина T. Ложью служит пустой список NIL, который в принципе атомом не является, но в языке LISP при проверке на то, является ли он атомом, выдается истина. Точно так же выдается истина и при проверке, является ли онсписком. Однако все списковые операции применимы к NIL, а те, которые работают с атомами, часто к нему неприменимы. Например, попытка присваивания значения выдает ошибку.

Основная операция для задания списков (list a b . . . z). Она вычисляет свои аргументы и собирает их в список. Для этой операциибез вычисления аргументов есть скоропись ’(a b . . . z). Она является частным случаем функции quote (сокращенно обозначаемой’ ), которая запрещает всякие вычисления в своем аргументе и копирует его в результат так, как он есть.

По традиции, элементарные операции разбора списков обозначаются именами, которые начинаются с c и кончаются на r, а в середине идет некоторая последовательность букв a и d ; (car s) выделяет голову (первый член списка ), (cdr s) — хвост (подсписок всех членов, начиная со второго). Буквы a и d применяются, начиная с конца. Общее число символов в получающемся атоме должно быть не больше шести. Рассмотрим фрагмент диалога, иллюстрирующий эти операции. Как только в диалоге вводится законченное выражение, оно вычисляется либо выдается ошибка.

[13]>(setq a ’(b c (d e) f g))
(B C (D E) F G)
[14]> (cddr a)
((D E) F G)
[15]> (cddar a)
*** - CDDAR: B is not a list
1. Break [16]> ^Z
[17]> (caaddr a)
D
[18]> (cdaddr a)
(E)

Поле зрения и поле памяти

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

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

В поле памяти с каждым атомом-именем могут быть связаны атрибуты. Стандартный атрибут — значение атома. Для установки этогоатрибута есть функция (setq atom value), аналогичная присваиванию. Эта функция не вычисляет свой первый аргумент, она рассматривает его как имя, которому нужно приписать значение.

Значение в языке LISP может быть локальным. Если мы изменили значение атома внутри некоторого блока, то такое ‘присваивание’ действует лишь внутри минимальных объемлющих его скобок и исчезает снаружи блока. Кроме значения, имена могут иметь сколько угодно других атрибутов, которые обязательно глобальны. Они принадлежат самому имени, а не блоку. Способ установки значений этихатрибутов несколько искусственный. Имеется еще одна функция setf, вычисляющая свой первый аргумент, дающий ссылку на место, которому можно приписать значение (например, на атрибут ). Функция получения значения атрибута get, даже если атрибута еще нет, указывает на его место. Следующий пример демонстрирует, как это работает.

[38]> (setf (get ’b ’weight) ’(125 kg))
(125 KG)
[39]> (get ’b ’weight)
(125 KG)

Рассмотрим подробнее структуру данных языка LISP. Об этом говорит сайт https://intellect.icu . Она является двухуровневой. На верхнем уровне имеется структура списков. На нижнем находится структура информации, сопоставленной атому. Она изображена на рис. 8.1. Оба этих уровня рекурсивно ссылаются друг на друга, например, атрибуты атома являются списками.

Типы данных (в смысле программирования) в LISP есть, но они определяются динамически. В частности, если действительное числопридано атому как значение, то тип атома становится float.

Модель вычислений LISP

Для LISP (как и для любого другого функционального языка) не обязательно² говорить, где и как размещаются структуры данных ( списки ).

Рис. 8.1. Структура информации, сопоставленной атому языка LISP

Их стоит рассматривать как сугубо математические объекты со сложной структурой, которая всегда точно указывает на текущиевычислительные элементы:

1. До выполнения шага вычисления — это список, включающий имя функции и ее аргументы.
2. Во время выполнения шага вычисления — это те фрагменты списочной структуры поля зрения, которые доступны для использования вычисляемой функцией (в частности, среди них есть список, связанный с именем функции, который определяет ее вычислительный процесс).
3. После выполнения шага вычислений — это результаты вычислений. Результаты можно разделить на три группы:
   • значение, выдаваемое вызовом функции: оно замещает в поле зрения отработанный вызов функции;
   • побочные эффекты, разбросанные по структуре поля данных;
   • очередная функция, которая будет вычисляться далее. В традиционном программировании обычно возвращаются к вычислениям той функции, которая активизировала завершаемую. В функциональном программировании может быть и по-другому. Результат может оказаться функцией, либо описанной в статическом тексте программы, либо скомпонованной в ходе вычислений.
    

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

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

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

В практике реализации функциональных систем программирования имеется три варианта конкретизации представления графа:

1. Списки LISP, которые связаны с последовательными вычислениями. Структура графа задается как совокупность линейных списков, объединяющих имена функций и указатели аргументов. Голова списка трактуется как указание функции, а хвост — как аргументы.
2. Коммутационные схемы, которые строятся на основе разделения функций и данных: функции представляются вершинами графа, а их аргументы-данные передаются по дугам, соединяющим вершины. Дуги рассматриваются в качестве каналов связи. Функция активизируется, когда ее аргументы появляются в каналах.
3. Ассоциативные схемы, в которых вершины-функции остаются виртуальными. Они образуются в результате связывания данных, имеющих одинаковый ключ. Ситуация, когда такие данные появляются в ассоциативной памяти, трактуется как готовность аргументов для вычисления функции, идентифицируемой этим ключом.

Коммутационные и ассоциативные схемы рассмотрены при обсуждении неимперативных моделей вычислений (см. § 1.2 и 3.1). Выбор последовательно просматриваемой структуры для первого функционального языка обусловлен единственной для того времени возможностью реализации функциональности путем моделирования ее операционными средствами традиционной модели вычислений.Списочная структура также строится посредством более или менее стандартного для традиционной модели адресного представления. С языковой точки зрения именно этот выбор обеспечивает однородность структуры программы и данных, на базе которой Дж. Маккартиудалось построить систему средств, достаточную для практического функционального программирования.

Программа на языке LISP задается как список применений функций, часть из которых может вычисляться во время исполнения самой программы. Как правило, заданные в программе списки интерпретируются как применения функций и вычисляются, если другое не определяют ранее активированные функции (вы видели, что функция quote запрещает вычисление своего аргумента, функция setqзапрещает вычисление лишь первого из двух аргументов, а функция setf заставляет вычислить первый аргумент лишь до стадии, когда получена ссылка на его значение). Любое выражение выдает значение, что используется, в частности, при диалоговой работе с LISP (на примере которой иллюстрируются понятия).

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

(block name e1 . . . en)               (8.1)

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

(return-from name value)               (8.2)

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

Далее, блоком считается любое описание функции. Описание функции производится при помощи функции defun, которая, в своюочередь, определяется через примитивы function и lambda. Первый из них задает, что имя, являющееся его аргументом, рассматривается как функция (он часто сокращается в конкретном синтаксисе до #’ ), второй образует значение функционального типа.Имя функции является и именем функционального блока.

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

[1]> (defun fact (n) (if (= n 0) 1 
       (* (fact (- n 1)) n)))
FACT
[2]> (fact 40)
815915283247897734345611269596115894272000000000
[3]> ((lambda (x) (fact (* x x))) 5)
15511210043330985984000000
[4]> (setq g ’(lambda (x) (fact (* x x))))
(LAMBDA (X) (FACT (* X X)))
[5]> (eval (list g 3))
362880

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

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

[23]> (defun f (x) (progn (setf 
        (get ’x ’weight) ’(25 kg)) (+ x 3)))
F
[24]> (setf (get ’x ’weight) ’(30 kg))
(30 KG)
[25]> (get ’x ’weight)
(30 KG)
[26]> (setq x 5)
5
[27]> (f 3)
6
[28]> x
5
[29]> (get ’x ’weight)
(25 KG)

В LISP имеется возможность создать анонимный блок со своими локальными переменными, не объявляя его функцией. Создание такого блока называется связыванием переменных и производится функцией let.

Значение имени, унаследованного извне, все равно будет внешним! Смотрите пример ниже.

[32]>(setq a ’(b c d))
(B C D)
[33]>(setq b 5)
5
[34]> (list (let ((b 6)) (eval (car a))) 
        (eval (car a)))
(5 5)
[35]> (list (let ((b 6)) b) (eval (car a)))
(6 5)
[36]> (list (let ((b 6)) (list b a)) 
        (eval (car a)))
((6 (B C D)) 5)
[37]> (list (let ((b 6)) (eval (car 
        (list ’b a)))) (eval (car a)))
(5 5)

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

[57]> (setq a (list 1 5 7 9 11 13 15 19 22 28))
(1 5 7 9 11 13 15 19 22 28)
[58]> (mapcar (function (lambda (x) (* x x))) a)
(1 25 49 81 121 169 225 361 484 784)

Функционал mapcar применяет свой первый аргумент ко всем членам второго.

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

И, наконец, приведем пример³.

Пример 8.4.2. Данная программа строит автомат для нахождения всех вхождений некоторой системы слов во входной поток. Позже она анализируется с точки зрения автоматного программирования.

;==================================================
;
; свертка/развертка системы текстов
; текст представлен списком
;((Имя Вариант ...)...)
; первое имя в свертке - обозначение системы текстов
;      (Элемент ...)
;      (Имя Лексема (Варианты))
; ((пример (ма (ш н)
;          (ш а) )
;      ( ш н ) )
; ((н ина)) )
;==================================================
; реализация свертки: unic, ass-all, swin, gram, bnf

(defun unic (vac) (remove-duplicates (mapcar ’car vac) ))
;; список уникальных начал

(defun ass-all (Key Vac)
;; список всех вариантов продолжения (что может идти за ключом)
    (cond
       ((Null Vac) Nil)
       ((eq (caar Vac) Key) (cons (cdar Vac)
          (ass-all Key (cdr Vac)) ))
       (T (ass-all Key (cdr Vac)) )
) )

(defun swin (key varl) (cond
;; очередной шаг свертки или снять скобки при отсутствии вариантов
    ((null (cdr varl))(cons key (car varl)))
    (T (list key (gram varl)) )
))

(defun gram (ltext)
;; левая свертка, если нашлись общие начала
    ( (lambda (lt) (cond
        ((eq (length lt)(length ltext)) ltext)
        (T (mapcar
            #’(lambda (k) (swin k (ass-all k ltext ) ))
               lt )
    ) ) ) (unic ltext)
) )

(defun bnf (main ltext binds) (cons (cons main (gram ltext)) binds))
;; приведение к виду БНФ

;===================================================
; реализация развертки: names, words, lexs, d-lex, d-names,
;      h-all, all-t, pred, sb-nm, chain, level1, lang

(defun names (vac) (mapcar ’car vac))
;; определяемые символы

(defun words (vac) (cond
;; используемые символы
    ((null vac) NIL)
    ((atom vac) (cons vac NIL ))
    (T (union (words(car vac)) (words (cdr vac)))) ))
   
(defun lexs (vac) (set-difference (words vac) (names vac)))
;; неопределяемые лексемы

(defun d-lex ( llex)
;; самоопределение терминалов
     (mapcar #’(lambda (x) (set x x) ) llex) )
(defun ( llex)

;; определение нетерминалов
     (mapcar #’(lambda (x) (set (car x )(cdr x )) ) llex) )
    
(defun h-all (h lt)
;; подстановка голов
     (mapcar #’(lambda (a)
        (cond
           ((atom h) (cons h a))
           (T (append h a)) )
      ) lt) )
     
(defun all-t (lt tl)
;; подстановка хвостов
     (mapcar #’(lambda (d)
        (cond
           ((atom d) (cons d tl))
           (T(append d tl))
       ) ) lt) )
       
(defun pred (bnf tl)
;; присоединение предшественников
    (level1 (mapcar #’(lambda (z) (chain z tl )) bnf) ))
    
(defun sb-nm (elm tl)
;; постановка определений имен
(cond
   ((atom (eval elm)) (h-all (eval elm) tl))
   (T (chain (eval elm) tl))
) )

(defun chain (chl tl)
;; сборка цепочек
    (cond
       ((null chl) tl)
       ((atom chl) (sb-nm chl tl))
       
       ((atom (car chl))
           (sb-nm (car chl) (chain (cdr chl) tl) ))
          
       (T (pred (all-t (car chl) (cdr chl)) tl)) ))
       
(defun level1 (ll)
;; выравнивание
(cond
((null ll)NIL)
(T (append (car ll) (level1 (cdr ll)) )) ))

(defun lang ( frm )
;; вывод заданной системы текстов
(d-lex (lexs frm))
(d-names frm)
(pred (eval (caar frm)) ’(())
) )

(defclass pet (animal possession) (
     (species      :initform ’cat)
     (nick         :accessor nickof
                   :inintform ’Pussy
                   :initarg namepet)
)

[6]> (defclass init () ())
#<STANDARD-CLASS INIT>
[7]> (defclass a (init) ())
#<STANDARD-CLASS A>
[8]> (defclass b (init) ())
#<STANDARD-CLASS B>
[9]> (defclass c1 (a b) ())
#<STANDARD-CLASS C1>
[10]> (defclass c2 (b a) ())
#<STANDARD-CLASS C2>
[11]> (defclass contr (c1 c2) ())
*** - DEFCLASS CONTR: 
      inconsistent precedence graph,
cycle (#<STANDARD-CLASS A> #<STANDARD-CLASS B>)

(defmethod inspectpet ((x pet) (y float))
(setf weightofanimal 3.5))

(defclass thing ()
   ((weight    :initform ’(0 kg)
               :accessor weightof
               :initarg :weight)))
(defclass animal (thing)
   ((specie    :accessor specieof
               :initarg :spec)
   (sex        :accessor sexof
               :initform ’m
               :initarg :sex)))
(defclass possession (thing)
   ((owner     :accessor ownerof
               :initform ’nnn)
   (cost       :accessor costof
               :initform ’(0 bucks)
               :initarg :cost))
)
(defclass person (animal)
   ((specie    :initform ’human)
   (name       :initarg :thename
               :accessor nameof)))
(defclass pet (animal possession)
   ((nick      :initarg :thenick
               :accessor nickof)
   (specie        :initform ’cat)))
   
(defmethod act :before ((p pet))
   (print "Cat mews"))
(defmethod act :after ((p pet))
   (print "Cat turns"))
(defmethod act :around ((p pet))
   (progn (print "You have a cat") (call-next-method)))
   
(defmethod act ((p animal))
   (progn (print "Animal is close to you") (call-next-method)))
(defmethod act :before ((p animal))
   (print "You see an animal"))
(defmethod act :after ((p animal))
   (print "You send the animal off"))
(defmethod act :around ((p animal))
   (progn (print "You don’t like wild animals") (call-next-method)))
   
(defmethod act ((p possession))
   (progn (print "You test your property") (call-next-method)))
(defmethod act :before ((p possession))
   (print "You see your property"))
(defmethod act :after ((p possession))
   (print "You are pleased by your property"))
(defmethod act :around ((p possession))
   (progn (print "You admire your property
                       if it is in good state") (call-next-method)))
                       
(defmethod act ((p thing))
   (print "You take the thing"))
(defmethod act :before ((p thing))
   (print "You see something"))
(defmethod act :after ((p thing))
   (print "You identified this thing"))
(defmethod act :around ((p thing))
   (progn (print "You are not interested
                       in strange things") (call-next-method)))
                       
(act (make-instance ’pet :thenick "Viola" :cost ’(25 kop)))

[1]> (load ’myclasses)
;; Loading file E:\clisp-2000-03-06\myclasses.lsp ...
"You have a cat"
"You don’t like wild animals"
"You admire your property if it is in good state"
"You are not interested in strange things"
"Cat mews"
"You see an animal"
"You see your property"
"You see something"
"Cat purrs"
"Animal is close to you"
"You test your property"
"You take the thing"
"You identified this thing"
"You are pleased by your property"
"You send the animal off"
"Cat turns"
;; Loading of file E:\clisp-2000-03-06\myclasses.lsp is finished.
T

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