Was ist F?#

F# ist eine universelle Programmiersprache zum Schreiben prägnanter, robuster und performanter Code.

Mit F# können Sie übersichtlichen, selbst dokumentierenden Code schreiben, bei dem der Fokus auf Ihrer Problemdomäne und nicht auf die Details der Programmierung liegt.

Dies geschieht, ohne die Geschwindigkeit und Kompatibilität zu beeinträchtigen - es ist Open-Source, plattformübergreifend und interoperable.

open System // Gets access to functionality in System namespace.

// Defines a list of names
let names = [ "Peter"; "Julia"; "Xi" ]

// Defines a function that takes a name and produces a greeting.
let getGreeting name = $"Hello, {name}"

// Prints a greeting for each name!
names
|> List.map getGreeting
|> List.iter (fun greeting -> printfn $"{greeting}! Enjoy your F#")

F# verfügt über zahlreiche Features, darunter:

• Einfache Syntax
• Standardmäßig unveränderlich
• Typinferenz und automatische Generalisierung
• Erstklassige Funktionen
• Leistungsstarke Datentypen
• Musterabgleich
• Asynchrone Programmierung

Eine vollständige Gruppe von Features wird im F#-Sprachhandbuch dokumentiert.

Umfangreiche Datentypen

Typen wie Datensätze und Diskriminierte Vereinigungen ermöglichen Es Ihnen, Ihre Daten darzustellen.

// Group data with Records
type SuccessfulWithdrawal =
    { Amount: decimal
      Balance: decimal }

type FailedWithdrawal =
    { Amount: decimal
      Balance: decimal
      IsOverdraft: bool }

// Use discriminated unions to represent data of 1 or more forms
type WithdrawalResult =
    | Success of SuccessfulWithdrawal
    | InsufficientFunds of FailedWithdrawal
    | CardExpired of System.DateTime
    | UndisclosedFailure

F#-Datensätze und diskriminierte Vereinigungen sind standardmäßig nicht null, unveränderlich und vergleichbar, wodurch sie sehr einfach zu verwenden sind.

Korrektheit bei Funktionen und Musterabgleich

F#-Funktionen sind einfach zu definieren. In Kombination mit dem Musterabgleich können Sie das Verhalten definieren, dessen Korrektheit vom Compiler erzwungen wird.

// Returns a WithdrawalResult
let withdrawMoney amount = // Implementation elided

let handleWithdrawal amount =
    let w = withdrawMoney amount

    // The F# compiler enforces accounting for each case!
    match w with
    | Success s -> printfn $"Successfully withdrew %f{s.Amount}"
    | InsufficientFunds f -> printfn $"Failed: balance is %f{f.Balance}"
    | CardExpired d -> printfn $"Failed: card expired on {d}"
    | UndisclosedFailure -> printfn "Failed: unknown :("

F#-Funktionen sind auch erstklassige Funktionen, was bedeutet, dass sie als Parameter übergeben und von anderen Funktionen zurückgegeben werden können.

Funktionen zum Definieren von Vorgängen für Objekte

F# verfügt über vollständige Unterstützung für Objekte, die nützlich sind, wenn Sie Daten und Funktionen mischen müssen. F#-Elemente und -Funktionen können zum Bearbeiten von Objekten definiert werden.

type Set<'T when 'T: comparison>(elements: seq<'T>) =
    member s.IsEmpty = // Implementation elided
    member s.Contains (value) =// Implementation elided
    member s.Add (value) = // Implementation elided
    // ...
    // Further Implementation elided
    // ...
    interface IEnumerable<'T>
    interface IReadOnlyCollection<'T>

module Set =
    let isEmpty (set: Set<'T>) = set.IsEmpty

    let contains element (set: Set<'T>) = set.Contains(element)

    let add value (set: Set<'T>) = set.Add(value)

In F# schreiben Sie häufig Code, der Objekte als Typ behandelt, um Funktionen zu bearbeiten. Features wie generische Schnittstellen, Objektausdrücke und vernünftige Verwendung von Membern sind in größeren F#-Programmen üblich.

Nächste Schritte

Weitere Informationen zu einer größeren Gruppe von F#-Features finden Sie in der F#-Tour.