F scharf (Programmiersprache)

F#

F# Logomark
Paradigma	Multi-Paradigma: funktional, Imperativ, objektorientierter, agentenorientiert, Metaprogrammierung, reflektierend, gleichzeitig
Familie	Ml
Entworfen von	Don Syme, Microsoft Research
Entwickler	Microsoft, Die F# Software Foundation
Erstmals erschienen	2005; Vor 17 Jahren, Version 1.0
Stabile Version	6.0[1]  / 19. Oktober 2021; vor 9 Monaten
Disziplin tippen	Statisch, stark, gefolgert
OS	Plattformübergreifend: .NETZ, .NET Framework, Mono
Lizenz	MIT -Lizenz[2][3]
Dateiname -Erweiterungen	.fs, .fsi, .fsx, .fsScript
Webseite	fsharp.org
Beeinflusst von
C#, Erlang, Haskell,[4] Ml, Ocaml,[5][6] Python, Scala
Beeinflusst
C#,[7] Ulme, F*, Livescript
F scharfe Programmierung bei Wikibooks

F# (ausgesprochen F scharf) ist eine funktionale erste, allgemeine Zwecke, stark tippt, Multi-Paradigma Programmiersprache das umfasst funktional, Imperativ, und Objekt orientierte Programmierung Methoden. Es wird am häufigsten als plattformübergreifend verwendet Gemeinsame Sprachinfrastruktur (Cli) Sprache auf .NETZ, kann aber auch erzeugen JavaScript^[8] und Grafikkarte (GPU) Code.^[9]

F# wird von der entwickelt F# Software Foundation,^[10] Microsoft und offene Mitwirkende. Ein Open Source, crad-plattform-Compiler für F# ist bei der F# Software Foundation erhältlich.^[11] F# ist eine voll unterstützte Sprache in Visual Studio^[12] und Jetbrains Rider.^[13] Plugins Unterstützung f# gibt es für viele weit verbreitete Redakteure, einschließlich Visual Studio -Code, Vim, und EMACs.

F# ist ein Mitglied der Ml Sprachfamilie und entstand als .NET Framework Implementierung eines Kerns der Programmiersprache Ocaml.^[5][6] Es wurde auch von beeinflusst von C#AnwesendPython, Haskell,^[4] Scala und Erlang.

Geschichte

Versionen

Sprachentwicklung

F# verwendet einen offenen Entwicklungs- und Engineering -Prozess. Der Sprachentwicklungsprozess wird von verwaltet von Don Syme aus Microsoft Research als die Wohlwollender Diktator für das Leben (BDFL) für das Sprachdesign zusammen mit der F# Software Foundation. Frühere Versionen der F# -Sprache wurden von entworfen von Microsoft und Microsoft Research Verwendung eines geschlossenen Entwicklungsprozesses.

F# stammt von Microsoft Research, Cambridge, Großbritannien. Die Sprache wurde ursprünglich von entworfen und implementiert von Don Syme,^[5] Nach wem im FSHARP -Team sagen sie, dass das F für "Spaß" ist.^[33] Andrew Kennedy trug zum Design von bei Maßeinheiten.^[5] Die Visual F# Tools für Visual Studio wurden von Microsoft entwickelt.^[5] Die F# Software Foundation entwickelte den F# Open-Source-Compiler und die Tools mit der Open-Source-Compiler-Implementierung des Microsoft Visual F# Tools-Teams.^[10]

Sprachübersicht

Funktionelle Programmierung

F# ist während der Unterstützung von objektorientierten Funktionen, die in C# verfügbar sind stark tippt funktionale erste Sprache mit einer großen Anzahl von Fähigkeiten, die normalerweise nur in gefunden werden Funktionelle Programmierung Sprachen. Zusammen können diese Funktionen ermöglichen, dass F# -Programme in einem vollständig funktionalen Stil geschrieben werden und auch funktionale und objektorientierte Stile gemischt werden können.

Beispiele für funktionale Merkmale sind:

• Alles ist ein Ausdruck
• Geben Sie Inferenz ein (Verwendung Hindley -Milner -Typ -Inferenz)
• Anonyme Funktionen mit erfassender Semantik (d. H., Schließungen)
• Unveränderliche Variablen und Objekte
• Faule Bewertung Unterstützung
• Funktionen höherer Ordnung
• Verschachtelte Funktionen
• Currying
• Musteranpassung
• Algebraische Datentypen
• Tupel
• Monad Musterunterstützung (genannt Berechnungsausdrücke^[41])
• Schwanzanrufoptimierung^[42]

