O que é F#What is F#

O F # é uma linguagem de programação funcional que torna mais fácil escrever código correto e passível de manutenção.F# is a functional programming language that makes it easy to write correct and maintainable code.

A programação F # envolve principalmente a definição de tipos e funções que são de tipo inferido e generalizados automaticamente.F# programming primarily involves defining types and functions that are type-inferred and generalized automatically. Isso permite que seu foco permaneça no domínio problemático e manipule seus dados, em vez dos detalhes da programação.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 = $"Hello, {name}! Isn't F# great?"

[<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 $"{greeting}")

    0

O F # tem vários recursos, incluindo:F# has numerous features, including:

  • Sintaxe leveLightweight syntax
  • Imutável por padrãoImmutable by default
  • Inferência de tipos e generalização automáticaType inference and automatic generalization
  • Funções de primeira classeFirst-class functions
  • Tipos de dados avançadosPowerful data types
  • Correspondência de padrõesPattern matching
  • Programação assíncronaAsync programming

Um conjunto completo de recursos está documentado na referência de linguagem F #.A full set of features are documented in the F# language reference.

Tipos de dados avançadosRich data types

Tipos de dados como registros e uniões discriminadas permitem que você represente domínios e dados complexos.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

Os registros F # e as uniões discriminadas são não nulos, imutáveis e comparáveis por padrão, tornando-os muito fáceis de usar.F# records and discriminated unions are non-null, immutable, and comparable by default, making them very easy to use.

Correção imposta com funções e correspondência de padrõesEnforced correctness with functions and pattern matching

As funções de F # são fáceis de declarar e poderosas na prática.F# functions are easy to declare and powerful in practice. Quando combinado com correspondência de padrões, eles permitem que você defina o comportamento cuja exatidão é imposta pelo 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 {d}"
    | UndisclosedFailure -> printfn "Failed: unknown :("

As funções F # também são de primeira classe, o que significa que elas podem ser passadas como parâmetros e retornadas de outras funções.F# functions are also first-class, meaning they can be passed as parameters and returned from other functions.

Funções para definir operações em objetosFunctions to define operations on objects

O F # tem suporte total para objetos, que são tipos de dados úteis quando você precisa misturar dados e funcionalidades.F# has full support for objects, which are useful data types when you need to blend data and functionality. As funções F # são usadas 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)

Em vez de escrever código orientado a objeto, em F #, você geralmente escreverá um código que trata os objetos como outro tipo de dados para funções a serem manipuladas.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. Recursos como interfaces genéricas, expressões de objetoe uso criterioso de Membros são comuns em programas em F # maiores.Features such as generic interfaces, object expressions, and judicious use of members are common in larger F# programs.

Próximas etapasNext steps

Para saber mais sobre um conjunto maior de recursos do F #, confira o Tour em f #.To learn more about a larger set of F# features, check out the F# Tour.