F# (hat F Sharp ausgesprochen), ist eine Mehrparadigma-Programmiersprache, das.NET Fachwerk ins Visier nehmend, das funktionelle Programmierung sowie befehlende und objektorientierte Programmierdisziplinen umfasst. Es ist eine Variante von ML und ist mit der OCaml Durchführung größtenteils vereinbar. F# wurde von Don Syme an Microsoft Research am Anfang entwickelt, aber wird jetzt an Microsoft Developer Division entwickelt und wird als eine völlig unterstützte Sprache im.NET Fachwerk und Sehstudio als ein Teil des Sehstudios 2010 verteilt.

Übersicht

F# ist eine stark getippte Sprache, die Typ-Schlussfolgerung verwendet. Infolgedessen brauchen Datentypen nicht vom Programmierer ausführlich erklärt zu werden; sie werden durch den Bearbeiter während der Kompilation abgeleitet. Jedoch, F# erlaubt auch ausführliche Datentyp-Behauptung. Eine CLI entgegenkommende Sprache, F# zu sein, unterstützt alle Typen CLI und Gegenstände, aber er erweitert das Typ-System und kategorisiert Typen als unveränderliche Typen oder veränderliche Typen. CLI Gegenstände klassifizieren als veränderliche Typen (der im Platz editiert werden kann), und verwendet werden, um ein objektorientiertes Programmiermodell zur Verfügung zu stellen. Unveränderliche Typen (solch einen Typ editierend, schafft ein neues Beispiel, ohne das ältere zu überschreiben), werden in erster Linie für die funktionelle Programmierung verwendet.

Wie ML, F# schließt einen funktionellen Programmierbestandteil das Unterstützen eifriger Einschätzung ein. Für die funktionelle Programmierung stellt es mehrere Konstruktionen und eine Reihe unveränderlicher Typen zur Verfügung: Tupel, Aufzeichnungen, haben Vereinigungen und Listen unterschieden.

Ein N-Tupel vertritt eine Sammlung von N-Werten, wo n  0. Der Wert n wird den arity des Tupels genannt. Der Typ entspricht dem 0-Tupel-, und er hat einen Wert nur: der keine Information befördert. Der Typ wird verwendet, um Funktionen durchzuführen, die keinen Eingang brauchen und/oder keinen Wert zurückgeben. Ein 3-Tupel-würde als vertreten, wo A, B und C Werte vielleicht verschiedener Typen sind. Ein Tupel kann nur verwendet werden, um Werte zu versorgen, wenn die Zahl von Werten am designmaligen bekannt ist und unveränderlich während der Ausführung bleibt.

Eine Aufzeichnung ist eine Spezialisierung des Tupels, wo die Datenmitglieder, als darin genannt werden. Aufzeichnungen können als geschaffen werden. Das Schlüsselwort wird verwendet, um eine Kopie einer Aufzeichnung, als darin zu schaffen, der eine neue Aufzeichnung durch das Kopieren und das Ändern des Werts des Feldes schafft (das Annehmen, dass die im letzten Beispiel geschaffene Aufzeichnung genannt wurde).

Der Listentyp ist eine regelmäßige verbundene Liste vertreten jedes Verwenden einer Notation (ist lernt Maschinenbediener), oder eine Schnellschrift als. Eine leere Liste wird geschrieben.

Die andere Sorte des algebraischen erwähnten Datentyps, "unterschiedene Vereinigungen" (vor dem Typ sichere Versionen von C Vereinigungen), kann definiert werden, um einen Wert von einigen eines vorherbestimmten Typs zu halten. Zum Beispiel,

Typ A =

| ConstructorX der Schnur

| ConstructorY der internen Nummer

</Quelle>

kann Werte, wie realisiert, durch jeden Konstrukteur halten. Der Typ der Werte, denen die Konstrukteure folgen werden, kann ebenso definiert werden.

Konstrukteure werden verwendet, um eine Ansicht vom Datentyp zu schaffen, der von der wirklichen Durchführung, wie erforderlich, verschieden ist, für das Aktive Muster-Konzept zu unterstützen. Datentypen werden mit dem Schlüsselwort geschaffen. F# verwendet das Schlüsselwort für verbindliche Typ-Werte zu einem Namen (Variable).

