Was ist F#?

F# ist eine universelle Programmiersprache zum Schreiben von prägnantem, stabilem und leistungsfähigen Code.

Mit F# können Sie übersichtlichen, selbstdokumentierenden Code schreiben, sodass Sie sich auf die Problemstellung konzentrieren können, ohne auf die Details der Programmierung achten zu müssen.

Dies geschieht ohne Kompromisse bei Geschwindigkeit und Kompatibilität, F# ist Open-Source, plattformübergreifend und interoperabel.

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
• Leistungsfähige Datentypen
• Musterabgleich
• Asynchrone Programmierung

Ein umfassende Dokumentation der Features finden Sie im F#-Sprachhandbuch.

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

Korrektheit bei Funktionen und Musterabgleich

F#-Funktionen lassen sich einfach 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 ebenfalls erstklassig, d. h., sie können als Parameter übergeben und von anderen Funktionen zurückgegeben werden.

Funktionen zum Definieren von Operationen für Objekte

F# bietet umfassende Unterstützung für Objekte, die nützlich sind, wenn Sie Daten und Funktionalität 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ücke und eine kluge Verwendung von Membern sind in umfangreicheren F#-Programmen üblich.

Nächste Schritte

Weitere Informationen über mehr F#-Features finden Sie in der Einführung in F#.