OCaml , ursprünglich bekannt als Objektiver Caml, ist die Hauptdurchführung der Programmiersprache von Caml, die von Xavier Leroy, Jérôme Vouillon, Damien Doligez, Didier Rémy und anderen 1996 geschaffen ist. OCaml erweitert die Kernsprache von Caml mit objektorientierten Konstruktionen.

Der toolset von OCAML schließt einen interaktiven Dolmetscher auf höchster Ebene, einen bytecode Bearbeiter und einen Optimierungseingeborener-Codebearbeiter ein. Es hat eine große Standardbibliothek, die es nützlich für viele derselben Anwendungen wie Python oder Perl, sowie robuste modulare und objektorientierte Programmierkonstruktionen macht, die es anwendbar für die groß angelegte Softwaretechnik machen. OCaml ist der Nachfolger des Caml Lichtes. Der Akronym-CAML ist ursprünglich für Kategorische Sprache der Abstrakten Maschine eingetreten, obwohl OCaml diese abstrakte Maschine aufgibt.

OCaml ist ein freies offenes Quellprojekt geführt und hauptsächlich aufrechterhalten durch INRIA. In den letzten Jahren haben viele neue Sprachen Elemente von OCaml, am meisten namentlich F# und Scala gezogen.

Philosophie

ML-derived Sprachen sind für ihre statischen Typ-Systeme und Typ ableitende Bearbeiter am besten bekannt. OCaml vereinigt funktionelle, befehlende und objektorientierte Programmierung unter einem ML ähnlichen Typ-System. Das bedeutet, dass der Programm-Autor nicht erforderlich ist, mit dem reinen funktionellen Sprachparadigma allzu vertraut zu sein, um OCaml zu verwenden.

Das statische Typ-System von OCAML kann helfen, Probleme an der Durchlaufzeit zu beseitigen. Jedoch zwingt es auch den Programmierer, sich den Einschränkungen des Typ-Systems anzupassen, das sorgfältigen Gedanken und Achtsamkeit verlangen kann. Ein Typ ableitender Bearbeiter reduziert außerordentlich das Bedürfnis nach manuellen Typ-Anmerkungen (zum Beispiel, der Datentyp von Variablen und die Unterschrift von Funktionen brauchen gewöhnlich nicht ausführlich erklärt zu werden, wie sie in Java tun). Dennoch kann der wirksame Gebrauch des Typ-Systems von OCAML eine Kultiviertheit seitens des Programmierers verlangen.

OCaml ist vielleicht aus anderen Sprachen mit Ursprüngen in der Akademie durch seine Betonung auf der Leistung am ausgezeichnetesten. Erstens macht sein statisches Typ-System Unverträglichkeiten der Typen während Laufzeit unmöglich, und begegnet so Laufzeittyp und Sicherheitskontrollen, die die Leistung dynamisch getippter Sprachen belasten, während sie noch Laufzeitsicherheit versichern (außer, wenn Reihe-Grenze-Überprüfung abgedreht wird, oder wenn bestimmte mit dem Typ unsichere Eigenschaften wie Anordnung verwendet werden; diese sind selten genug, dass das Vermeiden von ihnen in der Praxis ziemlich möglich ist).

Beiseite von der Datentypprüfung sind oberirdische, funktionelle Programmiersprachen im Allgemeinen, schwierig, um zum effizienten Maschinensprachcode wegen Probleme wie das funarg Problem zu kompilieren. Zusätzlich zur Standardschleife, dem Register und den Instruktionsoptimierungen, verwendet die Optimierung von OCAML des Bearbeiters statische Programm-Analyse-Techniken, um Wertboxen- und Verschluss-Zuteilung zu optimieren, helfend, die Leistung des resultierenden Codes zu maximieren, selbst wenn es umfassenden Gebrauch von funktionellen Programmierkonstruktionen macht.

Xavier Leroy hat festgestellt, dass "OCaml mindestens 50 % der Leistung eines anständigen C Bearbeiters liefert", aber ein direkter Vergleich ist unmöglich. Einige Funktionen in der OCaml Standardbibliothek werden mit schnelleren Algorithmen durchgeführt als gleichwertige Funktionen in den Standardbibliotheken anderer Sprachen. Zum Beispiel ist die Durchführung der Satz-Vereinigung in der OCaml Standardbibliothek asymptotisch schneller als die gleichwertige Funktion in den Standardbibliotheken von befehlenden Sprachen (z.B. C ++, Java), weil die OCaml Durchführung die Unveränderlichkeit dessen ausnutzt, bringt in Ordnung, um Teile von Eingangssätzen in der Produktion (Fortsetzung) wiederzuverwenden.

