In der Informatik ist funktionelle Programmierung ein Programmierparadigma, das Berechnung als die Einschätzung von mathematischen Funktionen behandelt und staatliche und veränderliche Daten vermeidet. Es betont die Anwendung von Funktionen im Gegensatz zum befehlenden Programmierstil, der Änderungen im Staat betont. Funktionelle Programmierung hat seine Wurzeln in der Lambda-Rechnung, ein formelles System entwickelt in den 1930er Jahren, um Funktionsdefinition, Funktionsanwendung und recursion zu untersuchen. Viele funktionelle Programmiersprachen können als Weiterentwicklungen auf der Lambda-Rechnung angesehen werden.

In der Praxis ist der Unterschied zwischen einer mathematischen Funktion und dem Begriff einer in der befehlenden Programmierung verwendeten "Funktion", dass befehlende Funktionen Nebenwirkungen haben können, den Wert des Programm-Staates ändernd. Wegen dessen haben sie an Verweisungsdurchsichtigkeit Mangel, d. h. derselbe Sprachausdruck kann auf verschiedene Werte zu verschiedenen Zeiten abhängig vom Staat des Durchführungsprogramms hinauslaufen. Umgekehrt, im funktionellen Code, hängt der Produktionswert einer Funktion nur von den Argumenten ab, die zur Funktion eingegeben werden, so eine Funktion f zweimal mit demselben Wert für ein Argument nennend, wird x dasselbe Ergebnis f (x) beide Male erzeugen. Das Beseitigen von Nebenwirkungen kann es viel leichter machen, das Verhalten eines Programms zu verstehen und vorauszusagen, das eine der Schlüsselmotivationen für die Entwicklung der funktionellen Programmierung ist.

Funktionelle Programmiersprachen, besonders rein funktionelle wie das Wegbahnen Hope, sind in der Akademie aber nicht in der kommerziellen Softwareentwicklung größtenteils betont worden. Jedoch sind prominente funktionelle Programmiersprachen wie Allgemeines Lispeln, Schema, ISLISP, Clojure, Schläger, Erlang, OCaml, Haskell, Scala und F# in industriellen und kommerziellen Anwendungen durch ein großes Angebot an Organisationen verwendet worden. Funktionelle Programmierung wird auch auf einigen bereichsspezifischen Programmiersprachen wie R (Statistik), Mathematica (symbolische Mathematik), J und K (Finanzanalyse) und XQuery/XSLT (XML) unterstützt. Weit verbreitete bereichsspezifische Aussagesprachen wie SQL und Lex/Yacc verwenden einige Elemente der funktionellen Programmierung, besonders im Enthalten veränderlicher Werte.

Die Programmierung in einem funktionellen Stil kann auch auf Sprachen vollbracht werden, die für die funktionelle Programmierung nicht spezifisch entworfen werden. Zum Beispiel ist die befehlende Programmiersprache von Perl das Thema eines Buches gewesen, das beschreibt, wie man funktionelle Programmierkonzepte anwendet. C# 3.0 zusätzliche Konstruktionen, um den funktionellen Stil auch zu erleichtern.

Geschichte

Lambda-Rechnung stellt ein theoretisches Fachwerk zur Verfügung, um Funktionen und ihre Einschätzung zu beschreiben. Obwohl es eine mathematische Abstraktion aber nicht eine Programmiersprache ist, bildet es die Basis fast aller funktionellen Programmiersprachen heute. Eine gleichwertige theoretische Formulierung, combinatory Logik, wird als abstrakter allgemein wahrgenommen als Lambda-Rechnung und ist ihm in der Erfindung vorangegangen. Es wird auf einigen esoterischen Sprachen einschließlich des Unlambdas verwendet. Logik von Combinatory und Lambda-Rechnung wurden beide ursprünglich entwickelt, um eine klarere Annäherung an die Fundamente der Mathematik zu erreichen.

Eine frühe funktionell-schmackhafte Sprache war Lispeln, das von John McCarthy während am Institut von Massachusetts für die Technologie (MIT) für die Reihe von IBM 700/7000 wissenschaftliche Computer gegen Ende der 1950er Jahre entwickelt ist. Lispeln hat viele auf funktionellen Sprachen jetzt gefundene Eigenschaften eingeführt, obwohl Lispeln technisch eine Mehrparadigma-Sprache ist. Schema und Dylan waren spätere Versuche, Lispeln zu vereinfachen und zu verbessern.

