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#")
// 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.
Met ons samenwerken op GitHub
De bron voor deze inhoud vindt u op GitHub, waar u ook problemen en pull-aanvragen kunt maken en controleren. Bekijk onze gids voor inzenders voor meer informatie.
.NET-feedback
.NET is een open source project. Selecteer een koppeling om feedback te geven:
F# is een opensource-programmeertaal voor meerdere platforms waarmee u eenvoudig beknopte, krachtige, robuuste en praktische code kunt schrijven. Het is een algemene taal waarmee u veel verschillende soorten toepassingen kunt maken, zoals Web-API, Desktop, IoT, Gaming en meer.