Eigenschaften

OCaml Eigenschaften: ein statischer

Typ-System, Typ-Schlussfolgerung,

parametrischer polymorphism, Schwanz recursion,

das Muster-Zusammenbringen,

erste Klasse lexikalische Verschlüsse,

functors (parametrische Module), das Ausnahme-Berühren und

der

zusätzliche generational automatische Müll-Sammlung.

OCaml ist besonders bemerkenswert, um ML-style Typ-Schlussfolgerung zu einem Gegenstand-System auf einer Allzwecksprache zu erweitern. Das erlaubt das Struktursubschreiben, wo Objektarten vereinbar sind, wenn ihre Methode-Unterschriften unabhängig von ihrem offen erklärten Erbe vereinbar sind; eine ungewöhnliche Eigenschaft auf statisch getippten Sprachen.

Eine Auslandsfunktionsschnittstelle, um sich zu C Primitiven zu verbinden, wird einschließlich der Sprachunterstützung für die effiziente numerische Reihe in Formaten zur Verfügung gestellt, die sowohl mit C als auch mit FORTRAN vereinbar sind. OCaml unterstützt auch die Entwicklung von Bibliotheken von OCaml-Funktionen, die mit einem "Haupt"-Programm in C verbunden werden können, so dass man eine OCaml Bibliothek C Programmierern verteilen konnte, die keine Kenntnisse noch Installation von OCaml haben.

Der OCaml Vertrieb enthält:

• Ein ausziehbarer parser und Makrosprache genannt Camlp4, der der Syntax von OCaml erlaubt, erweitert oder sogar ersetzt zu werden
• Lexer und parser Werkzeuge haben ocamllex und ocamlyacc genannt
• Testhilfeprogramm, das das Treten umgekehrt unterstützt, um Fehler zu untersuchen
• Dokumentationsgenerator
• Profiler — um Leistung zu messen
• Zahlreiche Mehrzweckbibliotheken

Der heimische Codebearbeiter ist für viele Plattformen, einschließlich Unix, Windows von Microsoft und Apple Mac OS X verfügbar. Ausgezeichnete Beweglichkeit wird durch die heimische Codegenerationsunterstützung für Hauptarchitekturen gesichert: IA-32, IA-64, AMD64, HP/PAPA; PowerPC, SPARC, Alpha, MIPS und StrongARM.

OCaml bytecode und heimische Codeprogramme können in einem Mehrgewindestil mit der Vorkaufszusammenhang-Schaltung geschrieben werden. Jedoch, weil der Müllmann für die Parallelität nicht entworfen wird, wird symmetrische Mehrverarbeitung nicht unterstützt. OCaml Fäden in demselben Prozess führen durch das Time-Sharing nur durch. Es gibt jedoch mehrere Bibliotheken für die verteilte Computerwissenschaft wie Functory und ocamlnet/Plasma (blog).

Codebeispiele

Schnipsel des OCaml-Codes werden durch das Eingehen in sie ins "auf höchster Ebene" am leichtesten studiert. Das ist eine interaktive OCaml Sitzung, die die abgeleiteten Typen des Resultierens oder der definierten Ausdrücke druckt. Das OCaml auf höchster Ebene wird durch die einfache Durchführung des OCaml Programms angefangen:

$ ocaml

Caml objektive Version 3.09.0

# In

Code kann dann an "#" schnell eingegangen werden. Zum Beispiel, um 1+2*3 zu rechnen:

# 1 + 2 * 3;;

-: interne Nummer = 7

OCaml leitet den Typ des Ausdrucks ab, "um interne Nummer" (eine ganze Maschinenpräzisionszahl) zu sein, und gibt das Ergebnis "7".

Hallo Welt

Das folgende Programm "hello.ml":

print_endline "Hallo Welt!"

</Quelle>

kann in einen bytecode rechtskräftigen kompiliert werden:

$ ocamlc hello.ml-o hallo

oder kompiliert in einen optimierten rechtskräftigen heimischen Code:

$ ocamlopt hello.ml-o hallo

und durchgeführt:

. $/hallo

Hallo Welt!

$\

Das Summieren einer Liste von ganzen Zahlen

Listen sind einer der grundsätzlichsten datatypes in OCaml. Das folgende Codebeispiel definiert eine rekursive Funktionssumme, die ein Argument xs akzeptiert. (Bemerken Sie das Schlüsselwort rec). Die Funktion wiederholt rekursiv über eine gegebene Liste und stellt eine Summe von Elementen der ganzen Zahl zur Verfügung. Die Match-Behauptung hat Ähnlichkeiten zu C ++ oder javanisches Sprachschalter-Element, obwohl es viel allgemeiner ist.

