F-Sharp

aus Wikipedia, der freien Enzyklopädie
Wechseln zu: Navigation, Suche
Icon falscher Titel.svg Der korrekte Titel dieses Artikels lautet „F#“. Diese Schreibweise ist aufgrund technischer Einschränkungen nicht möglich.
F#
Paradigmen: multiparadigmatisch: funktional, imperativ, objektorientiert
Erscheinungsjahr: 2002
Entwickler: Microsoft
Aktuelle Version: 3.0  (15. August 2012)
Typisierung: statisch, stark, implizit
Beeinflusst von: Objective CAML, C#, Haskell
Betriebssystem: plattformübergreifend
Lizenz: Apache-Lizenz 2.0
Microsoft F# Developer Center

F# (lies: F sharp; englische Aussprache [ɛf: ʃɑrp]) ist eine funktionale Programmiersprache von Microsoft für das .NET-Framework. F# ist mit den Sprachen OCaml und ML verwandt, die Syntax der Sprachen ähneln sich daher stark. Viele OCaml-Programme, die ungewöhnliche Konstrukte und Caml-spezifische Bibliotheken vermeiden, können deswegen ohne Änderung mit F# kompiliert werden.

Neben den Bestandteilen der funktionalen Programmierung sind in F# objektorientierte sowie imperative Sprachkonstrukte enthalten.

Ursprünglich wurde F# als Forschungsprojekt von Microsoft Research entwickelt, derzeit wird es von Microsofts Entwicklungsabteilung fortgeführt. F# wird als Teil von Visual Studio 2010 erstmals offiziell unterstützt und mit ausgeliefert.[1] Außerdem ist es auch als Erweiterung zu Visual Studio 2008 erhältlich.[2] Im November 2010 wurde F# sowie zugehörige Compiler und Bibliotheken unter der Apache-Lizenz 2.0 freigegeben.

Einige Sprachmerkmale[Bearbeiten]

Werte[Bearbeiten]

In funktionalen Programmiersprachen wie F# gibt es keine Variablen wie in imperativen Programmiersprachen. Stattdessen können mit dem Schlüsselwort let Werte eines bestimmten Typs deklariert werden:

let pi = 3.1415927
let name = "John"

F# bietet Typableitung, d. h. Typen von Ausdrücken werden automatisch ermittelt. Beispielsweise bekommt pi automatisch den Typ des Gleitkommazahl-Literals zugewiesen.

Werte sind im Normalfall unveränderlich, Sie können während der gesamten Ausführung eines Programms nicht geändert werden.

let pi = 3.1415927
let pi = 10.0

kann aus diesem Grund nicht kompiliert werden, da der Wert pi zweimal innerhalb desselben Gültigkeitsbereichs deklariert wird. Soll der Wert einer Variablen im Programmablauf änderbar sein, muss dies bereits bei der Deklaration kenntlich gemacht werden:

let mutable x = 0 // x wird durch das "mutable"-Schlüsselwort als veränderlich gekennzeichnet
x <- 5            // x wird ein neuer Wert zugewiesen
printfn "%i" x    // Gibt 5 aus

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

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.

Funktionen[Bearbeiten]

Funktionen werden wie andere Werte mit let deklariert und können Parameter erwarten:

let square x = x * x
let add x y = x + y

Funktionen können Funktionen als Parameter erwarten (siehe Funktion höherer Ordnung):

let do_twice f x = f (f x)

Die Typen der Parameter werden automatisch erkannt, können aber auch explizit deklariert werden:

let add (x: int) (y: int) :int = x + y
let do_twice (f : int -> int) (x: int) = f (f x)

Die Anweisung

printfn "%A" (do_twice square 5)

gibt 625 (das Quadrat des Quadrats von 5) aus. Die Funktion do_twice kann mit Hilfe des Kompositionsoperators und nach eta-Reduktion auch als

let do_twice f = f >> f

geschrieben werden.

Im obigen Beispiel wird für square der Typ int -> int ermittelt, das heißt, square ist eine Funktion, die einen Parameter vom Typ int erwartet und einen Wert vom Typ int zurückgibt. Für do_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 in Java/C++, siehe Polymorphie (Programmierung)).

In F# werden Parameter ohne Klammern etc., nur durch Leerzeichen getrennt, an die Funktion übergeben. Nur wenn als Parameter der Rückgabewert einer anderen Funktion benötigt wird, müssen Klammern gesetzt werden, um die Evaluierungsreihenfolge der Ausdrücke zu definieren. Bei printfn "%A" (add 5 8) gehören die Werte 5 und 8 zur Funktion add; deren Rückgabewert ist ein Parameter für die Funktion printfn.

F# ermöglicht Closures und verwendet Currying:

let add x y = x + y
let inc = add 1

In der Definition von inc wird der erste Parameter der Funktion add an den Wert 1 gebunden. Das Ergebnis dieser partiellen Funktionsanwendung ist eine neue Funktion mit nur noch einem Parameter. Die Auswertung des Ausdrucks

inc 5

liefert als Ergebnis 6.

F# unterstützt Tupel:

let u = (3, 6)
let v = (2, -3)
let add (a, b) (c, d) = (a + c, b + d)
let x, y = add u v

F# bietet Discriminated Unions und Pattern 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 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

In F# ist auch objektorientiertes Programmieren möglich. Beispiel für eine Klassendeklaration:

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

F# ist konform mit der Common Language Infrastructure. Somit kann in F# auf Typen zugegriffen werden, die in anderen .NET-Sprachen geschrieben sind, und umgekehrt. Nullzeiger werden nur für die Interaktion mit Klassen aus dem .NET-Framework benötigt.

Syntax[Bearbeiten]

Im F#-Code sind zwei Syntax-Formen möglich: einfache Syntax und ausführliche Syntax. Die einfache Syntax wird standardmäßig verwendet, allerdings sind bei dieser Form die Einzüge sehr wichtig. Diese spielen bei der ausführlichen Syntax eine kleinere Rolle, denn dort bestimmen eher Schlüsselwörter wie zum Beispiel begin, end und in Anfang und Ende von Codeblöcken.[3]

Beispiel für die einfache und ausführliche Syntax:

einfache Syntax ausführliche Syntax
let mutable x = 1
 
while x < 3 do
    x <- x + 1
 
let mutable x = 1
 
while x < 3 do
    x <- x + 1
done
type Person =
    val name : string
    val mutable age : int
 
 
type Person =
class
    val name : string
    val mutable age : int
end

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

Entwicklungsumgebung und Compiler[Bearbeiten]

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

F# ist nicht in den kostenfreien Visual Studio Express Editions enthalten, kann aber durch ein kostenfreies Toolkit nachträglich installiert werden. F# wird bei den kostenpflichtigen Visual Studio Editionen direkt mitgeliefert.

Es gibt auch eine interaktive Umgebung bzw. F#-Interpreter, F# Interactive oder kurz FSI. Damit kann man den Code direkt in der Konsole 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.[4]

Beispiel[Bearbeiten]

Folgende Beispiele geben „Hello World“ aus.

let main = System.Console.WriteLine("Hello World")

oder

printfn "Hello World"


Die folgende Funktion implementiert die rekursive Ackermannfunktion:

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))

Weblinks[Bearbeiten]

Literatur[Bearbeiten]

Einzelnachweise[Bearbeiten]

  1. Don Syme's WebLog on the F# Language and Related Topics: F# to ship as part of Visual Studio 2010
  2. F# at Microsoft Research research.microsoft.com
  3. Microsoft Ausführliche Syntax (F#)
  4. Microsoft F# Interactive-Referenz