Qué es F#What is F#

F#es un lenguaje de programación funcional que facilita la escritura de código correcto y fácil de mantener.F# is a functional programming language that makes it easy to write correct and maintainable code.

F#la programación implica principalmente definir tipos y funciones que se infieren de tipo y se generalizan automáticamente.F# programming primarily involves defining types and functions that are type-inferred and generalized automatically. Esto permite que el foco permanezca en el dominio del problema y manipule sus datos, en lugar de los detalles de la programación.This allows your focus to remain on the problem domain and manipulating its data, rather than the details of programming.

open System // Gets access to functionality in System namespace.

// Defines a function that takes a name and produces a greeting.
let getGreeting name =
    sprintf "Hello, %s! Isn't F# great?" name

[<EntryPoint>]
let main args =
    // Defines a list of names
    let names = [ "Don"; "Julia"; "Xi" ]

    // Prints a greeting for each name!
    names
    |> List.map getGreeting
    |> List.iter (fun greeting -> printfn "%s" greeting)

    0

F#tiene numerosas características, entre las que se incluyen:F# has numerous features, including:

  • Sintaxis ligeraLightweight syntax
  • Inmutable de forma predeterminadaImmutable by default
  • Inferencia de tipos y generalización automáticaType inference and automatic generalization
  • Funciones de primera claseFirst-class functions
  • Tipos de datos eficacesPowerful data types
  • Detección de patronesPattern matching
  • Programación asincrónicaAsync programming

En la F# referencia del lenguajese documenta un conjunto completo de características.A full set of features are documented in the F# language reference.

Tipos de datos enriquecidosRich data types

Los tipos de datos como registros y uniones discriminadas permiten representar dominios y datos complejos.Data types such as Records and Discriminated Unions let you represent complex data and domains.

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

F#los registros y las uniones discriminadas son no NULL, inmutables y comparables de forma predeterminada, lo que facilita su uso.F# records and discriminated unions are non-null, immutable, and comparable by default, making them very easy to use.

Aplicación de corrección con funciones y coincidencia de patronesEnforced correctness with functions and pattern matching

F#las funciones son fáciles de declarar y eficaces en la práctica.F# functions are easy to declare and powerful in practice. Cuando se combina con la coincidencia de patrones, permiten definir el comportamiento cuya corrección se aplica mediante el compilador.When combined with pattern matching, they allow you to define behavior whose correctness is enforced by the compiler.

// 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 %O" d
    | UndisclosedFailure -> printfn "Failed: unknown :("

F#las funciones son también de primera clase, lo que significa que se pueden pasar como parámetros y devolverse desde otras funciones.F# functions are also first-class, meaning they can be passed as parameters and returned from other functions.

Funciones para definir operaciones en objetosFunctions to define operations on objects

F#tiene compatibilidad total con objetos, que son tipos de datos útiles cuando es necesario combinar datos y funcionalidad.F# has full support for objects, which are useful data types when you need to blend data and functionality. F#las funciones se usan para manipular objetos.F# functions are used to manipulate objects.

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 lugar de escribir código orientado a objetos, en F#, a menudo escribirá código que trata los objetos como otro tipo de datos para las funciones que se van a manipular.Rather than writing code that is object-oriented, in F#, you will often write code that treats objects as another data type for functions to manipulate. Las características como las interfaces genéricas, las expresiones de objetoy el uso prudente de los miembros son comunes en los programas más grandes. F#Features such as generic interfaces, object expressions, and judicious use of members are common in larger F# programs.

Pasos siguientesNext steps

Para obtener más información acerca de un conjunto F# mayor de características, consulte el F# paseo.To learn more about a larger set of F# features, check out the F# Tour.