Wat is F?#

F# is een universele programmeertaal voor het schrijven van beknopte, robuuste en performante code.

Met F# kunt u overzichtelijke, zelfdocumenterende code schrijven, waarbij uw focus op uw probleemdomein blijft, in plaats van de details van programmeren.

Het doet dit zonder afbreuk te doen aan snelheid en compatibiliteit: het is opensource, platformoverschrijdend en 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# heeft talloze functies, waaronder:

• Lichtgewicht syntaxis
• Onveranderbaar standaard
• Type deductie en automatische generalisatie
• Eersteklas functies
• Krachtige gegevenstypen
• Patroonherkenning
• Asynchroon programmeren

Een volledige set functies wordt beschreven in de F#-taalhandleiding.

Uitgebreide gegevenstypen

Met typen zoals Records en Gediscrimineerde unions kunt u uw gegevens vertegenwoordigen .

// 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#-records en gediscrimineerde samenvoegingen zijn niet-null, onveranderbaar en vergelijkbaar, waardoor ze zeer eenvoudig te gebruiken zijn.

Juistheid met functies en patroonkoppeling

F#-functies zijn eenvoudig te definiëren. In combinatie met patroonkoppeling kunt u gedrag definiëren waarvan de juistheid wordt afgedwongen door de compiler.

// 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#-functies zijn ook eersteklas, wat betekent dat ze kunnen worden doorgegeven als parameters en worden geretourneerd vanuit andere functies.

Functies voor het definiëren van bewerkingen op objecten

F# biedt volledige ondersteuning voor objecten, wat handig is wanneer u gegevens en functionaliteit moet combineren. F#-leden en -functies kunnen worden gedefinieerd om objecten te bewerken.

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# schrijft u vaak code waarmee objecten worden behandeld als een type voor functies om te bewerken. Functies zoals algemene interfaces, objectexpressies en het gebruik van leden zijn gebruikelijk in grotere F#-programma's.

Volgende stappen

Bekijk de F#-rondleiding voor meer informatie over een grotere set F#-functies.