„OCaml“ – Versionsunterschied
[gesichtete Version] | [gesichtete Version] |
Keine Bearbeitungszusammenfassung |
Commonscat mit Helferlein hinzugefügt |
||
(30 dazwischenliegende Versionen von 27 Benutzern werden nicht angezeigt) | |||
Zeile 1: | Zeile 1: | ||
{{Infobox Programmiersprache |
|||
{{Infobox_Programmiersprache| |
|||
Name=OCaml |
| Name = OCaml |
||
| Logo = [[Datei:OCaml Logo.svg|230px|Logo]] |
|||
⚫ | |||
| Beschreibung = |
|||
|Entwickler= [[INRIA]] |
|||
| Paradigma = |
|||
|AktuelleVersion= 3.12.1 |
|||
⚫ | |||
⚫ | |||
| Designer = |
|||
|Typisierung = |
|||
| Entwickler = [[Institut national de recherche en informatique et en automatique|INRIA]] |
|||
⚫ | |||
| AktuelleVersion = <!--von Wikidata--> |
|||
⚫ | |||
⚫ | |||
|Beeinflusst_von= |
|||
| AktuelleVorabVersion = |
|||
|Beeinflusste = [[F-Sharp|F#]] |
|||
| AktuelleVorabVersionFreigabeDatum = |
|||
⚫ | |||
| Typisierung = |
|||
|Website= [http://caml.inria.fr/ http://caml.inria.fr/] |
|||
⚫ | |||
| Dialekte = |
|||
⚫ | |||
| Standardisierungen = |
|||
| Beeinflusst_von = [[Caml]] Light, [[Cool (Programmiersprache)|Cool]] [[Standard ML]] |
|||
| Beeinflusste = [[Applied Type System|ATS]], [[Elm (Programmiersprache)|Elm]], [[F-Sharp|F#]], [[F*]], [[Haxe (Programmiersprache)|Haxe]], [[Opa (Programmiersprache)|Opa]], [[Rust (Programmiersprache)|Rust]], [[Scala (Programmiersprache)|Scala]] |
|||
⚫ | |||
| Website = [https://ocaml.org/ ocaml.org] |
|||
}} |
}} |
||
'''OCaml''' ist eine auf der [[ML (Programmiersprache)|ML]]-Sprachfamilie basierende [[Programmiersprache]]. Sie wird am [[INRIA]] unter der Leitung von [[Xavier Leroy]] entwickelt. Caml stand ursprünglich für '' |
'''OCaml''' (ehemals ''Objective CAML'') ist eine auf der [[ML (Programmiersprache)|ML]]-Sprachfamilie basierende [[Programmiersprache]]. Sie wird am [[Institut national de recherche en informatique et en automatique|INRIA]] unter der Leitung von [[Xavier Leroy]] entwickelt. Caml stand ursprünglich für ''Categorical Abstract Machine Language'', basiert aber schon seit langem nicht mehr auf diesem abstrakten Konzept. Zusätzlich zu den [[Funktionale Programmierung|funktionalen]] und [[Imperative Programmierung|imperativen]] [[Merkmal]]en von ML unterstützt OCaml [[objektorientiert]]e Konzepte und unterscheidet sich in Details von ML. |
||
OCaml bietet einen [[Compiler]] zur Erzeugung von sowohl [[Bytecode]] als auch [[Maschinencode]]. Der erzeugte Maschinencode ist sehr effizient (vergleichbar mit [[C++]]-Code). Zu den mächtigsten Merkmalen dieser Sprache gehört [[statische Typisierung]] (in Verbindung mit [[Typinferenz]]), parametrische [[Polymorphie (Programmierung)|Polymorphie]], [[Pattern Matching]], ein Mechanismus zur [[Ausnahmebehandlung]] und [[automatische Speicherbereinigung]]. OCaml-[[Distribution (Software)|Distributionen]] enthalten einige allgemeine [[Programmbibliothek|Bibliotheken]] und sind für zahlreiche [[Plattform (Computer)|Plattformen]], inklusive [[Unix]] und [[Microsoft Windows|Windows]] erhältlich. |
OCaml bietet einen [[Compiler]] zur Erzeugung von sowohl [[Bytecode]] als auch [[Maschinencode]]. Der erzeugte Maschinencode ist sehr effizient (vergleichbar mit [[C++]]-Code). Zu den mächtigsten Merkmalen dieser Sprache gehört [[statische Typisierung]] (in Verbindung mit [[Typinferenz]]), parametrische [[Polymorphie (Programmierung)|Polymorphie]], [[Pattern Matching]], ein Mechanismus zur [[Ausnahmebehandlung]] und [[automatische Speicherbereinigung]]. OCaml-[[Distribution (Software)|Distributionen]] enthalten einige allgemeine [[Programmbibliothek|Bibliotheken]] und sind für zahlreiche [[Plattform (Computer)|Plattformen]], inklusive [[Unix]] und [[Microsoft Windows|Windows]] erhältlich. |
||
Ein bekanntes [[Computerprogramm|Programm]], das in |
Ein bekanntes [[Computerprogramm|Programm]], das in OCaml geschrieben wurde, ist [[MLDonkey]], ein [[Peer-to-Peer|P2P]]-[[Client]], der auf diversen [[Betriebssystem]]en läuft und auf verschiedene P2P-[[Netzwerk]]e zugreifen kann. |
||
== Beispiel zur funktionalen Programmierung == |
== Beispiel zur funktionalen Programmierung == |
||
Zeile 25: | Zeile 33: | ||
| 1 -> f |
| 1 -> f |
||
| n -> (fun x -> (wiederhole f (n - 1)) (f x));; |
| n -> (fun x -> (wiederhole f (n - 1)) (f x));; |
||
(wiederhole (fun x -> x + 2) 3) 1;; |
(wiederhole (fun x -> x + 2) 3) 1;; |
||
</syntaxhighlight> |
</syntaxhighlight> |
||
Dieses Beispiel zeigt die Mächtigkeit der funktionalen Programmierung: Die Funktion „wiederhole“ kann eine beliebige Funktion mehrfach auf sich selbst anwenden und ist daher eine Funktion höherer Ordnung. Gleichzeitig ist „wiederhole“ [[Polymorphie (Programmierung)|polymorph]] – der Datentyp der ihr übertragenen Funktion steht im vornherein nicht fest. Typisch für OCaml ist das [[Pattern Matching]], die durch das Zeichen |
Dieses Beispiel zeigt die Mächtigkeit der funktionalen Programmierung: Die Funktion „wiederhole“ kann eine beliebige Funktion mehrfach auf sich selbst anwenden und ist daher eine Funktion höherer Ordnung. Gleichzeitig ist „wiederhole“ [[Polymorphie (Programmierung)|polymorph]] – der Datentyp der ihr übertragenen Funktion steht im vornherein nicht fest. Typisch für OCaml ist das [[Pattern Matching]], die durch das Zeichen <code>|</code> gekennzeichnete Fallunterscheidung. Im Beispiel wird die Funktion „addiere zwei“ (<syntaxhighlight lang="ocaml" inline>fun x -> x + 2</syntaxhighlight>) dreifach auf die Zahl 1 angewendet. Der Interpreter gibt 7 aus. |
||
== Universelle Polymorphie == |
== Universelle Polymorphie == |
||
Unter dem Begriff [[Polymorphie (Programmierung)|Polymorphie]] werden häufig die völlig verschiedenen Konzepte der Ad-hoc-Polymorphie und der universellen Polymorphie zusammengefasst. Ad-hoc-Polymorphie, also implizite Typkonversion und das Überladen von Funktionen, sind mit dem strengen statischen Typkonzept von OCaml und der Typinferenz nicht vereinbar. |
Unter dem Begriff [[Polymorphie (Programmierung)|Polymorphie]] werden häufig die völlig verschiedenen Konzepte der Ad-hoc-Polymorphie und der universellen Polymorphie zusammengefasst. Ad-hoc-Polymorphie, also implizite Typkonversion und das Überladen von Funktionen, sind mit dem strengen statischen Typkonzept von OCaml und der Typinferenz nicht vereinbar. |
||
Zeile 38: | Zeile 45: | ||
Beispiel: Der Ausdruck |
Beispiel: Der Ausdruck |
||
<code>1 + 2</code> ist in OCaml genau so wohltypisiert wie <code>1.5 +. 2.3</code>. Der Ausdruck <code>1 + 1.5</code> hingegen ist nicht wohltypisiert, da der Operator <code>+</code> zwei Integer-Werte als Eingaben erwartet. Eine implizite |
<code>1 + 2</code> ist in OCaml genau so wohltypisiert wie <code>1.5 +. 2.3</code>. Der Ausdruck <code>1 + 1.5</code> hingegen ist nicht wohltypisiert, da der Operator <code>+</code> zwei Integer-Werte als Eingaben erwartet. Eine implizite Typkonvertierung findet nicht statt. |
||
Vielmehr implementiert OCaml das mächtigere Konzept der universellen Polymorphie, und zwar in beiden Spielarten, der [[Polymorphie (Programmierung)#Parametrische Polymorphie|parametrischen Polymorphie]] und der [[Polymorphie (Programmierung)#Inklusionspolymorphie|Inklusionspolymorphie]]. |
Vielmehr implementiert OCaml das mächtigere Konzept der universellen Polymorphie, und zwar in beiden Spielarten, der [[Polymorphie (Programmierung)#Parametrische Polymorphie|parametrischen Polymorphie]] und der [[Polymorphie (Programmierung)#Inklusionspolymorphie|Inklusionspolymorphie]]. |
||
== Modulsystem == |
== Modulsystem == |
||
⚫ | Eine große Stärke der Programmiersprache OCaml ist ihr Modulsystem. Es ermöglicht eine Strukturierung des Quellcodes, ähnlich den „Packages“ von [[Java (Programmiersprache)|Java]]. Zusammenhängende Definitionen sollen in Module gruppiert werden. Dadurch kann es zu keinen Namenskonflikten zwischen unterschiedlichen Programmteilen und Bibliotheken kommen. Jedes Modul wird mithilfe des struct…end Ausdrucks definiert und erhält mit sig…end seine Signatur (optional). |
||
⚫ | Eine große Stärke der Programmiersprache OCaml ist ihr Modulsystem. Es ermöglicht |
||
kommen. Jedes Modul wird mithilfe des struct...end Ausdrucks definiert und erhält mit sig...end seine Signatur (optional). |
|||
<syntaxhighlight lang="ocaml"> |
<syntaxhighlight lang="ocaml"> |
||
module Str : sig |
module Str : sig |
||
Zeile 55: | Zeile 60: | ||
end |
end |
||
</syntaxhighlight> |
</syntaxhighlight> |
||
Das Beispiel definiert ein Modul mit Namen "Str". Dieses Modul besitzt einen Typ "t" und eine Funktion "compare". Compare erwartet zwei Werte vom Typ t und liefert |
Das Beispiel definiert ein Modul mit Namen "Str". Dieses Modul besitzt einen Typ "t" und eine Funktion "compare". Compare erwartet zwei Werte vom Typ t und liefert eine Ganzzahl (Int) als Ergebnis zurück. An diesem Beispiel kann man ebenfalls sehen, wie in OCaml mithilfe von Modulsignaturen Informationen versteckt werden können. Der Typ t ist außerhalb des Moduls Str nur abstrakt sichtbar. Das statische Typsystem von OCaml stellt sicher, dass Programmierer, die an anderen Stellen mit Werten vom Typ t arbeiten, nur die passenden Funktionen verwenden können (z. B. die Funktion compare des Moduls Str). Der Einsatz der Methode compare des Moduls ''String'' ist dagegen mit Werten vom Typ t nicht möglich, auch wenn die interne Repräsentation zeigt, dass dies funktionieren würde (denn jeder Wert vom Typ t ist ein ''String''). |
||
Der Vorteil dieser abstrakten Datentypen besteht aber darin, dass bei einer Änderung der internen Darstellung von t in z. B. |
Der Vorteil dieser abstrakten Datentypen besteht aber darin, dass bei einer Änderung der internen Darstellung von t in z. B. eine Unicode-Zeichenkette nur in dem Modul Str Anpassungen vorgenommen werden müssen. Alle anderen Stellen des Programmcodes sind von der Änderung nicht betroffen. |
||
Im Gegensatz zum Packagesystem von Java erlaubt es OCaml, Module zu verschachteln. |
Im Gegensatz zum Packagesystem von Java erlaubt es OCaml, Module zu verschachteln. |
||
== Funktoren == |
== Funktoren == |
||
⚫ | Das Modulsystem von OCaml erlaubt das Programmieren von parametrisierten Modulen. Diese erhalten statisch zur [[Übersetzungszeit]] ein anderes Modul als Parameter. Damit lassen sich auf sehr abstrakte Art und Weise Datenstrukturen und Algorithmen entwerfen, ohne dass diese von ihrer konkreten Verwendung abhängen. Als Beispiel ist hier das Modul Set genannt. Es beinhaltet im Wesentlichen einen Funktor Make, der es möglich macht, für Daten Mengen zu erzeugen, falls es für die Daten entsprechende Interfaces gibt (compare und t müssen implementiert sein). |
||
⚫ | Das Modulsystem von OCaml erlaubt das Programmieren von parametrisierten Modulen. Diese erhalten statisch zur [[Übersetzungszeit]] ein anderes Modul als Parameter. |
||
<syntaxhighlight lang="ocaml"> |
<syntaxhighlight lang="ocaml"> |
||
module SetStr = Set.Make(Str) |
module SetStr = Set.Make(Str) |
||
Zeile 74: | Zeile 78: | ||
== Weblinks == |
== Weblinks == |
||
{{Commonscat}} |
|||
⚫ | |||
⚫ | |||
⚫ | |||
== Einzelnachweise == |
|||
<references responsive /> |
|||
{{Normdaten|TYP=s|GND=7578649-7|LCCN=sh/2007/000473}} |
|||
⚫ | |||
⚫ | |||
* [http://pauillac.inria.fr/caml/ Materialien zu OCaml] (englisch) |
|||
* [http://www.soton.ac.uk/~fangohr/software/ocamltutorial/ OCaml-Tutorial] |
|||
* [http://www.youtube.com/playlist?list=PL554EC67D1932B25E&feature=plcp/ OCaml-Videotutorial] (deutsch, [[Adobe Flash]] erforderlich) |
|||
* [http://camelia.sourceforge.net/ Camelia] – eine [[Integrierte Entwicklungsumgebung|IDE]] für OCaml |
|||
⚫ | |||
* [http://tuareg.forge.ocamlcore.org/ (X)Emacs OCaml-Modus] |
|||
* [http://urpc.dyndns.org/ocamlinterpreter Ein Online-Interpreter für OCaml] |
|||
[[Kategorie:Funktionale Programmiersprache]] |
[[Kategorie:Funktionale Programmiersprache]] |
Aktuelle Version vom 25. Mai 2024, 11:02 Uhr
OCaml | |
---|---|
Basisdaten | |
Erscheinungsjahr: | 1996 |
Designer: | Xavier Leroy, Damien Doligez |
Entwickler: | INRIA |
Aktuelle Version | 5.2.0[1] (13. Mai 2024) |
Beeinflusst von: | Caml Light, Cool Standard ML |
Beeinflusste: | ATS, Elm, F#, F*, Haxe, Opa, Rust, Scala |
Betriebssystem: | Plattformunabhängig |
Lizenz: | Q Public License (Compiler), LGPL (Bibliothek) |
ocaml.org |
OCaml (ehemals Objective CAML) ist eine auf der ML-Sprachfamilie basierende Programmiersprache. Sie wird am INRIA unter der Leitung von Xavier Leroy entwickelt. Caml stand ursprünglich für Categorical Abstract Machine Language, basiert aber schon seit langem nicht mehr auf diesem abstrakten Konzept. Zusätzlich zu den funktionalen und imperativen Merkmalen von ML unterstützt OCaml objektorientierte Konzepte und unterscheidet sich in Details von ML.
OCaml bietet einen Compiler zur Erzeugung von sowohl Bytecode als auch Maschinencode. Der erzeugte Maschinencode ist sehr effizient (vergleichbar mit C++-Code). Zu den mächtigsten Merkmalen dieser Sprache gehört statische Typisierung (in Verbindung mit Typinferenz), parametrische Polymorphie, Pattern Matching, ein Mechanismus zur Ausnahmebehandlung und automatische Speicherbereinigung. OCaml-Distributionen enthalten einige allgemeine Bibliotheken und sind für zahlreiche Plattformen, inklusive Unix und Windows erhältlich.
Ein bekanntes Programm, das in OCaml geschrieben wurde, ist MLDonkey, ein P2P-Client, der auf diversen Betriebssystemen läuft und auf verschiedene P2P-Netzwerke zugreifen kann.
Beispiel zur funktionalen Programmierung
[Bearbeiten | Quelltext bearbeiten] let rec wiederhole f = function
| 1 -> f
| n -> (fun x -> (wiederhole f (n - 1)) (f x));;
(wiederhole (fun x -> x + 2) 3) 1;;
Dieses Beispiel zeigt die Mächtigkeit der funktionalen Programmierung: Die Funktion „wiederhole“ kann eine beliebige Funktion mehrfach auf sich selbst anwenden und ist daher eine Funktion höherer Ordnung. Gleichzeitig ist „wiederhole“ polymorph – der Datentyp der ihr übertragenen Funktion steht im vornherein nicht fest. Typisch für OCaml ist das Pattern Matching, die durch das Zeichen |
gekennzeichnete Fallunterscheidung. Im Beispiel wird die Funktion „addiere zwei“ (fun x -> x + 2
) dreifach auf die Zahl 1 angewendet. Der Interpreter gibt 7 aus.
Universelle Polymorphie
[Bearbeiten | Quelltext bearbeiten]Unter dem Begriff Polymorphie werden häufig die völlig verschiedenen Konzepte der Ad-hoc-Polymorphie und der universellen Polymorphie zusammengefasst. Ad-hoc-Polymorphie, also implizite Typkonversion und das Überladen von Funktionen, sind mit dem strengen statischen Typkonzept von OCaml und der Typinferenz nicht vereinbar.
Als Beispiel sei hier erwähnt, dass z. B. zwischen der Addition von Ganzzahlen (Integer) und der Addition von Gleitkommazahlen durch unterschiedliche Operatoren unterschieden wird.
Beispiel: Der Ausdruck
1 + 2
ist in OCaml genau so wohltypisiert wie 1.5 +. 2.3
. Der Ausdruck 1 + 1.5
hingegen ist nicht wohltypisiert, da der Operator +
zwei Integer-Werte als Eingaben erwartet. Eine implizite Typkonvertierung findet nicht statt.
Vielmehr implementiert OCaml das mächtigere Konzept der universellen Polymorphie, und zwar in beiden Spielarten, der parametrischen Polymorphie und der Inklusionspolymorphie.
Modulsystem
[Bearbeiten | Quelltext bearbeiten]Eine große Stärke der Programmiersprache OCaml ist ihr Modulsystem. Es ermöglicht eine Strukturierung des Quellcodes, ähnlich den „Packages“ von Java. Zusammenhängende Definitionen sollen in Module gruppiert werden. Dadurch kann es zu keinen Namenskonflikten zwischen unterschiedlichen Programmteilen und Bibliotheken kommen. Jedes Modul wird mithilfe des struct…end Ausdrucks definiert und erhält mit sig…end seine Signatur (optional).
module Str : sig
type t
val compare : t -> t -> int
end = struct
type t = string
let compare s1 s2 = String.compare s1 s2
end
Das Beispiel definiert ein Modul mit Namen "Str". Dieses Modul besitzt einen Typ "t" und eine Funktion "compare". Compare erwartet zwei Werte vom Typ t und liefert eine Ganzzahl (Int) als Ergebnis zurück. An diesem Beispiel kann man ebenfalls sehen, wie in OCaml mithilfe von Modulsignaturen Informationen versteckt werden können. Der Typ t ist außerhalb des Moduls Str nur abstrakt sichtbar. Das statische Typsystem von OCaml stellt sicher, dass Programmierer, die an anderen Stellen mit Werten vom Typ t arbeiten, nur die passenden Funktionen verwenden können (z. B. die Funktion compare des Moduls Str). Der Einsatz der Methode compare des Moduls String ist dagegen mit Werten vom Typ t nicht möglich, auch wenn die interne Repräsentation zeigt, dass dies funktionieren würde (denn jeder Wert vom Typ t ist ein String).
Der Vorteil dieser abstrakten Datentypen besteht aber darin, dass bei einer Änderung der internen Darstellung von t in z. B. eine Unicode-Zeichenkette nur in dem Modul Str Anpassungen vorgenommen werden müssen. Alle anderen Stellen des Programmcodes sind von der Änderung nicht betroffen.
Im Gegensatz zum Packagesystem von Java erlaubt es OCaml, Module zu verschachteln.
Funktoren
[Bearbeiten | Quelltext bearbeiten]Das Modulsystem von OCaml erlaubt das Programmieren von parametrisierten Modulen. Diese erhalten statisch zur Übersetzungszeit ein anderes Modul als Parameter. Damit lassen sich auf sehr abstrakte Art und Weise Datenstrukturen und Algorithmen entwerfen, ohne dass diese von ihrer konkreten Verwendung abhängen. Als Beispiel ist hier das Modul Set genannt. Es beinhaltet im Wesentlichen einen Funktor Make, der es möglich macht, für Daten Mengen zu erzeugen, falls es für die Daten entsprechende Interfaces gibt (compare und t müssen implementiert sein).
module SetStr = Set.Make(Str)
Siehe auch
[Bearbeiten | Quelltext bearbeiten]- Standard ML
- F#, eine auf OCaml basierte Programmiersprache für Microsoft .NET
- EML, eine andere objektorientierte Erweiterung von ML
Weblinks
[Bearbeiten | Quelltext bearbeiten]- Offizielle OCaml-Website (englisch)
- OCaml im Browser testen
- OCaml Package Manager (OPAM) – Softwarepaketmanagementsystem für OCaml
Einzelnachweise
[Bearbeiten | Quelltext bearbeiten]- ↑ OCaml 5.2.0 Release Notes. (abgerufen am 24. Mai 2024).