| F# | |
|---|---|
 | |
| Basisdaten | |
| Paradigmen: | multiparadigmatisch:funktional,imperativ,objektorientiert |
| Erscheinungsjahr: | 2002 |
| Designer: | Don Syme, Microsoft Research |
| Entwickler: | F Sharp Software Foundation,Don Syme,Microsoft, |
| Aktuelle Version: | 7.0[1] (8. November 2022) |
| Typisierung: | statisch,stark, implizit |
| Beeinflusst von: | Objective CAML,C#,Haskell,Elm |
| Beeinflusste: | Elm,F*,LiveScript,Elixir |
| Betriebssystem: | plattformübergreifend |
| Lizenz: | Apache-Lizenz 2.0 |
| F# Software Foundation | |
F# (gelesen:Fsharp; englische Aussprache [ɛfː ʃɑrp]) ist einetypsichere Multi-Paradigmen-Sprache mit starkem Fokus auffunktionale Programmierung für das.Net-Framework. Die Syntax ähnelt der vonOCaml sehr stark, da diese Sprache als Vorbild für die Implementierung der funktionalen und imperativen Sprachelemente diente. Im Gegensatz zuOCaml hat F# kein strukturiertesTypsystem, sondern ein normatives, um bessere Kompatibilität mitC# zu erreichen.
Die objektorientierte Seite von F# ist deshalb auch signifikant anders als die in OCaml.
F# ist voll interaktionsfähig mit allen anderen Sprachen des.NET-Systems und bietet durch das.Net-Framework undMono die Möglichkeit, den Code sowohl auf Windows als auch auf Linux, derBSD- undillumos-Familie undmacOS einzusetzen. ViaXamarin sind auchAndroid und iOS als Zielplattformen möglich.
Ursprünglich wurde F# als Forschungsprojekt vonMicrosoft Research entwickelt, derzeit wird es von Microsofts Entwicklungsabteilung und der F# Software Foundation fortgeführt. F# wurde als Teil vonVisual Studio 2010 erstmals offiziell unterstützt und mit ausgeliefert.[2] Im November 2010 wurde F# sowie zugehörigeCompiler und Bibliotheken unter derApache-Lizenz 2.0 freigegeben.
In überwiegend imperativen Sprachen sindVariablen das primäre Sprachkonstrukt, um Werte zu speichern. Dies geschieht in funktional orientierten Programmiersprachen wie F# durch unveränderliche (englisch: „immutable“) Sprachkonstrukte. Mit dem häufig eingesetztenSchlüsselwortlet können Werte eines bestimmten Typs deklariert werden.
letpi=3.14159265letname="John"
F# bietetTypableitung, d. h. Typen von Ausdrücken werden automatisch ermittelt. Beispielsweise bekommtpi automatisch den Typ desGleitkommazahl-Literals zugewiesen.
Veränderliche Variablen sind mit demmutable Schlüsselwort möglich und werden mit dem Zuweisungsoperator<- verändert. Dies wird in den meisten Fällen nur selten getan, weil die beschriebene Unveränderlichkeit von Werten als passender zur Sprachphilosophie gesehen wird. Dies nennt sich in F# auchfunctional first, also „funktional-zuerst“.[3]
letmutablex=10x<-15
Werte im Nachhinein zu verändern, ist auch durch die Verwendung von sogenanntenreference cells möglich:
letx=ref0// x hat den Typ "int ref", ist also eine Referenz auf einen Integerx:=5// x wird ein neuer Wert zugewiesenprintfn"%i"!x// Mittels des "!"-Operators wird x dereferenziert. Gibt 5 aus.
Funktionen werden wie andere Werte mitlet deklariert und können Parameter erwarten:
letsquarex=x*xletaddxy=x+y
Funktionen können Funktionen als Parameter erwarten (sieheFunktion höherer Ordnung):
letdo_twicefx=f(fx)
Die Typen der Parameter werden automatisch erkannt, können aber auch explizit deklariert werden:
letadd(x:int)(y:int):int=x+yletdo_twice(f:int->int)(x:int)=f(fx)
Die Anweisung
printfn"%A"(do_twicesquare5)
gibt 625 (das Quadrat des Quadrats von 5) aus. Die Funktiondo_twice kann mit Hilfe desKompositionsoperators und nachEta-Reduktion auch als
letdo_twicef=f>>f
geschrieben werden.
Im obigen Beispiel wird fürsquare der Typint->int ermittelt, das heißt,square ist eine Funktion, die einen Parameter vom Typint erwartet und einen Wert vom Typint zurückgibt. Fürdo_twice erhält man den Typ('a->'a)->'a->'a. Dies bedeutet,do_twice ist eine Funktion, die als ersten Parameter einen Wert vom Typ('a->'a) (eine Funktion mit einem Parameter vom Typ'a und einem Rückgabewert vom Typ'a) bekommt. Als zweiten Parameter erhält sie einen Wert vom Typ'a und sie gibt einen Wert vom Typ'a zurück.'a hat hier die Rolle einer Typvariable (grob vergleichbar mit Generic- oder Template-Parametern inJava/C++, siehePolymorphie (Programmierung)).
In F# werden Parameter ohne Klammern etc., nur durch Leerzeichen getrennt, an die Funktion übergeben. Nur wenn alsParameter der Rückgabewert einer anderen Funktion benötigt wird, müssen Klammern gesetzt werden, um die Evaluierungsreihenfolge der Ausdrücke zu definieren. Beiprintfn"%A"(add58) gehören die Werte 5 und 8 zur Funktionadd; deren Rückgabewert ist ein Parameter für die Funktionprintfn.
F# ermöglichtClosures und verwendetCurrying automatisch:
letaddxy=x+yletinc=add1
In der Definition voninc wird der erste Parameter der Funktionadd an den Wert 1 gebunden. Das Ergebnis dieserpartiellen Funktionsanwendung ist eine neue Funktion mit nur noch einem Parameter. Die Auswertung des Ausdrucks
inc5
liefert als Ergebnis 6.
F# unterstütztTupel:
letu=(3,6)letv=(2,-3)letadd(a,b)(c,d)=(a+c,b+d)letx,y=adduv
F# bietetDiscriminated Unions[4] undPattern Matching:
// Ein Element vom Typ Baum ist entweder ein "Ast" und enthält zwei Elemente vom Typ "Baum",// oder es ist ein "Blatt" und enthält einen IntegertypeBaum=|AstofBaum*Baum|BlattofintletrecbaumSummex=matchxwith|Ast(l,r)->baumSummel+baumSummer|Blatt(x)->x
Ebenso gibt esType Provider für die typsichere Verarbeitung externer Daten mitIntelliSense.[5]
In F# ist auchobjektorientiertes Programmieren möglich. Beispiel für eine Klassendeklaration:
typePerson=valname:stringvalmutableage:intnew(n,a)={name=n;age=a}memberx.Name=x.namememberx.Agewithget()=x.ageandset(v)=x.age<-vmemberx.Print()=printfn"%s ist %i Jahre alt."x.namex.age
Nullzeiger werden nur für die Interaktion mit Klassen aus dem.Net-Framework benötigt.
Im F#-Code sind zwei Syntaxformen möglich: einfache Syntax und ausführliche Syntax. Die einfache Syntax wird standardmäßig verwendet.
Beispiel für die einfache und ausführliche Syntax:
| einfache Syntax | ausführliche Syntax |
|---|---|
letmutablex=1whilex<3dox<-x+1 | letmutablex=1whilex<3dox<-x+1done |
typePerson=valname:stringvalmutableage:int | typePerson=classvalname:stringvalmutableage:intend |
Bei der einfachen Syntax sind die Einrückungen zwingend erforderlich, bei der ausführlichen könnte man sie auch weglassen.
F#-Code wirdkompiliert, hierbei entstehtZwischencode in derCommon Intermediate Language (CIL), genau wie bei Programmen, die inC# oderVB.NET geschrieben wurden.
Es gibt auch eine interaktive Umgebung bzw. F#-Interpreter, F# Interactive oder kurz FSI. Damit kann man den Code direkt in derKonsole schreiben. Eingaben im Interpreter sind mit;; abzuschließen, wodurch auch mehrzeilige Eingaben ermöglicht werden. Nach dem Kompilieren führt F# Interactive den Code aus und schreibt die Signatur aller kompilierten Typen und Werte in das Konsolenfenster. Auch Fehlermeldungen werden so ausgegeben.[6]
Dieser Interpreter erlaubt in unterstützten Editoren wieVisual Studio Code die Ausführung von Code ohne vorherige Kompilierung, so wie dies von dynamischen Sprachen bekannt ist.
Außerdem gibt es den Fable[7]-Übersetzer, mit dessen Hilfe sich F#-Code inJavaScript,Rust,Python,PHP undDart übersetzen lässt.
Folgende Beispiele geben „Hello World“ aus.
letmain=System.Console.WriteLine("Hello World")
oder
printfn"Hello World"
Die folgende Funktion implementiert die rekursiveAckermannfunktion:
letrecackmn=ifm=0thenn+1elseifn=0thenack(m-1)1elseack(m-1)(ackm(n-1))
