¿Qué es F#?

F# es un lenguaje de programación universal para escribir código conciso, sólido y eficaz.

F# le permite escribir código ordenado y autoexplicativo cuyo foco permanece centrado en el dominio del problema, en lugar de en los detalles de programación.

La velocidad y la compatibilidad no se ven afectadas, ya que es de código abierto, multiplataforma e interoperable.

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# tiene numerosas características, incluidas las siguientes:

• Sintaxis simplificada
• Inmutable de forma predeterminada
• Inferencia de tipos y generalización automática
• Funciones de primera clase
• Tipos de datos eficaces
• Detección de patrones
• Programación asincrónica

En la guía del lenguaje F# se documenta un conjunto completo de características.

Tipos de datos enriquecidos

Los tipos como registros y uniones discriminadas le permiten representar los datos.

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

Los registros y las uniones discriminadas de F# son distintos de NULL, inmutables y comparables de forma predeterminada, lo que hace que sean muy fáciles de usar.

Exactitud mediante funciones y coincidencia de patrones

Las funciones de F# son fáciles de definir. Cuando se combinan con la coincidencia de patrones, permiten definir el comportamiento que el compilador aplica con exactitud.

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

Las funciones de F# también son de primera clase, lo que significa que se pueden pasar como parámetros y devolverse desde otras funciones.

Funciones para definir operaciones en objetos

F# tiene compatibilidad completa con objetos, que resultan útiles cuando se necesita combinar datos y funcionalidades. Los miembros y funciones de F# se pueden definir para manipular objetos.

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#, a menudo escribirá código que trate los objetos como un tipo para que las funciones los manipulen. Las características como las interfaces genéricas, las expresiones de objeto y el uso razonable de los miembros son comunes en programas de F# más grandes.

Pasos siguientes

Para obtener más información sobre un conjunto mayor de características de F#, consulte el Paseo por F#.