Was ist F?#

F# ist eine plattformübergreifende, interoperable Open-Source-Programmiersprache zum Schreiben von prägnanter, stabiler und widerstandsfähiger Code. Ihr Fokus liegt weiterhin auf Ihrer Problemdomäne und nicht auf den Details der Programmierung.

Die F#-Programmierung ist datenorientiert, wobei Code das Transformieren von Daten mit Funktionen umfasst.

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
  • Typrückschluss und automatische Generalisierung
  • Funktionen erster Klasse
  • Leistungsstarke Datentypen
  • Musterabgleich
  • Asynchrone Programmierung

Eine vollständige Reihe von Features ist im F#-Sprachleitfaden dokumentiert.

Umfangreiche Datentypen

Mit Typen wie Datensätzen und Unterscheidungs-Unions können Sie Ihre Daten darstellen.

// 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 Unterscheidungs-Unions sind nicht NULL, unveränderlich und standardmäßig vergleichbar, wodurch sie sehr einfach zu verwenden sind.

Richtigkeit mit Funktionen und Musterabgleich

F#-Funktionen sind einfach zu definieren. In Kombination mit Mustervergleichenkönnen Sie das Verhalten definieren, dessen Richtigkeit 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 ebenfalls 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# bietet vollständige Unterstützung für Objekte, die nützlich sind, wenn Sie Daten und Funktionen mischen müssen. F#-Member und -Funktionen können definiert werden, um Objekte zu bearbeiten.

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 für zu bearbeitende Funktionen behandelt. Features wie generische Schnittstellen, Objektausdrückeund die orientierte Verwendung von Membern sind in größeren F#-Programmen üblich.

Nächste Schritte

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