F#-Sprache – Hinweise für Neulinge [geschlossen]

Question

Sieht so aus, als gäbe es hier in StackOveflow eine Gruppe von F# Enthusiasten.

Ich würde diese Sprache gerne besser kennen, abgesehen von der Theorie der funktionalen Programmierung, können Sie mir die besseren Ausgangspunkte für den Einstieg in die F#-Sprache nennen?Ich meine, Tutorials, Anleitungen, aber vor allem Arbeitsproben, um die Chance zu haben, etwas zu tun und Spaß an der Sprache zu haben.

Vielen Dank

Andrea

Answer 1

Ich wollte mich nicht schrecklich ärgern, aber ich habe in meinem Blog ein paar F#-Übersichtsbeiträge geschrieben Hier Und Hier.Chris Smith (Mitarbeiter im F#-Team bei MS) hat einen Artikel mit dem Titel „F# in 20 Minuten“ – Teil 1 Und Teil 2.

Beachten Sie, dass Sie vorsichtig sein müssen, da das neueste CTP von F# (Version 1.9.6.0) im Vergleich zu früheren Versionen einige schwerwiegende Änderungen aufweist, sodass einige Beispiele/Tutorials ohne Änderungen möglicherweise nicht funktionieren.

Hier ist ein kurzer Überblick über ein paar coole Sachen. Vielleicht kann ich Ihnen hier selbst ein paar klare Hinweise geben sehr Kurz und wahrscheinlich nicht großartig, aber hoffentlich gibt es Ihnen etwas zum Spielen!:-

Erster Hinweis: Bei den meisten Beispielen im Internet wird davon ausgegangen, dass die „leichte Syntax“ aktiviert ist.Um dies zu erreichen, verwenden Sie die folgende Codezeile:-

#light

Dadurch wird vermieden, dass Sie bestimmte Schlüsselwörter einfügen müssen, die aus Gründen der OCaml-Kompatibilität vorhanden sind, und auch jede Zeile mit Semikolons abschließen müssen.Beachten Sie, dass die Verwendung dieser Syntax bedeutet, dass die Einrückung den Bereich definiert.Dies wird in späteren Beispielen deutlich, die alle auf der Aktivierung der Lightweight-Syntax basieren.

Wenn Sie den interaktiven Modus verwenden, müssen Sie alle Anweisungen mit doppelten Semikolons abschließen, zum Beispiel:-

  > #light;;
  > let f x y = x + y;;

  val f : int -> int -> int

  > f 1 2;;
  val it : int = 3

Beachten Sie, dass der interaktive Modus nach jeder Zeile ein „val“-Ergebnis zurückgibt.Dies liefert wichtige Informationen über die Definitionen, die wir erstellen, zum Beispiel „val f :int -> int -> int' gibt an, dass eine Funktion, die zwei Ganzzahlen benötigt, eine Ganzzahl zurückgibt.

Beachten Sie, dass wir Zeilen nur im interaktiven Modus mit Semikolons abschließen müssen. Bei der tatsächlichen Definition von F#-Code ist dies nicht erforderlich :-)

Sie definieren Funktionen mit dem Schlüsselwort „let“.Dies ist wahrscheinlich das wichtigste Schlüsselwort in F# und Sie werden es häufig verwenden.Zum Beispiel:-

let sumStuff x y = x + y
let sumStuffTuple (x, y) = x + y

Wir können diese Funktionen folgendermaßen aufrufen:

sumStuff 1 2
3
sumStuffTuple (1, 2)
3

Beachten Sie, dass es hier zwei verschiedene Möglichkeiten gibt, Funktionen zu definieren: Sie können Parameter entweder durch Leerzeichen trennen oder Parameter in „Tupeln“ angeben (d. h.Werte in Klammern durch Kommas getrennt).Der Unterschied besteht darin, dass wir mit dem ersten Ansatz eine „partielle Funktionsanwendung“ verwenden können, um Funktionen zu erhalten, die weniger als die erforderlichen Parameter benötigen, und nicht mit dem zweiten.Z.B.:-