F# ist eine ausdrucksbasierte Sprache mit Verwendung eifrige Bewertung und auch in einigen Fällen faule Bewertung. Jede Aussage in F#, einschließlich wenn Ausdrücke, Versuchen Ausdrücke und Schleifen sind ein komponierbarer Ausdruck mit einem statischen Typ.^[43] Funktionen und Ausdrücke, die keinen Wert zurückgeben Einheit. F# verwendet die Lassen Schlüsselwort zum Binden von Werten an einen Namen.^[43] Zum Beispiel:

Lassen x = 3 + 4 

bindet den Wert 7 zum Namen x.

Neue Typen werden mit dem definiert Typ Stichwort. Für die funktionale Programmierung bietet F# Tupel, Aufzeichnung, Diskriminierte Gewerkschaft, aufführen, Möglichkeit, und Ergebnis Typen.^[43] A Tupel repräsentiert einen Satz von n Werte, wo n ≥ 0. der Wert n wird genannt Arity des Tupels. Ein 3-Tupel würde als dargestellt als (A, b, c), wo a, b und c Werte für möglicherweise unterschiedliche Typen sind. Ein Tupel kann verwendet werden, um Werte nur zu speichern, wenn die Anzahl der Werte zur Designzeit bekannt ist und während der Ausführung konstant bleibt.

A Aufzeichnung ist ein Typ, bei dem die Datenmitglieder benannt sind. Hier ist ein Beispiel für die Datensatzdefinition:

 Typ R =   { Name : Saite   Das Alter : int } 

Datensätze können als erstellt werden let r = { Name="AB"; Age=42 }. Das mit Das Schlüsselwort wird verwendet, um eine Kopie eines Datensatzes zu erstellen, wie in { r with Name="CD" }, was einen neuen Rekord durch Kopieren erzeugt r und den Wert des Werts ändern Name Feld (unter der Annahme des im letzten Beispiels erstellten Datensatzes wurde benannt r).

A Diskriminierte Gewerkschaft Typ ist a Typ-Safe Version von C Gewerkschaften. Zum Beispiel,

 Typ A =   | Aßcasex von Saite  | Unioncasey von int 

Die Werte des Gewerkschaftstyps können einem der beiden Gewerkschaftsfall entsprechen. Die Arten der Werte, die von jedem Gewerkschaftsfall übernommen werden, sind in der Definition des einzelnen Falls enthalten.

Das aufführen Typ ist unveränderlich verlinkte Liste entweder mit a dargestellt head::tail Notation (:: ist der Nachteile Betreiber) oder eine Abkürzung als [item1; item2; item3]. Eine leere Liste wird geschrieben []. Das Möglichkeit Typ ist ein diskriminierter Gewerkschaftstyp mit Auswahlmöglichkeiten Einige (x) oder Keiner. F# Typen können sein generisch, implementiert als generische .NET -Typen.

F# unterstützt Lambda Funktionen und Schließungen.^[43] Alle Funktionen in F# sind erstklassige Werte und sind unveränderlich.^[43] Funktionen können sein Curry. Als erstklassige Werte können Funktionen als Argumente an andere Funktionen übergeben werden. Wie andere funktionale Programmiersprachen erlaubt F# Funktionszusammensetzung (Informatik) Verwendung der >> und << Betreiber.

F# bietet Sequenzausdrücke^[44] das definiert eine Sequenz seq {...}, aufführen [...] oder Array [| ... |] über Code, der Werte generiert. Zum Beispiel,

 seq { zum b in 0 .. 25 tun  wenn b < 15 dann  Ertrag b*b } 

bildet eine Folge von Quadraten von Zahlen von 0 bis 14, indem Zahlen aus dem Zahlenbereich von 0 bis 25 herausgefiltert werden. Sequenzen sind Generatoren -Werte werden auf Nachfrage generiert (d. H. sind faul ausgewertet) - während Listen und Arrays eifrig bewertet werden.

F# verwendet Musteranpassung Werte an Namen binden. Bei dem Zugriff auf diskriminierte Gewerkschaften wird auch eine Musteranpassung verwendet - die Gewerkschaft ist Wert gegen Musterregeln und eine Regel wird ausgewählt, wenn eine Übereinstimmung erfolgreich ist. F# unterstützt auch Aktive Muster als eine Form eines erweiterbaren Musteranpassungen.^[45] Es wird beispielsweise verwendet, wenn mehrere Arten des Anpassung an einem Typ existieren.^[43]

