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

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

кроме того, у Dustin Campbell есть большой блог , где он отправил много статей о своих приключениях при набирании скорость с F#..

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

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

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

John, которого пример кода Статистика не показывает функциональному программированию, потому что при выполнении функционального программирования ключ - то, что код делает уроки (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, ключевое слово подразумевается, и , если оператор ведет себя как C++ ?: оператор.

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

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

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

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

Функциональные языки также имеют тенденцию иметь действительно большие среды выполнения. 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#

, пишется совместно Don Syme. Создатель F#. Он работал над дженериками в.NET конкретно, таким образом, он мог создать F#.

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