lassen Sie rec xs = summieren

vergleichen Sie xs mit

| []-> 0

| x:: Xs'-> x + summieren xs'

</Quelle>

# Summe [1; 2; 3; 4; 5];;

-: interne Nummer = 15

Ein anderer Weg ist, Standardfalte-Funktion zu verwenden, die mit Listen arbeitet.

lassen Sie Summe xs =

Liste fold_left (+) 0 xs

</Quelle> # Summe [1; 2; 3; 4; 5];; -: interne Nummer = 15

Schnellsortierung

OCaml leiht sich zum kurzen Ausdruck von rekursiven Algorithmen. Das folgende Codebeispiel führt einen Algorithmus durch, der der Schnellsortierung ähnlich ist, die eine Liste in der zunehmenden Ordnung sortiert.

lassen Sie rec qsort = Funktion

| []-> []

| Türangel:: Rest->

lassen Sie is_less x = x

Geburtstag-Paradox

Das folgende Programm berechnet die kleinste Anzahl der Leute in einem Zimmer, für die die Wahrscheinlichkeit von völlig einzigartigen Geburtstagen weniger als 50 % ist (das so genannte Geburtstag-Paradox, wo für 1 Person die Wahrscheinlichkeit offensichtlich 100 % ist, für 2 ist es 364/365, usw.) (Antwort = 23).

lassen Sie year_size = 365.

lassen Sie rec birthday_paradox prob Leute =

lassen Sie prob' = (year_size-. lassen Sie Leute schwimmen)/. year_size *. prob in

wenn prob'

Kirchziffern

Der folgende Code definiert eine Kirchverschlüsselung von natürlichen Zahlen, mit dem Nachfolger (tragen) (succ) und der Hinzufügung (bei). Eine Kirchziffer ist eine höherwertige Funktion, die eine Funktion und einen Wert akzeptiert und für genau Zeiten gilt. Um eine Kirchziffer von einem funktionellen Wert bis eine Schnur umzuwandeln, passieren wir ihm eine Funktion dass prepends die Schnur zu seinem Eingang und die unveränderliche Schnur.

lassen Sie Null f x = x

lassen Sie succ n f x = f (n f x)

lassen Sie einen = succ Null

lassen Sie zwei = succ (succ Null)

lassen Sie tragen n1 n2 f x = n1 f (n2 f x) bei

lassen Sie to_string n = n (Spaß k-> "S" ^ k) "0"

lassen Sie _ = to_string (tragen Sie (succ zwei) zwei) bei

</Quelle>

Willkürliche Präzision factorial Funktion (Bibliotheken)

Eine Vielfalt von Bibliotheken ist von OCaml direkt zugänglich. Zum Beispiel hat OCaml eine eingebaute Bibliothek für die willkürliche Präzisionsarithmetik. Da die Factorial-Funktion sehr schnell wächst, überflutet sie schnell Maschinenpräzisionszahlen (normalerweise 32- oder 64 Bit). So ist factorial ein passender Kandidat für die Arithmetik der willkürlichen Präzision.

In OCaml stellt das Modul von Num Arithmetik der willkürlichen Präzision zur Verfügung und kann in ein laufendes Verwenden auf höchster Ebene geladen werden:

1. #load "nums.cma";;
2. offener Num;;

</Quelle>

Die Factorial-Funktion kann dann mit der willkürlichen Präzision numerische Maschinenbediener =/, */und-/geschrieben werden:

1. lassen Sie rec Tatsache n =

wenn n = / Interne Nummer 0 dann Interne Nummer 1 sonst n */Tatsache (n-/Interne Nummer 1);;

Val-Tatsache: Num.num-> Num.num =

</Quelle>

Diese Funktion kann viel größeren factorials, solcher als 120 schätzen!:

1. string_of_num (Tatsache (Interne Nummer 120));;

-: spannen Sie =

"

6689502913449127057588118054090372586752746333138029810295671352301633

55724496298936687416527198498130815763789321409055253440858940812185989

8481114389650005964960521256960000000000000000000000000000"

</Quelle>

Die beschwerliche Syntax für Operationen von Num kann dank der camlp4 Syntax-Erweiterung genannt die Abgegrenzte Überbelastung erleichtert werden:

1. #require "pa_do.num";;
2. lassen Sie rec Tatsache n = Num. (wenn n = 0 dann 1 sonst n * Tatsache (n-1));;

