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

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

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

Вместо этого Haskell использует другой подход к вводу-выводу: монады. Это объекты, которые содержат желаемую операцию ввода-вывода, которая должна выполняться на верхнем уровне вашего интерпретатора. На любом другом уровне они просто объекты в системе.

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

Что такое функциональное программирование

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

Старое определение (происходящее из Лиспа) заключается в том, что функциональное программирование - это программирование с использованием функций первого класса, то есть где функции обрабатываются как любое другое значение, поэтому вы можете передавать функции в качестве аргументов другим функциям, а функция может возвращать функции среди своих возвращаемых значений. Это приводит к использованию функций высшего порядка, таких как map и reduce (вы, возможно, слышали о mapReduce как об отдельной операции, активно используемой Google, и, что неудивительно, она является близкой родственницей!). Типы .NET System.Func и System.Action делают функции высшего порядка доступными в C #. Хотя каррирование в C # нецелесообразно, функции, которые принимают другие функции в качестве аргументов, являются общими, например функция Parallel.For.

Младшее определение (популяризированное Haskell) заключается в том, что функциональное программирование также связано с минимизацией и контролем побочных эффектов, включая мутации, то есть написание программ, которые решают проблемы путем составления выражений. Это чаще называют «чисто функциональным программированием». Это стало возможным благодаря совершенно разным подходам к структурам данных, которые называются «чисто функциональными структурами данных». Одна из проблем заключается в том, что перевод традиционных императивных алгоритмов на использование чисто функциональных структур данных обычно снижает производительность в 10 раз. Haskell - единственный сохранившийся чисто функциональный язык программирования, но его концепции вошли в массовое программирование с помощью таких библиотек, как Linq на .NET.

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

Повсюду. Лямбды в C # теперь продемонстрировали основные преимущества. В C ++ 11 есть лямбды. Сейчас нет оправдания тому, чтобы не использовать функции высшего порядка. Если вы можете использовать такой язык, как F #, вы также выиграете от вывода типов, автоматического обобщения, каррирования и частичного применения (а также от множества других языковых функций!).

Правильно ли я считаю, что C - нефункциональный язык программирования?

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

Возможно, стоит недавно прочитать эту статью о F # 101 в CoDe Mag. опубликовал.

Кроме того, Дастин Кэмпбелл ведет отличный блог, в котором он опубликовал множество статей о своих приключениях по освоению F #. .

Надеюсь, они вам пригодятся :)

РЕДАКТИРОВАТЬ:

Кроме того, просто чтобы добавить, мое понимание функционального программирования таково, что все - это функция или параметры функции, а не экземпляры / объекты с отслеживанием состояния .. Но я могу ошибаться F # - это то, что я умираю чтобы попасть, но просто нет времени! :)

В примере кода Джона Статистика не показано функциональное программирование, потому что, когда вы выполняете функциональное программирование, ключевым моментом является то, что код НЕ выполняет НАЗНАЧЕНИЙ (record = thingConstructor(t) - это присвоение) и НЕ имеет ПОБОЧНЫХ ЭФФЕКТОВ (localMap.put(record) - это оператор со стороной эффект). В результате этих двух ограничений все, что делает функция, полностью фиксируется ее аргументами и возвращаемым значением. Переписать код статистика так, как он должен выглядеть, если вы хотите эмулировать функциональный язык с использованием C ++:

RT getOrCreate(const T thing, 
                  const Function<RT<T>> thingConstructor, 
                  const Map<T,RT<T>> localMap) {
    return localMap.contains(t) ?
        localMap.get(t) :
        localMap.put(t,thingConstructor(t));
}

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

Кроме того, все неизменяемо, поэтому localMap.put должен создать новую копию localMap и вернуть ее вместо изменения исходного localMap, как это сделала бы обычная программа на C ++ или Java. . В зависимости от структуры localMap копия может повторно использовать указатели в оригинале, уменьшая объем данных, которые необходимо скопировать.

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

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

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

Функциональные языки также имеют очень большие среды выполнения. Haskell - исключение (исполняемые файлы GHC почти такие же маленькие, как программы C, как во время компиляции, так и во время выполнения), но программы SML, Common Lisp и Scheme всегда требуют тонны памяти.

Да, вы правы, полагая, что C - нефункциональный язык. C - процедурный язык.

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

SomeKindOfRecord<T> getOrCreate(T thing) { 
    if(localMap.contains(thing)) { return localMap.get(thing); }
    SomeKindOfRecord<T> record = new SomeKindOfRecord<T>(thing);
    localMap = localMap.put(thing, record);
    return record; 
}

Такое случается очень часто. Теперь на функциональном языке я мог написать

RT<T> getOrCreate(T thing, 
                  Function<RT<T>> thingConstructor, 
                  Map<T,RT<T>> localMap) {
    if(localMap.contains(thing)) { return localMap.get(thing); }
    RT<T> record = thingConstructor(thing);
    localMap = localMap.put(thing,record);
    return record; 
}

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

getOrCreate = myLib.getOrCreate(*,
                                SomeKindOfRecord<T>.constructor(<T>), 
                                localMap);

(где * - это своего рода обозначение "оставить этот параметр открытым", что является своего рода каррированием)

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

Если вы ищете хороший текст на F #

Expert F # написан в соавторстве с Доном Саймом. Создатель F #. Он специально работал над дженериками в .NET, чтобы создать F #.

F # создан по образцу OCaml, поэтому любой текст OCaml также поможет вам изучить F #.

Я считаю полезным Что такое функциональное программирование?

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

Предпочитать явный when параметр

public Program getProgramAt(TVGuide guide, int channel, Date when) {
  Schedule schedule = guide.getSchedule(channel);

  Program program = schedule.programAt(when);

  return program;
}

над

public Program getCurrentProgram(TVGuide guide, int channel) {
  Schedule schedule = guide.getSchedule(channel);

  Program current = schedule.programAt(new Date());

  return current;
}

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