Объяснение функционального программирования объектно-ориентированным программистам и менее техническим специалистам

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

1. Функции (очевидно)
2. Нет побочных эффектов
3. Неизменяемость
4. Рекурсия очень важна
5. Высокая степень параллелизации

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

Функциональное программирование используется в неожиданных местах. Он используется, например, для работы светофоров и коммутаторов связи (коммутаторы Ericsson работают на Erlang).

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

Для сторонников ООП можно показать, что закрытие подобно инкапсуляции, и, таким образом, функциональное программирование охватывает ООП. Можно также показать, насколько полезны функции высшего порядка, в частности, как они заставляют некоторые паттерны ООП (такие как паттерны Strategy и Template, а также паттерн Visitor в языках с мультиметодами) растворяться в языке (Питер Норвиг утверждает, что 16 из 23 паттернов GOF проще в Dylan и Lisp). В качестве аналога, ООП на основе передачи сообщений (а не подход CLOS) является паттерном в FP, который невидим в ООП.

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

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

Некоторые другие возможности, показывающие гибкость FP: ленивая оценка может быть реализована с помощью нулевых анонимных функций. FP может поддерживать ООП как на основе классов, так и на основе прототипов. Есть множество других примеров (например, стиль continuation-passing), но они обычно требуют знакомства с FP перед изучением. В

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

git checkout sha1_here  -- foo.m

или без проверки файла и просмотра его из командной строки

git show sha1_here:path_to_file/foo.m

http://www.regular-expressions.info/floatingpoint.html

Попробуйте просмотреть статью Функциональное программирование для остальной части U ниже.

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

Не уверен, как взломать этот звук, но как можно добавить прозрачную границу?

Возможно, есть способ сделать это с помощью Qt - я немного обошел документы QKeySequence, прежде чем сдаться, но вы можете просто использовать сигнал . В данный момент у меня нет настройки Qt/C + + на машине, но у меня есть привязки Python.

import sys, signal
from PyQt4 import QtGui

app = QtGui.QApplication(sys.argv)
signal.signal(signal.SIGINT, signal.SIG_DFL)

sys.exit(app.exec_())

Это работает и закроет приложение, когда я сделаю Ctrl-C . Так что я считаю, что ваше приложение может адаптировать этот код, и в конечном итоге это будет примерно так:

#include <signal.h>

int main(int argc, char* argv[])
{
    QApplication app(argc, argv);

    ... // parse command line options

    if (no_gui) {
        signal(SIGINT, SIG_DFL);
    }

    ... 

    return app.exec();
}

К сожалению, я не могу это скомпилировать, так что ему, вероятно, потребуется несколько исправлений, но это должно дать вам общее представление. С помощью обработчика SIG _ DFL программа должна использовать действие по умолчанию, связанное с Ctrl-C .

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

ОО - это существительные , в то время как функциональное программирование - это глаголы . Прочтите этот довольно хороший блог на эту тему Стива Йегге .

Честно говоря, я не думаю, что вы сможете. Функциональное программирование (например, «хорошее» объектно-ориентированное программирование в сравнении с «процедурным с классами») требует изменения ментальной модели. Вы просто не можете понять это как процедурный кодер, не потратив время и не проработав его.

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

Неизменяемые структуры данных

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

Непосредственный ответ: «ну, не надо, вы просто создаете новую версию своей структуры данных. с добавленным объектом ", и немедленный ответ" звучит не очень эффективно ". Ну это так.

Неизменяемый стек

Каноническая неизменяемая структура данных - это неизменяемый стек, который по сути представляет собой узел, содержащий два значения, доступные только для чтения: начало и конец. Выталкивание и выталкивание из стопки - O (1). Индексированный поиск, вставка / удаление в середине списка требует времени O (n), что, кстати, совпадает с изменяемым стеком.

using System;

namespace Juliet
{
    public abstract class Stack<T>
    {
        public static readonly Stack<T> Empty = new Nil();

        public abstract T Head { get; }
        public abstract Stack<T> Tail { get; }
        public abstract bool IsEmpty { get; }
        public Stack<T> Push(T value) { return new Cons(value, this); }
        public Stack<T> Append(Stack<T> other)
        {
            if (this.IsEmpty) { return other; }
            else { return new Cons(this.Head, this.Tail.Append(other)); }
        }

        sealed class Nil : Stack<T>
        {
            public override T Head { get { throw new Exception("Empty stack"); } }
            public override Stack<T> Tail { get { throw new Exception("Empty stack"); } }
            public override bool IsEmpty { get { return true; } }
        }

        sealed class Cons : Stack<T>
        {
            private readonly T _head;
            private readonly Stack<T> _tail;

            public override T Head { get { return _head; ; } }
            public override Stack<T> Tail { get { return _tail; } }
            public override bool IsEmpty { get { return false; } }

            public Cons(T head, Stack<T> tail)
            {
                _head = head;
                _tail = tail;
            }
        }
    }

    class Program
    {       
        static void Main(string[] args)
        {
            var s = Stack<int>.Empty.Push(1).Push(2).Push(3).Push(4).Push(5);
            while (!s.IsEmpty)
            {
                Console.Write("{0} ", s.Head);
                s = s.Tail;
            }
            Console.ReadKey(true);
        }
    }
}

Неизменяемое дерево AVL

Большинство людей не впечатлены стеками, потому что это не «серьезная» структура данных, но деревья AVL и другие самобалансирующиеся структуры данных впечатляют. Деревья на самом деле очень легко написать как неизменяемые структуры данных.

Эта версия поддерживает вставку и поиск O (log n), удаление не отображается, но также может быть реализовано в O (log n). Другими словами, неизменное дерево AVL имеет ту же вычислительную сложность, что и его изменяемый вариант:

using System;
using System.Linq;