let sumStuff1 = sumStuff 1
sumStuff 2
3

Beachten Sie, dass wir eine Funktion aus dem Ausdruck „sumStuff 1“ erhalten.Wenn wir Funktionen genauso einfach weitergeben können wie Daten, die als Sprache mit „erstklassigen Funktionen“ bezeichnet werden, ist dies ein grundlegender Bestandteil jeder funktionalen Sprache wie F#.

Mustervergleich ist verdammt cool, es ist im Grunde wie eine Switch-Anweisung auf Steroiden (ja, ich habe diesen Satz von einem anderen F#-Satz geklaut :-).Sie können Dinge tun wie:-

let someThing x =
  match x with
    | 0 -> "zero"
    | 1 -> "one"
    | 2 -> "two"
    | x when x < 0 -> "negative = " + x.ToString()
    | _ when x%2 = 0 -> "greater than two but even"
    | _ -> "greater than two but odd"

Beachten Sie, dass wir das Symbol „_“ verwenden, wenn wir etwas abgleichen möchten, der zurückgegebene Ausdruck jedoch nicht von der Eingabe abhängt.

Wir können den Mustervergleich nach Bedarf mit if-, elif- und else-Anweisungen abkürzen:

let negEvenOdd x = if x < 0 then "neg" elif x % 2 = 0 then "even" else "odd"

F#-Listen (die darunter als verknüpfte Listen implementiert sind) können folgendermaßen manipuliert werden:

let l1 = [1;2;3]
l1.[0]
1

let l2 = [1 .. 10]
List.length l2
10

let squares = [for i in 1..10 -> i * i]
squares
[1; 4; 9; 16; 25; 36; 49; 64; 81; 100]

let square x = x * x;;
let squares2 = List.map square [1..10]
squares2
[1; 4; 9; 16; 25; 36; 49; 64; 81; 100]

let evenSquares = List.filter (fun x -> x % 2 = 0) squares
evenSqares
[4; 16; 36; 64; 100]

Beachten Sie, dass die List.map-Funktion die Quadratfunktion auf die Liste von 1 bis 10 „abbildet“, d. h.wendet die Funktion auf jedes Element an.List.filter „filtert“ eine Liste, indem es nur Werte in der Liste zurückgibt, die die bereitgestellte Prädikatfunktion bestehen.Beachten Sie auch die Syntax „fun x -> f“ – dies ist das F#-Lambda.

Beachten Sie, dass wir durchgehend keine Typen definiert haben – der F#-Compiler/Interpreter „schließt“ Typen ab, d. h.Ermittelt, was Sie von der Nutzung erwarten.Zum Beispiel:-

let f x = "hi " + x

Hier bestimmt der Compiler/Interpreter, dass x ein String ist, da Sie eine Operation ausführen, die erfordert, dass x ein String ist.Es bestimmt auch, dass der Rückgabetyp ebenfalls ein String sein wird.

Bei Unklarheiten trifft der Compiler Annahmen, zum Beispiel:

let f x y = x + y

Hier können x und y verschiedene Typen haben, der Compiler verwendet jedoch standardmäßig int.Wenn Sie Typen definieren möchten, können Sie Typanmerkungen verwenden:

let f (x:string) y = x + y

Beachten Sie auch, dass wir x:string in Klammern setzen mussten. Dies ist häufig erforderlich, um Teile einer Funktionsdefinition zu trennen.

Zwei wirklich nützliche und häufig verwendete Operatoren in F# sind die Pipe-Forward- und Funktionskompositionsoperatoren |> bzw. >>.

Wir definieren |> folgendermaßen:-

let (|>) x f = f x

Beachten Sie, dass Sie Operatoren in F# definieren können, das ist ziemlich cool :-).

Dies ermöglicht es Ihnen, Dinge klarer zu schreiben, z. B.:-

[1..10] |> List.map (fun x -> x * x) |> List.filter (fun x -> x % 2 = 0)

Ermöglicht Ihnen, die ersten 10 geraden Quadrate zu erhalten.Das ist klarer als:-

List.filter (fun x -> x % 2 = 0) (List.map (fun x -> x * x) [1..10])

Na ja, zumindest denke ich das :-)