F# unterstützt eine allgemeine Syntax für die Definition von Zusammensetzungsberechnungen, die genannt werden Berechnungsausdrücke. Sequenzausdrücke, asynchrone Berechnungen und Abfragen sind bestimmte Arten von Berechnungsausdrücken. Berechnungsausdrücke sind eine Implementierung der monad Muster.^[44]

Imperative Programmierung

F# Unterstützung für imperative Programmierung umfasst

• zum Schleifen
• während Schleifen
• Arrays, erstellt mit dem [| ... |] Syntax
• Hash-tabelle, erstellt mit dem DICT [...] Syntax oder System.Collectionss.generic.Dictionary <_, _> Typ.

Werte und Datensatzfelder können auch als als bezeichnet werden veränderlich. Zum Beispiel:

// 'x' mit dem Anfangswert '1' definieren Lassen veränderlich x = 1 // Ändern Sie den Wert von 'x' auf '3' x <- 3 

Außerdem unterstützt F# den Zugriff auf alle CLI -Typen und -objekte, wie sie in der definiert sind System.Collectionss.generic Namespace Definieren imperativen Datenstrukturen.

Objekt orientierte Programmierung

Wie andere Gemeinsame Sprachinfrastruktur (CLI) Sprachen, F# kann CLI-Typen durch objektorientierte Programmierung verwenden.^[43] F# Unterstützung für objektorientierte Programmierung in Ausdrücken umfasst::

• DOT-NOTATION, z. B.,, x.Name
• Objektausdrücke, z. B., { new obj() with member x.ToString() = "hello" }
• Objektkonstruktion, z. B.,, new Form()
• Typtests, z. B.,, x :? string
• Typzussionen, z. B.,, x :?> string
• Benannte Argumente, z. B., x.Method(someArgument=1)
• Setters namens, z. B.,, new Form(Text="Hello")
• Optionale Argumente, z. B., x.Method(OptionalArgument=1)

Unterstützung für objektorientierte Programmierung in Mustern umfasst

• Typtests, z. B.,, :? string as s
• Aktive Muster, die über Objekttypen definiert werden können^[45]

Definitionen für f# Objekttypen können Klassen-, Strukturm-, Schnittstellen-, Enum- oder Delegierende Definitionen sein, die den in den Definitionsformen gefundenen Definitionsformen entsprechen C#. Zum Beispiel ist hier eine Klasse mit einem Konstruktor, der einen Namen und Alter nimmt und zwei Eigenschaften erklärt.

/// eine einfache Definition des Objekttyps Typ Person(Name : Saite, das Alter : int) =  Mitglied x.Name = Name  Mitglied x.Das Alter = das Alter 

Asynchrone Programmierung

F# unterstützt Asynchrone Programmierung durch Asynchrone Workflows.^[46] Ein asynchroner Workflow wird als eine Folge von Befehlen in einem definiert Async {...}, wie in

Lassen Asynctask =   Async { Lassen Req = WebRequest.Schaffen(URL)  Lassen! Antwort = Req.Getresponseasync()  verwenden Strom = Antwort.GetresponSstream()  verwenden StreamReader = Neu System.Io.StreamReader(Strom)  Rückkehr StreamReader.Lectoend() } 

Das Lassen! Zeigt an, dass der Ausdruck rechts (das Erhalten der Antwort) asynchron erfolgen sollte, der Fluss jedoch nur so weitergehen sollte, wenn das Ergebnis verfügbar ist. Mit anderen Worten, aus der Sicht des Codeblocks ist es, als ob das Erhalten der Antwort ein Blockierungsanruf ist, während aus der Sicht des Systems der Thread nicht blockiert wird und kann verwendet werden, um andere Ströme zu verarbeiten Das für diesen benötigte Ergebnis wird zwar nicht verfügbar.

Der asynchrische Block kann mit dem aufgerufen werden Async.runsynchronous Funktion. Mehrere asynchronisierte Blöcke können parallel mit dem ausgeführt werden Async.parallel Funktion, die eine Liste von übernimmt Async Objekte (im Beispiel, Asynctask ist ein asynchrones Objekt) und erstellt ein anderes asynchrones Objekt, um die Aufgaben in den Listen parallel auszuführen. Das resultierende Objekt wird mit Verwendung aufgerufen Async.runsynchronous.^[46] Kontrollinversion In F# folgt diesem Muster.^[46]

Parallele Programmierung

