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

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

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

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

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

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

Есть два различных определения "functional programming" в общем использовании сегодня:

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

Более молодое определение (популяризованное Haskell) состоит в том, что функциональное программирование также сводится к минимизации и контролю побочных эффектов, включая мутацию, т. е. написание программ, которые решают проблемы путем составления выражений. Это чаще всего называется "purely functional programming". Это стало возможным благодаря совершенно различным подходам к структурам данных, называемым "purely functional data structures". Одна из проблем заключается в том, что перевод традиционных императивных алгоритмов на использование чисто функциональных структур данных обычно ухудшает производительность в 10 раз. Haskell-единственный сохранившийся чисто функциональный язык программирования, но эти концепции проникли в основное Программирование с помощью библиотек типа Linq .NET.

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

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

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

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

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

Кроме того, у Дастина Кэмпбелла есть отличный блог , в котором он опубликовал много статей о своих приключениях на getting up to speed with F#..

Я надеюсь, что вы найдете их полезными :)

EDIT:

Кроме того, просто добавлю, что мое понимание функционального программирования заключается в том, что все является функцией или параметрами функции, а не экземплярами/объектами с сохранением состояния.. Но я могу ошибаться 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++s ?: .

Кроме того, все является неизменяемым, поэтому 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(t)) { return localMap.get(t); }
    SomeKindOfRecord<T> record = new SomeKindOfRecord<T>(t);
    localMap = localMap.put(t,record);
    return record; 
}

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

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

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

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

(где * - это своего рода обозначение "leave this parameter open", которое является своего рода каррированием)

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

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

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

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

Я нахожу, что такое функциональное программирование? быть полезным

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

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

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;
}

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