Val-Tatsache: Num.num-> Num.num =

1. Tatsache Num. (120);;

-: Num.num =

</Quelle>

Dreieck (Grafik)

Das folgende Programm "simple.ml" macht ein rotierendes Dreieck im 2. Verwenden OpenGL:

lassen Sie =

ignorieren Sie (Glut.init Sys.argv);

Glut.initDisplayMode ~double_buffer:true ;

ignorieren Sie (Glut.createWindow ~title: "Demo von OpenGL");

lassen Sie Winkel t = 10. *. t *. t in

lassen Sie machen =

GlClear.clear [`Farbe];

GlMat.load_identity ;

GlMat.rotate ~angle: (Winkel (Sys.time )) ~z:1. ;

GlDraw.begins `Dreiecke;

List.iter GlDraw.vertex2 [-1.-1.; 0. 1.; 1.-1.];

GlDraw.ends ;

Glut.swapBuffers in

GlMat.mode `modelview;

Glut.displayFunc ~cb:render;

Glut.idleFunc ~cb: (Ein Glut.postRedisplay);

Glut.mainLoop

</Quelle>

LablGL bindings zu OpenGL sind erforderlich. Das Programm kann dann zu bytecode kompiliert werden mit:

$ ocamlc-I +lablGL lablglut.cma lablgl.cma simple.ml-o einfacher

oder zu nativecode mit:

$ ocamlopt-I +lablGL lablglut.cmxa lablgl.cmxa simple.ml-o einfacher

und geführt:

. $/einfache

Viel hoch entwickeltere, grafische 3D und 2. Hochleistungsprogramme werden in OCaml leicht entwickelt. Dank des Gebrauches von OpenGL sind die resultierenden Programme nicht nur kurz gefasst und, sondern auch Quer-Plattform effizient, ohne irgendwelche Änderungen auf allen Hauptplattformen kompilierend.

Fibonacci Folge

Der folgende Code berechnet die Folge von Fibonacci einer Nummer n inputed. Es verwendet Schwanz recursion und das Muster-Zusammenbringen.

lassen Sie rec fib_aux n ein b =

vergleichen Sie n mit

| 0-> ein

| _-> fib_aux (n - 1) (+ b) ein

lassen Sie Flunkerei n = fib_aux n 0 1

</Quelle>

Abgeleitete Sprachen

MetaOCaml

MetaOCaml ist eine Mehrstufenprogrammiererweiterung von OCaml das Ermöglichen des zusätzlichen Kompilierens des neuen Maschinencodes während der Durchlaufzeit. Unter bestimmten Verhältnissen sind bedeutende Beschleunigungen mögliche verwendende Mehrstufenprogrammierung, weil die ausführlichere Information über die Daten, um in einer Prozession zu gehen, an der Durchlaufzeit verfügbar ist als in der regelmäßigen Übersetzungszeit, so kann der zusätzliche Bearbeiter weg viele Fälle der Bedingung optimieren, die usw. überprüft.

Als ein Beispiel: Wenn während der Übersetzung es bekannt ist, dass eine bestimmte Potenzfunktion sehr oft erforderlich ist, aber der Wert dessen ist nur an der Durchlaufzeit bekannt, können Sie eine zweistufige Potenzfunktion in MetaOCaml verwenden:

lassen Sie rec Macht n x =

wenn n = 0

dann.

sonst

wenn sogar n

dann sqr (Macht (n/2) x)

sonst.

</Quelle>

Sobald Sie an der Durchlaufzeit wissen, können Sie eine spezialisierte und sehr schnelle Potenzfunktion schaffen:

.

</Quelle>

Das Ergebnis ist:

Spaß x_1-> (x_1 *

lassen Sie y_3 =

lassen Sie y_2 = (x_1 * 1)

in (y_2 * y_2)

in (y_3 * y_3))

</Quelle>

Die neue Funktion wird automatisch kompiliert.

Andere abgeleitete Sprachen

• AtomCaml stellt eine für die atomare (transactional) Ausführung des Codes primitive Synchronisation zur Verfügung.
• "Emily ist eine Teilmenge von OCaml, der eine Designregel verifier verwendet, um Sicherheitsgrundsätze der Gegenstand-Fähigkeit geltend zu machen."
• F# ist ein Microsoft.NET auf OCaml gestützte Sprache.
• Frischer OCaml erleichtert die Manipulation von Namen und Bindern.
• GCaml fügt Verlängerungspolymorphism zu OCaml hinzu, so Überbelastung und das vor dem Typ sichere Aufstellen erlaubend.
• JoCaml integriert Aufbauten, um gleichzeitige und verteilte Programme zu entwickeln.
• OCamlDuce erweitert OCaml mit Eigenschaften wie XML-Ausdrücke und Typen des regelmäßigen Ausdrucks.
• OCamlP3l ist ein paralleles Programmiersystem, das auf OCaml und der P3L Sprache gestützt ist

In OCaml geschriebene Software

• FFTW - eine Softwarebibliothek, um getrennten Fourier zu schätzen, verwandelt sich. Mehrere C Routinen sind durch ein OCaml genanntes Programm erzeugt worden.
• Einklang - ein Dateisynchronisationsprogramm, um Dateien zwischen zwei Verzeichnissen zu synchronisieren.
• Galax - eine offene Quelle XQuery Durchführung.
• Mldonkey - ein Gleicher, um auf dem EDonkey Netz gestützter Kunde zu spähen.
• GeneWeb - freie offene Quellmehrplattform-Genealogie-Software.
• Der haXe Bearbeiter - ein freier offener Quellbearbeiter für die haXe Programmiersprache.
• Frama-c - ein Fachwerk für die C Programm-Analyse.
• Liquidsoap - Liquidsoap ist der Audiostrom-Generator des Projektes von Savonet, das namentlich verwendet ist, für den Strom von netradios zu erzeugen. http://savonet.sourceforge.net /
• Coccinelle - Coccinelle ist ein Programm-Zusammenbringen- und Transformationsmotor, der die Sprache von SmPL (Semantische Fleck-Sprache) zur Verfügung stellt, um gewünschte Matchs und Transformationen im C-Code anzugeben. http://coccinelle.lip6.fr /
• CSIsat - ein Werkzeug für die LA+EUF Interpolation.
• Orpie - eine Befehl-Linie RPN Rechenmaschine
• Coq - ein formelles Probeverwaltungssystem.
• Ocsigen - Webentwicklungsfachwerk
• Sinnestäuschung - Betriebssystem, um sichere, zuverlässige Hochleistungsnetzanwendungen über eine Vielfalt der Wolkencomputerwissenschaft und beweglichen Plattformen zu bauen
• Opa - eine offene Quellprogrammiersprache für die Webentwicklung.
• CIL-CIL ist ein Vorderende für die C Programmiersprache, die Programm-Analyse und Transformation erleichtert.

Das private Handelsunternehmen Hauptstadt der Jane Street hat OCaml als seine bevorzugte Sprache angenommen.

http://cacm.acm.org/magazines/2011/11/138203-ocaml-for-the-masses/fulltext

Siehe auch

• Caml und Caml Light, Sprachen, aus denen OCaml entwickelt

hat

• Normaler ML, ein anderer populärer Dialekt von ML
• Ausziehbarer ML, ein anderer objektorientierter Dialekt von ML
• O'Haskell, eine objektorientierte Erweiterung auf die funktionelle Sprache Haskell

Außenverbindungen

Offizielle

• Sprachfamilienwebsite von Caml
• OCaml Bibliotheken
• Versuchen Sie OCaml in Ihrem Browser
• OCaml Tutorenkurs für C, C ++, Java und Programmierer von Perl
• Buch von Jason Hickey
• Ein grundlegender OCaml Tutorenkurs
• Ein Tutorenkurs mit einer praktischen Annäherung.
• OCamlcore Planet-Ansammlung von Leuten und Institutionsfutter über OCaml.
• OCamlForge ein kostenloser Dienst zu Open Source OCaml Entwickler, die leichten Zugang zum besten in der Quelle anbieten, kontrollieren Management, Adressenlisten, das Programmfehler-Verfolgen, die Nachrichtenausschüsse/Foren, die Aufgabenverwaltung, die Seite-Bewirtung, dauerhafte Datei archivalische, volle Unterstützungen und webbasierte Gesamtregierung.
• OCaml Batterien Eingeschlossen, eine gemeinschaftsgebaute Standardbibliothek für OCaml
• OCaml-Java, OCaml für Java
• OCamIL, ein OCaml Bearbeiter für Microsoft.NET
• LablGL und LablGTK OpenGL + bindings (LablGL) und GTK + bindings (LablGTK)
• Neueste OCaml-Projekte über Sourceforge
• Vergleich der Geschwindigkeit von verschiedenen Sprachen einschließlich OCaml
• MetaOCaml Hausseite
• der GODI Paket-Betriebsleiter für OCaml
• Ocamlwizard