¿Qué es F?#

  • Artículo
  • 2 minutos para leer

F# es un lenguaje de programación interoperable, multiplataforma y de código abierto para escribir código concisa, sólido y de gran rendimiento. El foco se mantiene en el dominio del problema, en lugar de en los detalles de la programación.

La programación de F# está orientada a datos, donde el código implica la transformación de datos con funciones.

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, entre las que se incluyen:

  • 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

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

Tipos de datos enriquecidos

Tipos como registros y uniones discriminadas 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 de F# y las uniones discriminadas son no NULL, inmutables y comparables de forma predeterminada, lo que hace que sean muy fáciles de usar.

Corrección con funciones y coincidencia de patrones

Las funciones de F# son fáciles de definir. Cuando se combinan con la coincidencia depatrones, permiten definir el comportamiento cuya corrección exige el compilador.

// 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 son útiles cuando se necesita combinar datos y funcionalidad. 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 trata los objetos como un tipo para que las funciones las manipulen. Características como las interfaces genéricas,las expresiones de objetoy el uso inteligente de miembros son comunes en programas de F# más grandes.

Pasos siguientes

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