Information Processing Language (IPL) wird manchmal als die erste computergestützte funktionelle Programmiersprache zitiert. Es ist eine mit dem Zusammenbau artige Sprache, um Listen von Symbolen zu manipulieren. Es hat wirklich einen Begriff "des Generators", der sich auf eine Funktion beläuft, die eine Funktion als ein Argument akzeptiert, und, da es eine Sprache des Zusammenbau-Niveaus ist, kann Code als Daten verwendet werden, so kann IPL betrachtet werden als, höherwertige Funktionen zu haben. Jedoch verlässt es sich schwer auf die sich ändernde Listenstruktur und ähnlichen befehlenden Eigenschaften.

Kenneth E. Iverson hat APL am Anfang der 1960er Jahre entwickelt, beschrieben bestellen seinen 1962 Eine Programmiersprache (internationale Standardbuchnummer 9780471430148) vor. APL war der primäre Einfluss auf den FP von John Backus. Am Anfang der 1990er Jahre haben Iverson und Roger Hui J geschaffen. Mitte der 1990er Jahre hat Arthur Whitney, der vorher mit Iverson gearbeitet hatte, K geschaffen, der gewerblich in Finanzindustrien zusammen mit seinem Nachkommen Q. verwendet wird

John Backus präsentierte FP in seinem 1977 Turing-Preis-Vortrag "Kann Programmierend, Vom Stil von von Neumann Befreit Werden? Ein Funktioneller Stil und seine Algebra von Programmen". Er definiert funktionelle Programme, die als auf eine hierarchische Weise mittels des "Kombinierens von Formen" aufbauen werden, die eine "Algebra von Programmen" erlauben; auf der modernen Sprache bedeutet das, dass funktionelle Programme dem Grundsatz von compositionality folgen. Das Papier von Backus hat Forschung in die funktionelle Programmierung verbreitet, obwohl es Funktionsniveau-Programmierung aber nicht den Stil der Lambda-Rechnung betont hat, der gekommen ist, um mit der funktionellen Programmierung vereinigt zu werden.

In den 1970er Jahren wurde ML von Robin Milner an der Universität Edinburghs geschaffen, und David Turner hat am Anfang die Sprache SASL an der Universität St. Andrews und später der Sprache Miranda an der Universität von Kent entwickelt. ML hat sich schließlich in mehrere Dialekte entwickelt, von denen der allgemeinste jetzt OCaml und Normaler ML sind. Auch in den 1970er Jahren hat die Entwicklung des Schemas (ein teilweise funktioneller Dialekt des Lispelns), wie beschrieben, in den einflussreichen Lambda-Zeitungen und dem 1985-Lehrbuch Struktur und Interpretation von Computerprogrammen, Bewusstsein der Macht der funktionellen Programmierung zur breiteren Programmiersprache-Gemeinschaft gebracht.

In den 1980er Jahren, Pro Martin-Löf hat intuitionistic Typ-Theorie entwickelt (auch genannt Typ-Theorie Constructive), der funktionelle Programme mit konstruktiven Beweisen willkürlich komplizierter mathematischer als abhängige Typen ausgedrückter Vorschläge vereinigt hat. Das hat zu starken neuen Annäherungen an den interaktiven Lehrsatz-Beweis geführt und hat die Entwicklung von vielen nachfolgenden funktionellen Programmiersprachen beeinflusst.

Die Sprache von Haskell hat mit einer Einigkeit 1987 begonnen, einen offenen Standard für die funktionelle Programmierforschung zu bilden; Durchführungsausgaben sind seit 1990 andauernd gewesen.

Konzepte

Mehrere Konzepte und Paradigmen sind zur funktionellen Programmierung spezifisch, und der Befehlsform-Programmierung (einschließlich der objektorientierten Programmierung) allgemein fremd. Jedoch sind Programmiersprachen häufig Hybriden von mehreren Programmierparadigmen, so können Programmierer, die "größtenteils befehlende" Sprachen verwenden, einige dieser Konzepte verwertet haben.

Erstklassige und höherwertige Funktionen

Höherwertige Funktionen sind Funktionen, die entweder andere Funktionen als Argumente nehmen oder sie als Ergebnisse zurückgeben können. In der Rechnung ist ein Beispiel einer höherwertigen Funktion der Differenzialoperator, der die Ableitung einer Funktion zurückgibt.

