Qu’est-ce que F#

F# est un langage de programmation universel pour écrire du code succinct, robuste et performant.

F# vous permet d’écrire du code non documenté, auto-documentant, où votre focus reste sur votre domaine de problème, plutôt que sur les détails de la programmation.

Il le fait sans compromettre la vitesse et la compatibilité - il est open source, multiplateforme et interopérable.

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# a de nombreuses fonctionnalités, notamment :

• Syntaxe simplifiée
• Immuable par défaut
• Inférence de type et généralisation automatique
• Fonctions de première classe
• Types de données puissants
• Critères spéciaux
• Programmation asynchrone

Un ensemble complet de fonctionnalités est documenté dans le guide de langue F#.

Types de données enrichis

Les types tels que les enregistrements et les unions discriminatoires vous permettent de représenter vos données.

// 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

Les enregistrements F# et les unions discriminées ne sont pas null, immuables et comparables par défaut, ce qui les rend très faciles à utiliser.

Exactitude avec des fonctions et des critères correspondants

Les fonctions F# sont faciles à définir. Lorsqu’elles sont combinées avec des critères correspondants, elles vous permettent de définir le comportement dont la correction est appliquée par le compilateur.

// 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 :("

Les fonctions F# sont également de première classe, ce qui signifie qu’elles peuvent être passées en tant que paramètres et retournées par d’autres fonctions.

Fonctions permettant de définir des opérations sur des objets

F# prend entièrement en charge les objets, qui sont utiles lorsque vous devez fusionner des données et des fonctionnalités. Les membres et fonctions F# peuvent être définis pour manipuler des objets.

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)

En F#, vous allez souvent écrire du code qui traite les objets comme un type pour les fonctions à manipuler. Les fonctionnalités telles que les interfaces génériques, les expressions d’objet et l’utilisation judicieuse de membres sont courantes dans les programmes F# plus volumineux.

Étapes suivantes

Pour en savoir plus sur un plus grand ensemble de fonctionnalités F#, consultez la visite guidée F#.