Parallele Programmierung wird teilweise durch die unterstützt Async.parallel, Async.start und andere Operationen, die asynchrone Blöcke parallel ausführen.

Parallele Programmierung wird auch durch die unterstützt Array.Parallel Funktionelle Programmierbetreiber in der F# Standardbibliothek, direkte Verwendung des System.Threading.tasks Task -Programmiermodell, direkte Verwendung von .NET -Threadpool und .NET -Threads und durch dynamische Übersetzung von F# Code in alternative parallele Ausführungsmotoren wie z. GPU^[9] Code.

Maßeinheiten

Das F# -Typsystem unterstützt Maßeinheiten Überprüfung nach Zahlen.^[47] Die Funktionen der Messfunktion integrieren in die Inferenz von F# Typ, um minimale Anmerkungen im Benutzercode zu benötigen.^[48]

Metaprogrammierung

F# ermöglicht einige Formen der Syntax -Anpassung über Metaprogrammierung Um das Einbettung von Brauch zu unterstützen Domänenspezifische Sprachen Innerhalb der F# -Sprache, insbesondere durch Berechnungsausdrücke.^[43]

F# enthält eine Funktion für die Laufzeit-Metaprogrammierung, die als Zitate bezeichnet wird.^[49] Ein Zitatausdruck bewertet eine abstrakte Syntaxbaumdarstellung der F# -Ausdrücke. In ähnlicher Weise sind Definitionen mit dem gekennzeichnet [] Das Attribut kann auch in ihrem Anführungsformular zugegriffen werden. F# Zitate werden für verschiedene Zwecke verwendet, einschließlich zum Kompilieren von F# Code in JavaScript^[8] und GPU^[9] Code. (Zitate stellen ihre F# -Codesausdrücke als Daten für die Verwendung durch andere Teile des Programms dar, während es syntaktisch korrigiert wird, f# Code).

Informationsreiche Programmierung

F# 3.0 führte eine Form der Kompilierungszeit-Metaprogrammierung durch eine statisch erweiterbare Artgenerierung ein, die als F# -Typanbieter bezeichnet wird.^[50] Mit F# -Typanbietern können der F# Compiler und die Tools mit Komponenten erweitert werden, die zum Kompilierungszeitpunkt Typinformationen für den Compiler on-Demand zur Verfügung stellen. F# -Typanbieter wurden verwendet, um einen stark typisierten Zugriff auf vernetzte Informationsquellen auf skalierbare Weise zu gewähren, einschließlich der Werfebasis Wissensgrafik.^[51]

In F# 3.0 werden die Funktionen F# Zitat und Berechnungsausdruck kombiniert, um es zu implementieren Linq Abfragen.^[52] Zum Beispiel:

// Verwenden Sie den ODATA -Typ Anbieter, um Typen zu erstellen, mit denen Sie auf die Northwind -Datenbank zugreifen können. offen Microsoft.fsharp.data.typeProviders Typ Nordwind = Odataservice<"http://services.odata.org/northwind/northwind.svc"> Lassen db = Nordwind.GetDatacontext() // ein Abfrageausdruck. Lassen Abfrage1 = Anfrage { zum Kunde in db.Kunden tun  auswählen Kunde } 

Die Kombination von Typanbietern, Abfragen und stark typisierten funktionellen Programmierungen ist als bekannt als Informationsreiche Programmierung.^[53]

Agentenprogrammierung

F# unterstützt eine Variation der Schauspieler Programmiermodell durch die Implementierung von leichten asynchronen Wirkstoffen in Memory. Der folgende Code definiert beispielsweise einen Agenten und veröffentlicht 2 Nachrichten:

Lassen Zähler =  Mailboxprozessor.Anfang(Spaß Posteingang ->  Lassen Rec Schleife n =  Async { tun printfn "n = %d, wartet ..." n  Lassen! Nachricht = Posteingang.Erhalten()  Rückkehr! Schleife(n+Nachricht) }  Schleife 0) 

Entwicklungswerkzeuge

• Visual Studio, mit den visuellen F# -Tools von Microsoft Installiert, kann zum Erstellen, Ausführen und Debuggen von F# -Projekten verwendet werden. Die visuellen F# -Tools enthalten ein visuelles Studio, das veranstaltet wurde Read -E -druck -Schleife (Repl) Interaktive Konsole, die den F# -Codel ausführen kann, wie sie geschrieben wird. Visual Studio für Mac unterstützt auch F# -Projekte.
• Visual Studio -Code enthält die volle Unterstützung für F# über die Ionid -Erweiterung.
• F# kann mit jedem Texteditor entwickelt werden. Spezifische Unterstützung gibt es bei Redakteuren wie z. EMACs.
• Jetbrains Rider ist für die Entwicklung des F# -Codes ab Release 2019.1 optimiert.^[54]
• Linqpad hat F# seit Version 2.x unterstützt.^[Deren?]