Die durch den >>-Operator definierte Funktionszusammensetzung ist wie folgt definiert:-

let (>>) f g x = g(f(x))

D.h.Wenn Sie eine Operation weiterleiten, bleibt nur der Parameter der ersten Funktion unspezifiziert.Dies ist nützlich, da Sie Folgendes tun können:

let mapFilter = List.map (fun x -> x * x) >> List.filter (fun x -> x % 2 = 0)

Hier akzeptiert MapFilter eine Liste als Eingabe und gibt die wie zuvor gefilterte Liste zurück.Es ist eine gekürzte Version von:-

let mapFilter = l |> List.map (fun x -> x * x) |> List.filter (fun x -> x % 2 = 0)

Wenn wir rekursive Funktionen schreiben wollen, müssen wir die Funktion als rekursiv definieren, indem wir „rec“ nach dem let einfügen.Beispiele unten.

Ein paar coole Sachen:-

Fakultät

let rec fact x = if x <= 1 then 1 else x * fact (x-1)

n-te Fibonacci-Zahl

let rec fib n = if n <= 1 then n else fib (n-1) + fib (n-2)

FizzBuzz

let (/%) x y = x % y = 0
let fb = function
  | x when x /% 15 -> "FizzBuzz"
  | x when x /% 3  -> "Fizz"
  | x when x /% 5  -> "Buzz"
  | x              -> x.ToString()

[1..100] |> List.map (fb >> printfn "%s")

Wie auch immer, das ist ein sehr Kurzer Überblick, hoffentlich hilft es ein wenig!!

Answer 2

Ohne Zweifel sollten Sie Don Symes ausgezeichnetes Buch „Expert F#“ kaufen.Das Buch ist sehr gut geschrieben und sowohl für Anfänger als auch für Experten geeignet.Darin finden Sie sowohl Einführungsmaterial als auch viel anspruchsvolleres Material.Mit fast 600 Seiten bietet es ein gutes Preis-Leistungs-Verhältnis.

Ich stellte fest, dass es mir viele nützliche Techniken zum Schreiben funktionalerer C# beibrachte und mir das gesamte Referenzmaterial lieferte, das ich brauchte, um mit dem Schreiben von Windows-gehosteten F#-Anwendungen zu beginnen.

Das Buch wird von Apress veröffentlicht und verfügt über eine begleitende Website unter:http://www.expert-fsharp.com/default.aspx

Answer 3

@kronoz – vielen Dank für deine lange Antwort, das ist ein wirklich guter Ausgangspunkt.Ich werde Ihren Ratschlägen folgen und nach dem von @vecstasy erwähnten Buch suchen.

Jetzt lass mich mit dem Codieren beginnen :-)

let thanksalot = "thanks a lot"
printfn "%s" (thanksalot);;

Answer 4

Ich habe gelesen Funktionale Programmierung in der realen Welt

Mit Beispielen in F# und C# von:Tomas Petricek

Bisher finde ich es sehr gut, F#-Konzepte zu vermitteln, indem man nebenbei die Implementierungen in C# zeigt.Ideal für OO-Programmierer.

Answer 5

Besuche die F#-Entwicklercenter.Es gibt auch hubFS, ein Forum speziell für F#.

Answer 6

Wenn Sie über die aktuelle CTP-Version in Visual Studio verfügen, können Sie damit ein F#-Tutorial-Projekt erstellen, das Ihnen eine Tutorial.fs liefert, die genau das enthält, was der Name vermuten lässt.

Dieses Tutorial weist auch auf eine größere Sammlung von hin F#-Beispiele bei Microsoft.

Außerdem läuft derzeit ein F#-Beispielprojekt unter CodePlex.

Hoffe das hilft,

Michiel

Answer 7

Das erste Kapitel meines Buches F# for Scientists ist frei verfügbar Hier.Wir haben eine Reihe kostenloser F#-Spielzeugprogramme Hier.Der erste Artikel aus unserem F#.NET Journal ist frei verfügbar Hier.