Vad är F#

F# är ett universellt programmeringsspråk för att skriva kortfattad, robust och högpresterande kod.

Med F# kan du skriva rensad, självdokumenterande kod, där ditt fokus ligger kvar på din problemdomän, i stället för information om programmering.

Det gör detta utan att kompromissa med hastighet och kompatibilitet - det är öppen källkod, plattformsoberoende och driftskompatibelt.

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# har flera funktioner, bland annat:

• Lättviktssyntax
• Oföränderlig som standard
• Typinferens och automatisk generalisering
• Förstklassiga funktioner
• Kraftfulla datatyper
• Mönsterjämförelse
• Asynkron programmering

En fullständig uppsättning funktioner dokumenteras i F#-språkguiden.

Omfattande datatyper

Med typer som arkivhandlingar och diskriminerade fackföreningar kan du representera dina data.

// 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#-register och diskriminerade unioner är icke-nullbara, oföränderliga och jämförbara av standard, vilket gör dem mycket enkla att använda.

Korrekthet med funktioner och mönstermatchning

F#-funktioner är enkla att definiera. När de kombineras med mönstermatchning kan du definiera beteende vars korrekthet framtvingas av kompilatorn.

// 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#-funktioner är också förstklassiga, vilket innebär att de kan skickas som parametrar och returneras från andra funktioner.

Funktioner för att definiera åtgärder för objekt

F# har fullt stöd för objekt, vilket är användbart när du behöver blanda data och funktioner. F#-medlemmar och funktioner kan definieras för att ändra objekt.

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)

I F# skriver du ofta kod som behandlar objekt som en typ för funktioner som ska manipuleras. Funktioner som allmänna gränssnitt, objektuttryck och omdömesgill användning av medlemmar är vanliga i större F#-program.

Nästa steg

Mer information om en större uppsättning F#-funktioner finns i F#-rundturen.