Anwendungsbereiche

F# ist a Allzweckprogrammiersprache.

Web Programmierung

Das Sicherer Stapel ist ein End-to-End-F# Stack zur Entwicklung von Webanwendungen. Es verwendet ASP.NET CORE Auf der Serverseite und Fabel Auf der Clientseite.^[55]

Eine alternative End-to-End-Option ist die Option Websharper Rahmen.^[56]

Plattformübergreifende App-Entwicklung

F# kann zusammen mit dem verwendet werden Visual Studio -Tools für Xamarin Apps für die Entwicklung von Apps für iOS und Android. Das Fabelhaft Die Bibliothek bietet eine komfortablere funktionale Schnittstelle.

Analytische Programmierung

Unter anderem wird F# für die quantitative Finanzierungsprogrammierung verwendet,^[57] Energiehandel und Portfoliooptimierung,^[58] maschinelles Lernen,^[59] Business Intelligence^[60] und soziale Spiele auf Facebook.^[61]

In den 2010er Jahren wurde F# als optimierte Alternative zu positioniert C#. Die Skriptfähigkeit und die Kompatibilität zwischen Sprache mit allen Microsoft-Produkten haben es bei Entwicklern beliebt.^[62]

Scripting

F# kann als Skriptsprache verwendet werden, hauptsächlich für Desktop Read -E -druck -Schleife (Repl.) Scripting.^[63]

Open-Source-Community

Das f# Open Source Community umfasst die F# Software Foundation^[10] und die F# Open Source -Gruppe bei GitHub.^[11] Beliebte Open-Source-F# -Projekte umfassen:

• Fabel, ein F# zu JavaScript -Transpiler basierend auf Babel.
• Paket, einen alternativen Paketmanager für .NET, der noch verwenden kann NuGet Repositories, hat aber eine zentralisierte Version des Versionsmanagements.
• GEFÄLSCHT, ein F# Friendly Build-System.
• Giraffe, eine funktional orientierte Middleware für ASP.NET CORE.
• Suave, eine leichte Webserver- und Webentwicklungsbibliothek.

Kompatibilität

F# verfügt über einen älteren "ML -Kompatibilitätsmodus", mit dem Programme, die in einer großen Untergruppe von OCAML grob geschrieben sind, ohne Funktionen, Objekte, polymorphe Varianten oder andere Ergänzungen direkt kompilieren können.

Beispiele

Es folgen ein paar kleine Proben:

// Dies ist ein Kommentar für ein Beispiel für ein Beispiel für ein Beispiel für das Hello World. printfn "Hallo Welt!" 

Eine Personklasse mit einem Konstruktor, der einen Namen und Alter und zwei unveränderliche Eigenschaften nimmt.

/// Dies ist ein Dokumentationskommentar für eine Typdefinition. Typ Person(Name : Saite, das Alter : int) =  Mitglied x.Name = Name  Mitglied x.Das Alter = das Alter      /// Klasse Instantiation Lassen Herr smith = Person("Schmied", 42) 

Ein einfaches Beispiel, das häufig verwendet wird, um die Syntax der funktionalen Sprachen zu demonstrieren, ist die faktorielle Funktion Für nicht negative 32-Bit-Ganzzahlen, hier in F#gezeigt:

/// Unter Verwendung des Muster -Matching -Ausdrucks Lassen Rec Fakultät n =  passen n mit  | 0 -> 1  | _ -> n * Fakultät (n - 1) /// für eine Einzelargument-Funktion gibt es syntaktische Zucker (Musteranpassungsfunktion): Lassen Rec Fakultät = Funktion   | 0 -> 1   | n -> n * Fakultät (n - 1)      /// Falten- und Bereichsoperator verwenden Lassen Fakultät n = [1..n] |> Seq.falten (*) 1 

Iterationsbeispiele:

/// Iteration mit einer 'für' Schleife Lassen Printliste lst =   zum x in lst tun  printfn "%d" x /// Iteration unter Verwendung einer Funktion höherer Ordnung Lassen Printlist2 lst =   Aufführen.Iter (printfn "%d") lst /// Iteration unter Verwendung einer rekursiven Funktion und Musteranpassung Lassen Rec Printlist3 lst =  passen lst mit  | [] -> ()  | h :: t ->  printfn "%d" h  Printlist3 t 

