Cos'è F#

F# è un linguaggio di programmazione universale per la scrittura di codice conciso, affidabile e efficiente.

F# consente di scrivere codice indipendente e autodocumentato, in cui l'attenzione rimane sul dominio del problema, anziché sui dettagli della programmazione.

Questa operazione viene eseguita senza compromettere la velocità e la compatibilità: è open source, multipiattaforma e interoperabile.

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# offre numerose funzionalità, tra cui:

• La sintassi leggera
• Non modificabile per impostazione predefinita
• Inferenza dei tipi e generalizzazione automatica
• Funzioni di prima classe
• Tipi di dati avanzati
• Corrispondenza dei criteri
• Programmazione asincrona

Un set completo di funzionalità è documentato nella guida al linguaggio F#.

Tipi di dati avanzati

I tipi, ad esempio record e unioni discriminate , consentono di rappresentare i dati.

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

I record F# e le unioni discriminate non sono null, non modificabili e confrontabili per impostazione predefinita, semplificandone l'uso.

Correttezza con funzioni e criteri di ricerca

Le funzioni F# sono facili da definire. In combinazione con i criteri di ricerca, consentono di definire il comportamento di cui viene applicata la correttezza dal compilatore.

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

Le funzioni F# sono anche di prima classe, ovvero possono essere passate come parametri e restituite da altre funzioni.

Funzioni per definire operazioni su oggetti

F# offre il supporto completo per gli oggetti, utili quando è necessario combinare dati e funzionalità. I membri e le funzioni F# possono essere definiti per modificare gli oggetti.

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#, spesso si scrive codice che considera gli oggetti come tipo per le funzioni da modificare. Le funzionalità, ad esempio interfacce generiche, espressioni di oggetto e uso succoso dei membri , sono comuni nei programmi F# più grandi.

Passaggi successivi

Per altre informazioni su un set più ampio di funzionalità di F#, vedere il tour di F#.