namespace Juliet
{
    public abstract class AvlTree<T>
        where T : IComparable<T>
    {
        static AvlTree<T> Make(AvlTree<T> left, T value, AvlTree<T> right)
        {
            return new Node(left, value, right, Math.Max(left.Height, right.Height) + 1, left.Count + right.Count + 1);
        }

        public static readonly AvlTree<T> Empty = new Nil();

        protected abstract AvlTree<T> Left { get; }
        protected abstract AvlTree<T> Right { get; }
        protected abstract T Value { get; }
        public abstract int Height { get; }
        public abstract int Count { get; }

        public bool Contains(T v)
        {
            if (this.Height == 0) { return false; }
            else
            {
                int compare = v.CompareTo(this.Value);
                if (compare < 0) { return this.Left.Contains(v); }
                else if (compare > 0) { return this.Right.Contains(v); }
                else { return true; }
            }
        }

        public AvlTree<T> Insert(T v)
        {
            if (this.Height == 0) { return Make(this, v, this); }
            else
            {
                int compare = v.CompareTo(this.Value);
                if (compare < 0) { return Balance(Make(this.Left.Insert(v), this.Value, this.Right)); }
                else if (compare > 0) { return Balance(Make(this.Left, this.Value, this.Right.Insert(v))); }
                else { return this; }
            }
        }

        private static AvlTree<T> Balance(AvlTree<T> tree)
        {
            if (tree.Height > 0)
            {
                int outerBalanceFactor = tree.Left.Height - tree.Right.Height;
                if (outerBalanceFactor <= -2 && tree.Right.Height > 0) // right-side too heavy
                {
                    int innerBalanceFactor = tree.Right.Left.Height - tree.Right.Right.Height;
                    if (innerBalanceFactor <= -1) // right-right case
                    {
                        return LeftRotate(tree);
                    }
                    else if (innerBalanceFactor >= 1) // right-left case
                    {
                        return DoubleLeftRotate(tree);
                    }
                }
                else if (outerBalanceFactor >= 2 && tree.Left.Height > 0) // left-side too heavy
                {
                    int innerBalanceFactor = tree.Left.Left.Height - tree.Left.Right.Height;
                    if (innerBalanceFactor <= -1) // left-left case
                    {
                        return DoubleRightRotate(tree);
                    }
                    else if (innerBalanceFactor >= 1) // left-right case
                    {
                        return RightRotate(tree);
                    }
                }
            }
            return tree;
        }

        private static AvlTree<T> LeftRotate(AvlTree<T> tree)
        {
            if (tree.Height > 0 && tree.Right.Height > 0)
            {
                T p = tree.Value;
                T q = tree.Right.Value;
                AvlTree<T> a = tree.Left;
                AvlTree<T> b = tree.Right.Left;
                AvlTree<T> c = tree.Right.Right;
                return Make(Make(a, p, b), q, c);
            }
            return tree;
        }

        private static AvlTree<T> RightRotate(AvlTree<T> tree)
        {
            if (tree.Height > 0 && tree.Left.Height > 0)
            {
                T q = tree.Value;
                T p = tree.Left.Value;
                AvlTree<T> a = tree.Left.Left;
                AvlTree<T> b = tree.Left.Right;
                AvlTree<T> c = tree.Right;
                return Make(a, p, Make(b, q, c));
            }
            return tree;
        }

        private static AvlTree<T> DoubleLeftRotate(AvlTree<T> tree)
        {
            if (tree.Height > 0)
            {
                // right-rotate right child, left-rotate root
                return LeftRotate(Make(tree.Left, tree.Value, RightRotate(tree.Right)));
            }
            return tree;
        }

        private static AvlTree<T> DoubleRightRotate(AvlTree<T> tree)
        {
            if (tree.Height > 0)
            {
                // left-rotate left child, right-rotate root
                return RightRotate(Make(LeftRotate(tree.Left), tree.Value, tree.Right));
            }
            return tree;
        }


        sealed class Nil : AvlTree<T>
        {
            protected override AvlTree<T> Left { get { throw new Exception("Empty tree"); } }
            protected override AvlTree<T> Right { get { throw new Exception("Empty tree"); } }
            protected override T Value { get { throw new Exception("Empty tree"); } }
            public override int Height { get { return 0; } }
            public override int Count { get { return 0; } }
        }

        sealed class Node : AvlTree<T>
        {
            readonly AvlTree<T> _left;
            readonly AvlTree<T> _right;
            readonly T _value;
            readonly int _height;
            readonly int _count;

            protected override AvlTree<T> Left { get { return _left; } }
            protected override AvlTree<T> Right { get { return _right; } }
            protected override T Value { get { return _value; } }
            public override int Height { get { return _height; } }
            public override int Count { get { return _count; } }

            public Node(AvlTree<T> left, T value, AvlTree<T> right, int height, int count)
            {
                _left = left;
                _right = right;
                _value = value;
                _height = height;
                _count = count;
            }
        }
    }

    class Program
    {       
        static void Main(string[] args)
        {
            var tree = AvlTree<int>.Empty;
            foreach(int i in Enumerable.Range(1, 1000000).OrderBy(_ => Guid.NewGuid()))
            {
                tree = tree.Insert(i);
            }

            Console.Write("Tree height: {0}, tree count: {1}", tree.Height, tree.Count);

            Console.ReadKey(true);
        }
    }
}

Compare it to sentence structure.

Я бью по мячу, ловлю мяч, бросаю мяч:
Процедурный
Удар(мяч)
Поймать(мяч)
Throw(ball)

OO
Ball.Hit()
Ball.Catch()
Ball.Throw()

Мы использовали это руководство для Haskell, и оно сработало очень хорошо, беззаботно, но неплохо справляется с объяснениями:

Изучите Haskell для Great Good