Beispiele für Fibonacci:

/// Fibonacci -Nummerformel Lassen Flunkerei n =  Lassen Rec g n f0 F1 =  passen n mit  | 0 -> f0  | 1 -> F1  | _ -> g (n - 1) F1 (f0 + F1)  g n 0 1 /// Ein anderer Ansatz - eine faule unendliche Abfolge von Fibonacci -Zahlen Lassen Fibseq = Seq.entfalten (Spaß (a,b) -> Etwas(a+b, (b, a+b))) (0,1) // sogar Fibs drucken [1 .. 10] |> Aufführen.Karte  Flunkerei |> Aufführen.Filter  (Spaß n -> (n % 2) = 0) |> Printliste // gleiche Sache mit einem Listenausdruck [ zum i in 1..10 tun  Lassen r = Flunkerei i  wenn r % 2 = 0 dann Ertrag r ] |> Printliste 

Ein Beispiel -Windows -Formulierprogramm:

// Öffnen Sie die Windows Forms -Bibliothek offen System.Windows.forms // Erstellen Sie ein Fenster und setzen Sie einige Eigenschaften ein Lassen bilden = Neu Bilden(Sichtbar=Stimmt, Oberste=Stimmt, Text="Willkommen bei F#") // Erstellen Sie ein Etikett, um einen Text im Formular anzuzeigen Lassen Etikett =  Lassen x = 3 + (4 * 5)  Neu Etikett(Text = $"{x}") // Fügen Sie das Etikett zum Formular hinzu bilden.Kontrollen.Hinzufügen(Etikett) // Führen Sie schließlich das Formular aus [<<System.Stathread>]] Anwendung.Laufen(bilden) 

Asynchrone parallele Programmierprobe (parallele CPU- und E/A -Aufgaben):

/// Ein einfacher Primzahl -Detektor Lassen isprime (n:int) =  Lassen gebunden = int (sqrt (schweben n))  seq {2 .. gebunden} |> Seq.für alle (Spaß x -> n % x <> 0) // Wir verwenden asynchrische Workflows Lassen Primeasync n =  Async { Rückkehr (n, isprime n) } /// Primzahlen zwischen m und n mit mehreren Threads zurückgeben Lassen Primzahlen m n =  seq {m .. n}  |> Seq.Karte Primeasync  |> Async.Parallel  |> Async.Runsynchron  |> Array.Filter snd  |> Array.Karte fst // einen Test ausführen Primzahlen 1000000 1002000  |> Array.Iter (printfn "%d") 

Siehe auch

• Ocaml
• C#
• .NET Framework

Anmerkungen

Verweise

• Syme, Don; Granicz, Adam; Zisternino, Antonio (2007), Experte F#, Apress
• Harrop, Jon (2010), Visual F# 2010 für technisches Computing, Fliegende Froschberatung
• Pickering, Robert (2007), Grundlagen von F#, Apress
• Smith, Chris (2009), Programmierung f#, O'Reilly
• Petricek, Tomas (2009), Funktionelle Programmierung realer Welt mit Beispielen in F# und C#, Manning Publications
• Hansen, Michael; Rischel, Hans (2013), Funktionelle Programmierung mit F#, Cambridge University Press
• Astborg, Johan (2013), F# für quantitative Finanzen, Packt Publishing
• Lundin, Mikael (2015), Testen mit F#, Packt Publishing

Externe Links

• Offizielle Website Die F# Software Foundation
• Die F# Open Source -Gruppe bei GitHub
• Das visuelle F# -Entuchszentrum Archiviert 2008-11-19 bei der Wayback -Maschine
• Tsunami, ein eingebettbarer Desktop f# ide
• Cloud Tsunami, ein eingebettbares Silberlight f# ide
• Versuchen Sie es mit F#, um F# in einem Webbrowser zu lernen
• F# Snippets Site
• Das visuelle F# -Teamblog
• Die ursprüngliche Microsoft Research -Website für F#
• Planet F#
• Der F# Survival Guide, Dezember 2009 (webbasiertes Buch)
• Die F# Sprachspezifikation
• Eine Einführung in die F# -Programmierung Archiviert 2011-07-13 bei der Wayback -Maschine
• Ein Tutorial, das die zeigt Prozess ein funktionales Design zu erreichen; Beinhaltet Test- und Parallelcodierung