Qu’est-ce que F# ?

F# est un langage de programmation universel conçu pour vous aider à écrire du code succinct, robuste et performant.

F# vous permet de créer du code épuré et autodocumenté en focalisant votre attention sur le domaine du problème plutôt que sur les détails de la programmation.

En aucun cas la vitesse et la compatibilité ne sont sacrifiées : 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# comprend de nombreuses fonctionnalités, parmi lesquelles :

• 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 du langage F#.

Types de données riches

Des types tels que les enregistrements et les unions discriminées 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 et les unions discriminées F# sont non Null, immuables et comparables par défaut, ce qui les rend très faciles à utiliser.

Exactitude avec les fonctions et les critères spéciaux

Les fonctions F# sont faciles à définir. En les combinant avec des critères spéciaux, vous pouvez définir un comportement dont l’exactitude 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, ce qui est utile quand vous devez mélanger des données et des fonctionnalités. Vous pouvez définir des membres et des fonctions F# 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 écrivez souvent du code qui traite les objets en tant que type que des fonctions peuvent manipuler. Des fonctionnalités telles que les interfaces génériques, les expressions d’objet et l’utilisation judicieuse des membres sont courantes dans les programmes F# plus importants.

Étapes suivantes

Pour découvrir un ensemble plus large de fonctionnalités F#, consultez la présentation de F#.