imported>Derkoenig: lf, Commonscat mit Helferlein hinzugefügt

2026-04-11T22:13:50Z

lf, Commonscat mit Helferlein hinzugefügt

Neue Seite

{{Korrekter Titel|F#}}
{{Dieser Artikel|behandelt die Programmiersprache. Zur Bedeutung von f# in der Optik siehe [[Lichtstärke (Fotografie)]].}}

{{Infobox Programmiersprache
| Name = F#
| Logo = [[Datei:Fsharp logo.png|230px]]
| Beschreibung = Funktionale Programmiersprache
| Paradigma = multiparadigmatisch: [[Funktionale Programmierung|funktional]], [[Imperative Programmierung|imperativ]], [[Objektorientierte Programmierung|objektorientiert]]
| Erscheinungsjahr = 2002
| Designer =
| Entwickler = [[F Sharp Software Foundation]], [[Don Syme]], [[Microsoft]],
| AktuelleVersion = 7.0<ref>{{Internetquelle |url=https://devblogs.microsoft.com/dotnet/announcing-fsharp-7/ |titel=Announcing F# 7 |datum=2021-11-09 |abruf=2023-09-14 |sprache=en-US}}</ref>
| AktuelleVersionFreigabeDatum = 8. November 2022
| AktuelleVorabVersion =
| AktuelleVorabVersionFreigabeDatum =
| Typisierung = [[Statische Typisierung|statisch]], [[Starke Typisierung|stark]], implizit
| Implementierung =
| Dialekte =
| Standardisierungen =
| Beeinflusst_von = [[Objective CAML]], [[C-Sharp|C#]], [[Haskell (Programmiersprache)|Haskell]], [[Elm (Programmiersprache)|Elm]]
| Beeinflusste = [[Elm (Programmiersprache)|Elm]], [[F*]], [[LiveScript]], [[Elixir (Programmiersprache)|Elixir ]]
| Betriebssystem = [[plattformübergreifend]]
| Lizenz = [[Apache-Lizenz 2.0]]
| Website = [http://fsharp.org/ F# Software Foundation]
}}

'''F#''' (gelesen: ''F {{lang|en|sharp}}''; englische Aussprache [{{IPA|ɛfː ʃɑrp}}]) ist eine [[Typsicherheit|typsichere]] Multi-[[Programmierparadigma|Paradigmen-]]Sprache mit starkem Fokus auf [[funktionale Programmierung]] für das [[.Net-Framework]]. Die Syntax ähnelt der von [[Objective CAML|OCaml]] sehr stark, da diese Sprache als Vorbild für die Implementierung der funktionalen und imperativen Sprachelemente diente. Im Gegensatz zu [[Objective CAML|OCaml]] hat F# kein strukturiertes [[Typisierung (Informatik)|Typsystem]], sondern ein normatives, um bessere Kompatibilität mit [[C-Sharp|C#]] 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 (Oberbegriff)|.NET]]-Systems und bietet durch das [[.Net-Framework]] und [[Mono (Software)|Mono]] die Möglichkeit, den Code sowohl auf Windows als auch auf Linux, der [[Berkeley Software Distribution|BSD]]- und [[illumos]]-Familie und [[macOS]] einzusetzen. Via [[Xamarin]] sind auch [[Android (Betriebssystem)|Android]] und iOS als Zielplattformen möglich.

Ursprünglich wurde F# als Forschungsprojekt von [[Microsoft Research]] entwickelt, derzeit wird es von Microsofts Entwicklungsabteilung und der F# Software Foundation fortgeführt. F# wurde als Teil von [[Visual Studio]] 2010 erstmals offiziell unterstützt und mit ausgeliefert.<ref>[http://blogs.msdn.com/dsyme/archive/2008/12/10/fsharp-to-ship-as-part-of-visual-studio-2010.aspx ''F# to ship as part of Visual Studio 2010''.] Don Syme’s WebLog on the F# Language and Related Topics</ref> Im November 2010 wurde F# sowie zugehörige [[Compiler]] und Bibliotheken unter der [[Apache-Lizenz 2.0]] freigegeben.

== Einige Sprachmerkmale ==
=== Werte ===
In überwiegend imperativen Sprachen sind [[Variable (Programmierung)|Variablen]] 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 eingesetzten [[Schlüsselwort (Programmierung)|Schlüsselwort]] <code>let</code> können Werte eines bestimmten Typs deklariert werden.

<syntaxhighlight lang="fsharp">
let pi = 3.14159265
let name = "John"
</syntaxhighlight>

F# bietet [[Typableitung]], d. h. Typen von Ausdrücken werden automatisch ermittelt. Beispielsweise bekommt <code>pi</code> automatisch den Typ des [[Gleitkommazahl]]-[[Literal]]s zugewiesen.

Veränderliche Variablen sind mit dem <code>mutable</code> Schlüsselwort möglich und werden mit dem Zuweisungsoperator <code><-</code> 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# auch ''functional first'', also „funktional-zuerst“.<ref>{{Internetquelle |url=https://slideslive.com/38904441/functionalfirst-programming-with-f?ref=og-meta-tags |titel=Functional-first Programming with F# |sprache=en-US |abruf=2023-09-14}}</ref>

<syntaxhighlight lang="fsharp">
let mutable x = 10
x <- 15
</syntaxhighlight>

Werte im Nachhinein zu verändern, ist auch durch die Verwendung von sogenannten ''reference cells'' möglich:

<syntaxhighlight lang="fsharp">
let x = ref 0 // x hat den Typ "int ref", ist also eine Referenz auf einen Integer
x := 5 // x wird ein neuer Wert zugewiesen
printfn "%i" !x // Mittels des "!"-Operators wird x dereferenziert. Gibt 5 aus.
</syntaxhighlight>

=== Funktionen ===
Funktionen werden wie andere Werte mit <code>let</code> deklariert und können Parameter erwarten:
<syntaxhighlight lang="fsharp">
let square x = x * x
let add x y = x + y
</syntaxhighlight>

Funktionen können Funktionen als Parameter erwarten (siehe [[Funktion höherer Ordnung]]):
<syntaxhighlight lang="fsharp">
let do_twice f x = f (f x)
</syntaxhighlight>

Die Typen der Parameter werden automatisch erkannt, können aber auch explizit deklariert werden:
<syntaxhighlight lang="fsharp">
let add (x: int) (y: int) :int = x + y
let do_twice (f : int -> int) (x: int) = f (f x)
</syntaxhighlight>

Die Anweisung
<syntaxhighlight lang="fsharp">
printfn "%A" (do_twice square 5)
</syntaxhighlight>
gibt 625 (das Quadrat des Quadrats von 5) aus. Die Funktion <code>do_twice</code> kann mit Hilfe des [[Komposition (Mathematik)|Kompositionsoperators]] und nach [[Eta-Reduktion]] auch als
<syntaxhighlight lang="fsharp">
let do_twice f = f >> f
</syntaxhighlight>
geschrieben werden.

Im obigen Beispiel wird für <code>square</code> der Typ <syntaxhighlight lang="fsharp" style="white-space:nowrap" inline>int -> int</syntaxhighlight> ermittelt, das heißt, <code>square</code> ist eine Funktion, die einen Parameter vom Typ <code>int</code> erwartet und einen Wert vom Typ <code>int</code> zurückgibt. Für <syntaxhighlight lang="fsharp" inline>do_twice</syntaxhighlight> erhält man den Typ <syntaxhighlight lang="fsharp" style="white-space:nowrap" inline>('a -> 'a) -> 'a -> 'a</syntaxhighlight>. Dies bedeutet, <code>do_twice</code> ist eine Funktion, die als ersten Parameter einen Wert vom Typ <syntaxhighlight lang="fsharp" style="white-space:nowrap" inline>('a -> 'a)</syntaxhighlight> (eine Funktion mit einem Parameter vom Typ <syntaxhighlight lang="fsharp" inline>'a</syntaxhighlight> und einem Rückgabewert vom Typ <syntaxhighlight lang="fsharp" inline>'a</syntaxhighlight>) bekommt. Als zweiten Parameter erhält sie einen Wert vom Typ <syntaxhighlight lang="fsharp" inline>'a</syntaxhighlight> und sie gibt einen Wert vom Typ <syntaxhighlight lang="fsharp" inline>'a</syntaxhighlight> zurück. <syntaxhighlight lang="fsharp" inline>'a</syntaxhighlight> hat hier die Rolle einer Typvariable (grob vergleichbar mit Generic- oder Template-Parametern in [[Java (Programmiersprache)|Java]]/[[C++]], siehe [[Polymorphie (Programmierung)]]).

In F# werden Parameter ohne Klammern etc., nur durch Leerzeichen getrennt, an die Funktion übergeben. Nur wenn als [[Parameter (Informatik)|Parameter]] der Rückgabewert einer anderen Funktion benötigt wird, müssen Klammern gesetzt werden, um die Evaluierungsreihenfolge der Ausdrücke zu definieren. Bei <syntaxhighlight lang="fsharp" style="white-space:nowrap" inline>printfn "%A" (add 5 8)</syntaxhighlight> gehören die Werte 5 und 8 zur Funktion <syntaxhighlight lang="fsharp" inline>add</syntaxhighlight>; deren Rückgabewert ist ein Parameter für die Funktion <syntaxhighlight lang="fsharp" inline>printfn</syntaxhighlight>.

F# ermöglicht [[Closure (Funktion)|Closures]] und verwendet [[Currying]] automatisch:

<syntaxhighlight lang="fsharp">
let add x y = x + y
let inc = add 1
</syntaxhighlight>

In der Definition von <code>inc</code> wird der erste Parameter der Funktion <code>add</code> an den Wert 1 gebunden. Das Ergebnis dieser [[Partielle Funktionsanwendung|partiellen Funktionsanwendung]] ist eine neue Funktion mit nur noch einem Parameter. Die Auswertung des Ausdrucks
<syntaxhighlight lang="fsharp">
inc 5
</syntaxhighlight>
liefert als Ergebnis 6.

F# unterstützt [[Tupel (Informatik)|Tupel]]:
<syntaxhighlight lang="fsharp">
let u = (3, 6)
let v = (2, -3)
let add (a, b) (c, d) = (a + c, b + d)
let x, y = add u v
</syntaxhighlight>

F# bietet ''Discriminated Unions''<ref>[https://learn.microsoft.com/de-de/dotnet/fsharp/language-reference/discriminated-unions Unterscheidungs-Unions], auf learn.microsoft.com</ref> und [[Pattern Matching]]:

<syntaxhighlight lang="fsharp">
// 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 Integer
type Baum =
| Ast of Baum * Baum
| Blatt of int

let rec baumSumme x =
match x with
| Ast(l, r) -> baumSumme l + baumSumme r
| Blatt(x) -> x
</syntaxhighlight>

Ebenso gibt es [[Type Provider]] für die typsichere Verarbeitung externer Daten mit [[IntelliSense]].<ref>[https://docs.microsoft.com/en-us/dotnet/fsharp/tutorials/type-providers/ Type Provider]</ref>

In F# ist auch [[Objektorientierte Programmierung|objektorientiertes Programmieren]] möglich. Beispiel für eine Klassendeklaration:

<syntaxhighlight lang="fsharp">
type Person =
val name : string
val mutable age : int
new(n, a) = { name = n; age = a }
member x.Name = x.name
member x.Age
with get() = x.age
and set(v) = x.age <- v
member x.Print() = printfn "%s ist %i Jahre alt." x.name x.age
</syntaxhighlight>

[[Zeiger (Informatik)#Nullzeiger|Nullzeiger]] werden nur für die Interaktion mit Klassen aus dem [[.Net-Framework]] benötigt.

== Syntax ==
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:
{| class="wikitable toptextcells"
|-
! einfache Syntax !! ausführliche Syntax
|-
|
<syntaxhighlight lang="fsharp">
let mutable x = 1

while x < 3 do
x <- x + 1
</syntaxhighlight>
|
<syntaxhighlight lang="fsharp">
let mutable x = 1

while x < 3 do
x <- x + 1
done
</syntaxhighlight>
|-
|
<syntaxhighlight lang="fsharp">
type Person =
val name : string
val mutable age : int
</syntaxhighlight>
|
<syntaxhighlight lang="fsharp">
type Person =
class
val name : string
val mutable age : int
end
</syntaxhighlight>
|}

Bei der einfachen Syntax sind die Einrückungen zwingend erforderlich, bei der ausführlichen könnte man sie auch weglassen.

== Entwicklungsumgebung und Compiler ==

F#-Code wird [[Compiler|kompiliert]], hierbei entsteht [[Zwischencode]] in der [[Common Intermediate Language]] (CIL), genau wie bei Programmen, die in [[C-Sharp|C#]] oder [[VB.NET]] geschrieben wurden.

Es gibt auch eine interaktive Umgebung bzw. F#-[[Interpreter]], F# Interactive oder kurz FSI. Damit kann man den Code direkt in der [[Kommandozeile|Konsole]] schreiben. Eingaben im Interpreter sind mit <code>;;</code> 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.<ref>[http://msdn.microsoft.com/de-de/library/dd233175.aspx Microsoft F# Interactive-Referenz]</ref>

Dieser Interpreter erlaubt in unterstützten Editoren wie [[Visual Studio Code]] die Ausführung von Code ohne vorherige Kompilierung, so wie dies von dynamischen Sprachen bekannt ist.

Außerdem gibt es den Fable<ref>{{Internetquelle |url=https://fable.io/ |titel=Fable · JavaScript you can be proud of! |abruf=2023-09-14}}</ref>-Übersetzer, mit dessen Hilfe sich F#-Code in [[JavaScript]], [[Rust (Programmiersprache)|Rust]], [[Python (Programmiersprache)|Python]], [[PHP]] und [[Dart (Programmiersprache)|Dart]] übersetzen lässt.

== Beispiele ==

Folgende Beispiele eines [[Hallo-Welt-Programm]]s geben „Hello World“ aus.

<syntaxhighlight lang="fsharp">
let main = System.Console.WriteLine("Hello World")
</syntaxhighlight>

oder

<syntaxhighlight lang="fsharp">
printfn "Hello World"
</syntaxhighlight>

Die folgende Funktion implementiert die rekursive [[Ackermannfunktion]]:
<syntaxhighlight lang="fsharp">
let rec ack m n =
if m = 0 then n + 1
else if n = 0 then ack (m - 1) 1
else ack (m - 1) (ack m (n - 1))
</syntaxhighlight>

== Literatur ==
* Oliver Sturm: ''F# Einstieg und praktische Anwendung''. entwickler.press, 2012, ISBN 978-3-86802-083-0.

== Weblinks ==
{{Commonscat|F Sharp (programming language)|F-Sharp}}
* {{Internetquelle |url=http://fsharp.org/ |titel=The F# Software Foundation |abruf=2014-06-05 |sprache=en}}
* {{Internetquelle |url=https://docs.microsoft.com/de-de/dotnet/fsharp/ |titel=F# Dokumentation |werk=Microsoft Docs |hrsg=Microsoft |abruf=2014-04-27}}
* {{Internetquelle |url=https://github.com/dotnet/fsharp |titel=F# compiler, Basisbibliothek und Tools auf GitHub |abruf=2020-06-09 |sprache=en}}
* {{Internetquelle |url=http://research.microsoft.com/en-us/um/cambridge/projects/fsharp/default.aspx |titel=F# at Microsoft Research |hrsg=Microsoft Research |abruf=2014-04-27 |sprache=en |kommentar=F#-Homepage von Microsoft Research}}
* {{Internetquelle |url=http://www.ctocorner.com/fsharp/book/default.aspx |titel=The F# Survival Guide |hrsg=CTO Corner |archiv-url=https://web.archive.org/web/20110715231625/http://www.ctocorner.com/fsharp/book/default.aspx |archiv-datum=2011-07-15 |abruf=2014-04-27 |sprache=en}}
* {{Internetquelle |url=http://dungpa.github.io/fsharp-cheatsheet/ |titel=F# Cheatsheet |werk=Github |abruf=2020-06-09 |sprache=en|hrsg=}}
* {{Internetquelle |autor=Scott Wlaschin |url=http://fsharpforfunandprofit.com/posts/low-risk-ways-to-use-fsharp-at-work/ |titel=Twenty six low-risk ways to use F# at work |werk=F# for fun and profit |datum=2014-04-20 |abruf=2020-06-09 |sprache=en}}
* {{Internetquelle |url=https://try.fsharp.org/ |titel=Try F# |hrsg=F# Software Foundation |abruf=2020-06-09 |sprache=en}} Interaktives Tutorial.

== Belege ==
<references />

{{Normdaten|TYP=s|GND=7578680-1}}

[[Kategorie:Funktionale Programmiersprache]]
[[Kategorie:Microsoft]]
[[Kategorie:.NET]]
[[Kategorie:Programmiersprache für die Common Language Runtime]]

F-Sharp - Versionsgeschichte

imported>Derkoenig: lf, Commonscat mit Helferlein hinzugefügt