Höherwertige Funktionen sind nah mit erstklassigen Funktionen verbunden, in denen höherwertige Funktionen und erstklassige Funktionen sowohl Funktionen als Argumente als auch Ergebnisse anderer Funktionen erlauben. Die Unterscheidung zwischen den zwei ist fein: "Höherwertig" beschreibt ein mathematisches Konzept von Funktionen, die auf anderen Funktionen funktionieren, während "erster Klasse" ein Informatik-Begriff ist, der Programmiersprache-Entitäten beschreibt, die keine Beschränkung ihres Gebrauches haben (so, können erstklassige Funktionen überall im Programm erscheinen, dass andere erstklassige Entitäten wie Zahlen, einschließlich als Argumente für andere Funktionen können, und weil ihre Rückkehr schätzt).

Höherwertige Funktionen ermöglichen teilweise Anwendung oder, eine Technik mit Currysoße zuzubereiten, in der eine Funktion auf seine Argumente einer nach dem anderen mit jeder Anwendung angewandt wird, eine neue Funktion zurückgebend, die das folgende Argument akzeptiert. Das erlaubt demjenigen, zum Beispiel, die Nachfolger-Funktion als der Hinzufügungsmaschinenbediener kurz und bündig auszudrücken, der teilweise auf die natürliche Zahl ein angewandt ist.

Reine Funktionen

Rein funktionelle Funktionen (oder Ausdrücke) haben kein Gedächtnis oder Eingabe/Ausgabe-Nebenwirkungen. Das bedeutet, dass reine Funktionen mehrere nützliche Eigenschaften haben, von denen viele verwendet werden können, um den Code zu optimieren:

• Wenn das Ergebnis eines reinen Ausdrucks nicht verwendet wird, kann es entfernt werden, ohne andere Ausdrücke zu betreffen.
• Wenn eine reine Funktion mit Rahmen genannt wird, die keine Nebenwirkungen verursachen, ist das Ergebnis in Bezug auf diese Parameter-Liste unveränderlich (manchmal hat Verweisungsdurchsichtigkeit genannt), d. h. wenn die reine Funktion wieder mit denselben Rahmen genannt wird, wird dasselbe Ergebnis zurückgegeben (das kann ermöglichen, Optimierungen wie memoization zu verstecken).
• Wenn es keine Datenabhängigkeit zwischen zwei reinen Ausdrücken gibt, dann kann ihre Ordnung umgekehrt werden, oder sie können in der Parallele durchgeführt werden, und sie können einander nicht stören (in anderen Begriffen, die Einschätzung jedes reinen Ausdrucks ist vor dem Faden sicher).
• Wenn die komplette Sprache Nebenwirkungen nicht erlaubt, dann kann jede Einschätzungsstrategie verwendet werden; das gibt die Bearbeiter-Freiheit, die Einschätzung von Ausdrücken in einem Programm (zum Beispiel, mit der Abholzung) wiederzubestellen oder zu verbinden.

Während die meisten Bearbeiter für befehlende Programmiersprachen reine Funktionen entdecken, und Beseitigung des allgemeinen Subausdrucks für reine Funktionsanrufe durchführen, können sie nicht das für vorkompilierte Bibliotheken immer tun, die allgemein diese Information nicht ausstellen, so Optimierungen verhindernd, die mit jenen Außenfunktionen verbunden sind. Einige Bearbeiter, wie gcc, fügen Extraschlüsselwörter für einen Programmierer hinzu, um Außenfunktionen als rein ausführlich zu kennzeichnen, solche Optimierungen zu ermöglichen. Fortran 95 erlaubt Funktionen, "rein" benannt zu werden.

Recursion

Wiederholung, die (sich) auf funktionellen Sprachen (schlingt), wird gewöhnlich über recursion vollbracht. Rekursive Funktionen rufen sich an, einer Operation erlaubend, immer wieder durchgeführt zu werden. Recursion kann das Aufrechterhalten eines Stapels verlangen, aber Schwanz recursion kann anerkannt und durch einen Bearbeiter in denselben Code optimiert werden, der verwendet ist, um Wiederholung auf befehlenden Sprachen durchzuführen. Der Schema-Sprachstandard verlangt, dass Durchführungen anerkennen und Schwanz recursion optimieren. Schwanz recursion Optimierung kann durch das Umwandeln des Programms in die Verlängerung vorübergehender Stil während des Kompilierens unter anderen Annäherungen durchgeführt werden.

Allgemeine Muster von recursion können mit höheren Ordnungsfunktionen, mit catamorphisms und anamorphisms ausgeklammert werden (oder "faltet sich" und "entfaltet sich") die offensichtlichsten Beispiele zu sein. Solche höheren Ordnungsfunktionen spielen eine Rolle, die eingebauten Kontrollstrukturen wie Schleifen auf befehlenden Sprachen analog ist.