F# verwendet Muster, das zusammenpasst, um Namen in Werte aufzulösen. Es wird auch verwendet, wenn man auf unterschiedene Vereinigungen zugreift. Funktionen mit einer unterschiedenen Vereinigung stellen verschiedene anzurufende Ausdrücke zur Verfügung, mit dem Datentyp in der Vereinigung vereinigt. Die Vereinigung wird gegen diese Datentypen verglichen, und der mit dem Match vereinigte Ausdruck wird angerufen. F# unterstützt auch das Aktive Muster-Muster. Es wird zum Beispiel verwendet, wenn ein Typ vielfache Ansichten zur Verfügung stellen muss. Zum Beispiel wird eine Exponentialzahl, sowie die Basis und Hochzahlen, der Endwert zur Verfügung stellen.

Alle Funktionen in F# sind Beispiele des Typs, und sind ebenso unveränderlich. Funktionen können mit Currysoße zubereitet werden. Wenn man ein Beispiel eines Typs ist, können Funktionen als Argumente für andere Funktionen passiert werden, auf höhere Ordnungsfunktionen hinauslaufend. F# unterstützt Lambda-Funktionen und Verschlüsse ebenso. Wie andere funktionelle Programmiersprachen, F# erlaubt Funktionszusammensetzung mit dem Maschinenbediener. Jede Behauptung in F#, einschließlich Behauptungen und Schleifen, ist ein composable Ausdruck mit einem bestimmten Rücktyp ebenso. Funktionen und Ausdrücke, die keinen Wert zurückgeben, haben einen Rücktyp dessen.

F# wird erweitertes Typ-System als allgemeine.NET Typen durchgeführt. Der Typ Record schafft eine.NET Klasse mit den Feldnamen als Eigenschaften. Tupel sind allgemeine Klassen des Typs

F#, wie andere.NET Sprachen, kann.NET Typen und Gegenstände mit einem befehlenden objektorientierten Stil der Programmierung verwenden. Für die befehlende Programmierung, F# Unterstützungen und Schleifen, Reihe (geschaffen mit der Syntax und den Zahl-Folgen, die in der Schnellschrift als in geschrieben sind) und Unterstützung, um zu schaffen (gleichwertig zu.NET Klassen). F# erlaubt auch, die Syntax zu erweitern, um Einbetten-Gewohnheit bereichsspezifische Sprachen innerhalb F# Sprache selbst zu unterstützen.

F# stellt Folge-Ausdrücke zur Verfügung, der ein Definieren eines Folge-Blocks (oder oder) kurz zusammenfassende Konstruktionen berücksichtigt (entweder Funktionen, bedingte Ausdrücke oder Schleifen), die einer Sammlung und einer anderen Funktion (oder Lambda), solch folgen, dass die Funktion auf den von den Sammlungssammlungsverarbeitungsausdrücken nachgegebenen Ergebnissen angerufen wird. Zum Beispiel,

Folge-Ausdrücke und Berechnungsausdrücke werden auch verwendet, um asynchrone Arbeitsabläufe zu schaffen. Ein asynchroner Arbeitsablauf wird als eine Folge von Befehlen innen a, als in definiert

lassen Sie asynctask = async

{\

lassen Sie req = WebRequest. Schaffen Sie (URL-Adresse)

lassen Sie! Antwort = req. GetResponseAsync

verwenden Sie Strom = Antwort. GetResponseStream

verwenden Sie streamreader = neues System. IO.StreamReader (Strom)

geben Sie streamreader zurück. ReadToEnd

}\

</Quelle>

Das Erlauben des Rests des async blockiert, um als der Delegierte definiert und als die Rückrufaktionsfunktion einer asynchronen Operation passiert zu werden. Das hilft, sich mit Inversion von Kontrollproblemen zu befassen. Der Async-Block wird mit der Funktion angerufen. Vielfache Async-Blöcke werden in der Parallele mit der Funktion durchgeführt, die eine Liste von Gegenständen nimmt (im Beispiel, ist ein Async-Gegenstand), und schafft einen anderen Async-Gegenstand, die Aufgaben in den Listen in der Parallele zu führen. Der resultierende Gegenstand wird damit angerufen.

F# kommt mit einem Sprachdienst von Microsoft Visual Studio, der es mit dem IDE integriert. Mit dem Sprachdienst kann installiertes, Visuelles Studio verwendet werdenF# zu schaffen, Projekte und das Sehstudio-Testhilfeprogramm haben gepflegtF# Code die Fehler zu beseitigen. Außerdem kommt es mit einer interaktiven Studio-veranstalteten Sehkonsole, die F# Code durchführt, wie es geschrieben wird.

SharpDevelop unterstützt F# ebenso seit der Version 3.0.

LINQPad unterstützt F# ebenso seit der Version 2.x.

Beispiele

Einige kleine Proben folgen:

(* ist Das eine Anmerkung *)

(* Probe hallo Weltprogramm *)

