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

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

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

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

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

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

надеюсь, вы найдете эти полезные :)

EDIT:

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

пример кода John the Statistician не показывает функциональное программирование, потому что, когда вы делаете функциональное программирование, ключ в том, что код не выполняет никаких назначений (record = thingConstructor(t) является назначением), и у него нет побочных эффектов (localMap.put(record) заявление с побочным эффектом). В результате этих двух ограничений, все, что функции does полностью захвачен его аргументами и его возвращаемым значением. Переписывая код статистика так, как он должен выглядеть, если вы хотел эмулировать функциональный язык с помощью 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));
}

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

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

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

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

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

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

Да, вы правы, думая, что 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);

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

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

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

Эксперт 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;
}

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

в информатике функциональное программирование-это парадигма программирования-стиль построения структуры и элементов компьютерных программ,который рассматривает вычисления как оценку математических функций и избегает cзависание-состояние и изменяемые данные. Это декларативная парадигма программирования, которая означает, что программирование выполняется с выражениями. В функциональном коде выходное значение функции зависит только от аргументов, которые являются входными для функции, таким образом, вызов функции f дважды с одинаковым значением для аргумента x приведет к одному и тому же результату f(x) каждый раз. Устранение побочных эффектов, т. е. изменений состояния, не зависящих от входных функций, может значительно облегчить понимание и прогнозирование поведения программы, что является одной из ключевых мотиваций развития функционального программирования. см. более подробную информацию в wiki. некоторые примеры функциональных языков программирования scala, javascript...и т. д.