Allgemeinster Zweck erlauben funktionelle Programmiersprachen uneingeschränkten recursion und sind abgeschlossener Turing, der das stockende Problem unentscheidbar macht, Unzuverlässigkeit des Equational-Denkens verursachen kann, und allgemein die Einführung der Widersprüchlichkeit in die durch das Typ-System der Sprache ausgedrückte Logik verlangt. Einige spezielle Zweck-Sprachen wie Coq erlauben nur wohl begründeten recursion und normalisieren stark (nichtendende Berechnung kann nur mit unendlichen Strömen von genanntem codata von Werten ausgedrückt werden). Demzufolge scheitern diese Sprachen, Turing zu sein, ganze und ausdrückende bestimmte Funktionen in ihnen sind unmöglich, aber sie können noch eine breite Klasse der interessanten Berechnung ausdrücken, während sie die durch uneingeschränkten recursion eingeführten Probleme vermeiden. Funktionelle Programmierung, die auf wohl begründeten recursion mit einigen anderen Einschränkungen beschränkt ist, wird funktionelle Gesamtprogrammierung genannt. Sieh Dreher 2004 für mehr Diskussion.

Streng gegen die nichtstrenge Einschätzung

Funktionelle Sprachen können dadurch kategorisiert werden, ob sie strenge (eifrige) oder nichtstrenge (faule) Einschätzung, Konzepte verwenden, die sich darauf beziehen, wie Funktionsargumente bearbeitet werden, wenn ein Ausdruck bewertet wird. Der technische Unterschied ist in der denotational Semantik von Ausdrücken, die Mangel oder auseinander gehende Berechnung enthalten. Unter der strengen Einschätzung wird die Einschätzung jedes Begriffes, der einen Mangel-Subbegriff enthält, selbst scheitern. Zum Beispiel, der Ausdruck:

Drucklänge ([2+1, 3*2, 1/0, 5-4])

wird unter der strengen Einschätzung wegen der Abteilung durch die Null im dritten Element der Liste scheitern. Unter der nichtstrengen Einschätzung wird die Länge-Funktion den Wert 4 zurückgeben (d. h., die Zahl von Sachen in der Liste), seit dem Auswerten davon wird nicht versuchen, die Begriffe zu bewerten, die die Liste zusammensetzen. Kurz gesagt strenge Einschätzung bewertet immer völlig Funktionsargumente vor dem Hervorrufen der Funktion. Nichtstrenge Einschätzung bewertet Funktionsargumente nicht, wenn ihre Werte nicht erforderlich sind, den Funktionsanruf selbst zu bewerten.

Die übliche Durchführungsstrategie für die nichtstrenge Einschätzung auf funktionellen Sprachen ist die Graph-Verminderung. Nichtstrenge Einschätzung wird standardmäßig auf mehreren reinen funktionellen Sprachen einschließlich Mirandas verwendet, Sauber und Haskell.

Hughes 1984 argumentiert für nichtstrenge Einschätzung als ein Mechanismus, um Programm-Modularität durch die Trennung von Sorgen zu verbessern, indem er unabhängige Durchführung von Erzeugern und Verbrauchern von Datenströmen erleichtert. 1993 von Launchbury beschreibt einige Schwierigkeiten, die faule Einschätzung, besonders im Analysieren Lagerungsvoraussetzungen eines Programms einführt, und eine betriebliche Semantik vorschlägt, um in solcher Analyse zu helfen. Harper 2009 hat sowohl einschließlich der strengen als auch einschließlich nichtstrengen Einschätzung auf derselben Sprache mit dem Typ-System der Sprache vor, um sie zu unterscheiden.

Typ-Systeme

Besonders seit der Entwicklung der Typ-Schlussfolgerung von Hindley-Milner in den 1970er Jahren haben funktionelle Programmiersprachen dazu geneigt, getippte Lambda-Rechnung im Vergleich mit der ungetippten Lambda-Rechnung zu verwenden, die im Lispeln und seinen Varianten (wie Schema) verwendet ist. Der Gebrauch von algebraischem datatypes und Muster, das zusammenpasst, macht Manipulation von komplizierten Datenstrukturen günstig und ausdrucksvoll; die Anwesenheit der starken Übersetzungszeit-Datentypprüfung macht Programme zuverlässiger, während Typ-Schlussfolgerung den Programmierer vom Bedürfnis befreit, Typen zum Bearbeiter manuell zu erklären.