printfn "Hallo Welt!"

</Quelle>

Ein einfaches Beispiel, das häufig verwendet wird, um die Syntax von funktionellen Sprachen zu demonstrieren, ist die Factorial-Funktion für nichtnegative ganze 32-Bit-Zahlen, die hier in F#: gezeigt sind

lassen Sie rec factorial n =

vergleichen Sie n mit

| 0-> 1

| _-> n * factorial (n - 1)

</Quelle>

Rekursive Funktionsbeispiele:

(* Druck eine Liste von Zahlen rekursiv *)

lassen Sie rec printList lst =

vergleichen Sie lst mit

| []->

| h:: t->

printf "%d\n" h

printList t

(* Dasselbe Ding, mit dem Zusammenbringen gegen Listenelemente *)

lassen Sie rec printList2 l =

vergleichen Sie l mit

| []->

| h:: t-> printfn "%A" h

printList2 t

(* das Verwenden der Schnellschrift für das Match *)

lassen Sie rec printList3 = Funktion

| []-> | h:: t-> printfn "%A" h

printList3 t

(* Oder, mit einer höherwertigen Funktion *)

lassen Sie printlist4 lst = List.iter (printfn "%A") lst

</Quelle>

(* Fibonacci-Zahl-Formel *)

lassen Sie rec Flunkerei n =

vergleichen Sie n mit

| 0 | 1-> n

| _-> Flunkerei (n - 1) + Flunkerei (n - 2)

(* Eine alternative Annäherung - eine faule rekursive Folge von Fibonacci-Zahlen *)

lassen Sie rec Flunkereien = Seq.cache

(* eine Andere Annäherung - eine faule unendliche Folge von Fibonacci-Zahlen *)

lassen Sie fibSeq = Seq.unfold (Spaß (a, b)-> Einige (a+b, (b, a+b))) (1,1)

(* Druck sogar Flunkereien *)

[1.. 10]

|> List.map Flunkerei

|> List.filter (Spaß n-> (n % 2) = 0)

|> printlist

(* Dasselbe Ding, mit Folge-Ausdrücken *)

[weil ich in 1.. 10 tun

lassen Sie r = Flunkerei i

wenn r % 2 = 0 dann Ertrag r]

|> printlist</Quelle>

(* bildet Beispielwindows Programm *)

(* müssen Wir die Systembibliothek für die Klasse von STAThreadAttribute * öffnen)

öffnen Sie System

(* müssen Wir die Windows-Form-Bibliothek * öffnen)

offenes System. Windows. Formen

(* Schaffen ein Fenster und setzen einige Eigenschaften *)

lassen Sie Form = neue Form (Visible=true, TopMost=true, Text = "Willkommen in F#")

(* Schaffen ein Etikett, um einen Text in der Form * zu zeigen)

,

lassen Sie Etikett =

lassen Sie Zeitsekretärin = neues Etikett

lassen Sie x = 3 + (4 * 5)

(* Satz der Wert des Textes *)

Zeitsekretärin. Text

Anwendung. Geführt (bilden)

</Quelle>

(* Async Arbeitsablauf-Probe (passen Zentraleinheit und Eingabe/Ausgabe-Aufgaben an) *)

(* Ein sehr naiver Primzahl-Entdecker *)

lassen Sie isPrime (n:int) =

lassen Sie gebunden = interne Nummer (System. Mathematik. Sqrt (lassen n schwimmen))

seq {2.. gebunden} |> Seq.exists (Spaß x-> n % x = 0) |> nicht

(* verwenden Wir async Arbeitsabläufe *)

lassen Sie primeAsync n =

async {Rückkehr (n, isPrime n) }\

(* Rückblüte zwischen M und n das Verwenden vielfacher Fäden *)

lassen Sie Blüte M n =

seq {M. n }\

|> Seq.map primeAsync

|> Async. Parallele

|> Async. RunSynchronously

|> Array.filter snd

|> Array.map fst

(* Durchgeführt ein Test *)

Blüte 1000000 1002000

|> Array.iter (printfn "%d")

</Quelle>

Siehe auch

C#

• Clojure
• Haskell
• Quecksilber
• ML
• Nemerle
• OCaml
• Scala

Referenzen

Links

• Die Website von Microsoft Research für

F#

• Microsoft F# Developer Center
• Der Webklotz von Don Syme, eine Schlüsselinformationsquelle auf

F#

• Planet

F#

• F# Überleben-Führer, Dez 2009 (Webbasiertes Buch)
• F# 2.0 Sprachspezifizierung
• Eine Einführung in F#, programmierend