Einige forschungsorientierte funktionelle Sprachen wie Coq, Agda, der Cayennepfeffer und das Sinngedicht basieren auf der intuitionistic Typ-Theorie, die Typen erlaubt, von Begriffen abzuhängen. Solche Typen werden abhängige Typen genannt. Diese Typ-Systeme haben entscheidbare Typ-Schlussfolgerung nicht und sind schwierig, zu verstehen und damit zu programmieren. Aber abhängige Typen können willkürliche Vorschläge in der Prädikat-Logik ausdrücken. Durch den Isomorphismus des Currys-Howard, dann, werden gut getippte Programme auf diesen Sprachen ein Mittel, formelle mathematische Beweise zu schreiben, von denen ein Bearbeiter bescheinigten Code erzeugen kann. Während diese Sprachen in der akademischen Forschung hauptsächlich von Interesse sind (einschließlich in der formalisierten Mathematik), haben sie begonnen, in der Technik ebenso verwendet zu werden. Compcert ist ein Bearbeiter für eine Teilmenge der C Programmiersprache, die in Coq geschrieben und formell nachgeprüft wird.

Eine beschränkte Form von abhängigen Typen hat gerufen verallgemeinerte algebraische Datentypen (GADT'S) können in einem Weg durchgeführt werden, der einige der Vorteile der abhängig getippten Programmierung zur Verfügung stellt, während er den grössten Teil seiner Unannehmlichkeit vermeidet. GADT'S ist in Glasgow Bearbeiter von Haskell und in Scala (als "Fall-Klassen") verfügbar, und ist als Hinzufügungen zu anderen Sprachen einschließlich Javas und C#. vorgeschlagen worden

Funktionelle Programmierung auf nichtfunktionellen Sprachen

Es ist möglich, einen funktionellen Stil der Programmierung auf Sprachen zu verwenden, die als funktionelle Sprachen nicht traditionell betrachtet werden. Unter befehlenden Programmiersprachen tritt die feste Unterstützung der D Programmiersprache für die funktionelle Programmierung hervor. Zum Beispiel hat D einen reinen Modifikator, um funktionelle Reinheit geltend zu machen. Nur Fortran 95 hat etwas Ähnliches.

Funktionen der ersten Klasse sind zu Hauptströmungssprachen langsam hinzugefügt worden. Zum Beispiel, Anfang 1994, unterstützen Sie für das Lambda, den Filter, die Karte und nehmen Sie ab wurde zur Pythonschlange hinzugefügt. Dann während der Entwicklung der Pythonschlange 3000 hat Guido van Rossum nach der Eliminierung dieser Eigenschaften verlangt. Bis jetzt ist nur die Funktion entfernt worden, und es bleibt zugänglich über das Standardbibliotheksmodul. Funktionen der ersten Klasse wurden auch in PHP 5.3, Visuelle Grundlegende 9, C# 3.0, und C ++ 11 eingeführt.

Die Sprache Einheitliche Abfrage (LINQ) Eigenschaft, mit seinen vielen Verkörperungen, ist ein offensichtlicher und starker Gebrauch der funktionellen Programmierung in.NET.

In Java können anonyme Klassen manchmal verwendet werden, um Verschlüsse vorzutäuschen; jedoch sind anonyme Klassen nicht immer richtiger Ersatz zu Verschlüssen, weil sie Fähigkeiten mehr beschränkt haben.

Viele objektorientierte Designmuster sind expressible in funktionellen Programmierbegriffen: Zum Beispiel diktiert das Strategie-Muster einfach Gebrauch einer höherwertigen Funktion, und das Besuchermuster entspricht grob einem catamorphism oder Falte.

Die Vorteile von unveränderlichen Daten können sogar in befehlenden Programmen gesehen werden, so mühen sich Programmierer häufig, einige Daten unveränderlich sogar in befehlenden Programmen zu machen.

Vergleich zur befehlenden Programmierung

Funktionelle Programmierung ist von der befehlenden Programmierung sehr verschieden. Die bedeutendsten Unterschiede stammen von der Tatsache, dass funktionelle Programmierung Nebenwirkungen vermeidet, die in der Befehlsform-Programmierung verwendet werden, um Staat und Eingabe/Ausgabe durchzuführen. Reine funktionelle Programmierung weist Nebenwirkungen völlig zurück und stellt so Verweisungsdurchsichtigkeit zur Verfügung, die es leichter macht, nachzuprüfen, und parallelize Programme, und leichter zu optimieren, automatisierte Werkzeuge zu schreiben, um jene Aufgaben durchzuführen.

Höherwertige Funktionen werden in der älteren befehlenden Programmierung selten verwendet. Wo ein traditionelles befehlendes Programm eine Schleife verwenden könnte, um eine Liste zu überqueren, würde ein funktionelles Programm eine verschiedene Technik verwenden. Es würde eine höherwertige Funktion verwenden, die als Argumente eine Funktion und eine Liste nimmt. Die höherwertige Funktion würde dann die gegebene Funktion auf jedes Element der gegebenen Liste anwenden und dann eine neue Liste mit den Ergebnissen zurückgeben.

Das Simulieren des Staates

Es gibt Aufgaben (zum Beispiel, ein Bankkonto-Gleichgewicht aufrechterhaltend), die häufig am natürlichsten durchgeführt mit dem Staat scheinen. Reine funktionelle Programmierung führt diese Aufgaben und Eingabe/Ausgabe-Aufgaben wie akzeptierender Benutzereingang durch und zum Schirm auf eine verschiedene Weise druckend.

Die reine funktionelle Programmiersprache Haskell führt sie durch, monads verwendend, ist auf Kategorie-Theorie zurückzuführen gewesen. Monads bieten eine Weise an, bestimmte Typen von rechenbetonten Mustern, einschließlich (aber nicht beschränkt auf) das Modellieren der Berechnung mit dem veränderlichen Staat (und andere Nebenwirkungen wie Eingabe/Ausgabe) auf eine befehlende Weise zu abstrahieren, ohne Reinheit zu verlieren. Während vorhanden, kann monads leicht sein, in einem Programm, in Anbetracht passender Schablonen und Beispiele zu gelten, viele Studenten finden sie schwierig, begrifflich z.B, wenn gefragt, zu verstehen, neuen monads zu definieren (der manchmal für bestimmte Typen von Bibliotheken erforderlich ist).

Unreine funktionelle Sprachen schließen gewöhnlich eine direktere Methode ein, veränderlichen Staat zu führen. Clojure verwendet zum Beispiel geführte Verweisungen, die durch die Verwendung reiner Funktionen auf den aktuellen Staat aktualisiert werden können. Diese Art der Annäherung ermöglicht Veränderlichkeit, während sie noch den Gebrauch von reinen Funktionen als die bevorzugte Weise fördert, Berechnung auszudrücken.

Alternative Methoden wie Logik von Hoare und Einzigartigkeit sind entwickelt worden, um Nebenwirkungen in Programmen zu verfolgen. Einige moderne Forschungssprachen verwenden Wirkungssysteme, um ausführlich die Anwesenheit von Nebenwirkungen zu machen.

Leistungsfähigkeitsprobleme

Funktionelle Programmiersprachen sind normalerweise in ihrem Gebrauch der in einer Prozession gehenden Haupteinheit (CPU) und des Gedächtnisses weniger effizient als befehlende Sprachen wie C und Pascal. Das ist mit der Tatsache verbunden, dass einige veränderliche Datenstrukturen wie Reihe eine sehr aufrichtige Durchführung mit der gegenwärtigen Hardware haben (der eine hoch entwickelte Maschine von Turing ist). Und es ist nicht leicht, ihre ebenso effizienten unveränderlichen Mehrzweckkollegen zu schaffen. Für rein funktionelle Sprachen ist die Grenzfall-Verlangsamung in der Zahl von verwendeten Speicherzellen logarithmisch, weil veränderliches Gedächtnis durch eine rein funktionelle Datenstruktur mit der logarithmischen Zugriffszeit (wie ein erwogener Baum) vertreten werden kann. Jedoch sind solche Verlangsamungen nicht universal. Für Programme, die intensive numerische Berechnung durchführen, sind funktionelle Sprachen wie OCaml und Sauber nur ein bisschen langsamer als C. Für Programme, die großen matrices und mehrdimensionale Datenbanken behandeln, ordnen Sie funktionelle Sprachen (wie J, und K) wurden mit der Geschwindigkeitsoptimierung entworfen.

Die Unveränderlichkeit von Daten, in vielen Fällen, kann zu Ausführungsleistungsfähigkeit führen, indem sie dem Bearbeiter erlaubt wird, Annahmen zu machen, die auf einer befehlenden Sprache unsicher sind, so Gelegenheiten für die Reihenvergrößerung vergrößernd.

Faule Einschätzung kann auch das Programm sogar asymptotisch beschleunigen, wohingegen es es höchstens durch einen unveränderlichen Faktor verlangsamen kann (jedoch, kann es Speicherleckstellen, wenn verwendet, unpassend einführen). Launchbury 1993 bespricht theoretische Probleme, die mit Speicherleckstellen von der faulen Einschätzung und O'Sullivan verbunden sind u. a. 2008 gibt etwas praktischen Rat, um sie zu analysieren und zu befestigen.

Das Codieren von Stilen

Befehlende Programme neigen dazu, die Reihe von Schritten zu betonen, die durch ein Programm im Ausführen einer Handlung gemacht sind, während funktionelle Programme dazu neigen, die Zusammensetzung und Einordnung von Funktionen häufig zu betonen, ohne ausführliche Schritte anzugeben. Ein einfaches Beispiel illustriert das mit zwei Lösungen derselben Programmierabsicht (das Rechnen von Fibonacci-Zahlen). Das befehlende Beispiel ist in C ++.

1. einschließen

//Fibonacci-Zahlen, befehlender Stil

interne Nummer fibonacci (int Wiederholungen)

{\

interne Nummer zuerst = 0, zweit = 1;//schätzt Samen

für (interne Nummer i = 0; ich

Und dasselbe Beispiel in C.

einschließen

interne Nummer fibonacci (interne Nummer);

int Hauptsache

{\

printf (" %d\n", fibonacci (10));

kehren Sie 0 zurück;

}\

//Fibonacci-Zahlen, befehlender Stilinterne Nummer fibonacci (int Wiederholungen){\

interne Nummer zuerst = 0, zweit = 1, ich;//schätzt Samen

für (ich = 0; ich

Eine funktionelle Version (in Haskell) hat ein verschiedenes Gefühl dazu:

- Fibonacci-Zahlen, funktioneller Stil

- beschreiben Sie eine unendliche Liste, die auf der Wiederauftreten-Beziehung für Fibonacci-Zahlen gestützt ist

fibRecurrence zuerst zweit = zuerst: fibRecurrence zweit (zuerst + zweit)

- beschreiben Sie Fibonacci-Liste als fibRecurrence mit Anfangswerten 0 und 1

fibonacci = fibRecurrence 0 1

- beschreiben Sie Handlung, um zu drucken, das 10. Element des fibonacci verzeichnen

wichtig = Druck (fibonacci!! 10)

</Quelle>

Der befehlende Stil beschreibt die Zwischenstufen, die am Rechnen beteiligt sind, und legt jene Schritte innerhalb einer Schleife-Behauptung. Im Gegensatz setzt die funktionelle Durchführung gezeigt hier die mathematische Wiederauftreten-Beziehung fest, die die komplette Folge von Fibonacci definiert, dann ein Element von der Folge auswählt (sieh auch recursion). Dieses Beispiel verlässt sich auf die faule Einschätzung von Haskell, um eine "unendliche" Liste zu schaffen, deren nur so viel, wie erforderlich (die ersten 10 Elemente in diesem Fall) wirklich geschätzt wird. Diese Berechnung geschieht, wenn das Laufzeitsystem die durch "den wichtigen" beschriebene Handlung ausführt.

Dasselbe Programm in Erlang stellt ein einfaches Beispiel dessen zur Verfügung, wie funktionelle Sprachen im Allgemeinen nicht verlangen, dass ihre Syntax "wenn" Behauptung enthält.

- Modul (fibonacci).

- Export ([Anfang/1]).

%% Fibonacci-Zahlen in Erlang

fangen Sie (N)-> do_fib (0,1, N) an.

do_fib (_, B, 1)-> B;

do_fib (A, B, N)-> do_fib (B, A+B, n-1).

</Quelle>

Dieses Programm wird innerhalb eines Moduls enthalten hat "fibonacci" genannt und erklärt, dass die Funktion des Anfangs/1 von der Außenseite des Spielraums dieses Moduls sichtbar sein wird.

Der Funktionsanfang/1 nimmt einen Parameter-Wert der ganzen Zahl und ruft dann eine innere Funktion hat do_fib/3 genannt.

In der direkten Unähnlichkeit zum befehlenden Codierstil braucht Erlang nicht, "wenn" Behauptung, weil die Durchlaufzeit von Erlang die Rahmen untersuchen wird, die zu einer Funktion passieren werden, und die erste Funktion nennen, die eine Unterschrift hat, die das aktuelle Muster von Rahmen vergleicht. (Syntax von Erlang stellt wirklich zur Verfügung, "wenn" Behauptung, aber es wird als syntaktischer Zucker und im Vergleich zu seinem Gebrauch auf befehlenden Sprachen betrachtet, nur eine geringe Rolle im Anwendungslogikdesign spielt).

Im Allgemeinen ist es unnötig, einen ausführlichen Test auf einen Parameter-Wert zu codieren, weil solch ein Test durch die Versorgung einer Reihe von Funktionsunterschriften implizit durchgeführt wird, die die verschiedenen Muster von Werten beschreiben, die durch eine Funktion erhalten werden konnten.

Im Fall oben wird die erste Version von do_fib/3 nur genannt, wenn der dritte Parameter das genaue der Wert von 1 hat. In allen anderen Fällen wird die zweite Version von do_fib/3 genannt.

Schließlich läuft das Schreiben desselben Programms im Lispeln hinaus:

(defun Tatsache (x) (wenn (= x 1) 1 (* x (Tatsache (-x 1)))))

</Quelle>

Das Programm kann dann als genannt werden

(Tatsache 10)

</Quelle>

Verwenden Sie in der Industrie

Funktionelle Programmierung ist lange in der Akademie, aber mit wenigen Industrieanwendungen populär gewesen. Jedoch kürzlich sind mehrere prominente funktionelle Programmiersprachen in kommerziellen oder industriellen Systemen verwendet worden. Zum Beispiel wurde die Programmiersprache von Erlang, die von der schwedischen Gesellschaft Ericsson gegen Ende der 1980er Jahre entwickelt wurde, ursprünglich verwendet, um mit der Schuld tolerante Fernmeldesysteme durchzuführen. Es ist populär seitdem geworden, für eine Reihe von Anwendungen an Gesellschaften wie T-Mobile, Nortel, Facebook und EDF zu bauen. Der Schema-Dialekt des Lispelns wurde als die Basis für mehrere Anwendungen auf frühen Computern des Apple Macintosh verwendet, und ist mehr kürzlich auf Probleme wie Lehrsimulierungssoftware und Fernrohr-Kontrolle angewandt worden. OCaml, der Mitte der 1990er Jahre eingeführt wurde, hat gesehenen kommerziellen Nutzen in Gebieten wie Finanzanalyse, Fahrer-Überprüfung, Industrieroboter-Programmierung und statische Analyse der eingebetteten Software. Haskell, obwohl am Anfang beabsichtigt, als eine Forschungssprache, ist auch durch eine Reihe von Gesellschaften, in Gebieten wie Raumfahrtsysteme, Hardware-Design und Webprogrammierung angewandt worden.

Andere funktionelle Programmiersprachen, die gesehenen Nutzen in der Industrie haben, schließen Scala, F#, Lispeln, Normaler ML und Clojure ein.

Siehe auch

• Vergleich, Paradigmen zu programmieren
• Eifrige Einschätzung
• Liste von funktionellen Programmierthemen
• Verschachtelte Funktion

Weiterführende Literatur

• Cousineau, Guy und Michel Mauny. Die Funktionelle Annäherung an die Programmierung. Cambridge, das Vereinigte Königreich: Universität von Cambridge Presse, 1998.
• Curry, Haskell Brooks und Feys, Robert und Craig, William. Combinatory Logik. Volume I. North-Holland Publishing Company, Amsterdam, 1958.
• Dominus, Mark Jason. Höherwertiger Perl. Morgan Kaufmann. 2005.
• Graham, Paul. ANSI Allgemeines LISPELN. Englewood Klippen, New Jersey: Prentice Hall, 1996.
• MacLennan, Bruce J. Functional Programming: Praxis und Theorie. Addison-Wesley, 1990.
• Pratt, Terrence, W. und Marvin V. Zelkowitz. Programmiersprachen: Design und Durchführung. 3. Hrsg. Englewood Cliffs, New Jersey: Prentice Hall, 1996.
• Salus, Peter H. Functional und Logikprogrammiersprachen. Vol. 4 des Handbuches von Programmiersprachen. Indianapolis, Indiana: Macmillan das Technische Veröffentlichen, 1998.
• Thompson, Simon. Haskell: Das Handwerk der Funktionellen Programmierung. Harlow, England: Addison-Wesley Longman Limited, 1996.

Außenverbindungen

• Funktionelle Programmierung für den Rest von Uns Eine Einführung durch Slava Akhmechet
• Funktionelle Programmierung in der Pythonschlange (durch David Mertz): Teil 1, Teil 2, Teil 3