O que é F#

F# é uma linguagem de programação universal para escrever código sucinto, robusto e de alto desempenho.

O F# permite que você escreva um código de auto-documentação não clusterizado, em que seu foco permanece no domínio do problema, em vez dos detalhes da programação.

Ela faz isso sem comprometer a velocidade e a compatibilidade – é de software livre, multiplataforma e interoperável.

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#")

O F# tem vários recursos, que incluem:

• Sintaxe leve
• Imutável por padrão
• Inferência de tipo e generalização automática
• Funções de primeira classe
• Tipos de dados avançados
• Correspondência de padrões
• Programação assíncrona

Um conjunto completo de recursos está documentado no guia de linguagem F#.

Tipo de dados avançados

Tipos como Registros e Uniões discriminadas permitem que você represente seus dados.

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

Registros e uniões discriminadas em F# são não nulos, imutáveis e comparáveis por padrão, tornando-os muito fáceis de usar.

Correção com funções e correspondência de padrões

As funções F# são fáceis de definir. Quando combinados com a correspondência de padrões, elas permitem que você defina o comportamento cuja correção é imposta pelo 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 :("

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.

Funções para definir operações em objetos

O F# tem suporte total para objetos, que são úteis quando você precisa misturar dados e funcionalidade. Membros e funções F# podem ser definidos 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)

Em F#, você geralmente escreverá um código que trata objetos como um tipo para as funções manipularem. Recursos como interfaces genéricas, expressões de objeto e o uso criterioso de membros são comuns em programas maiores em F#.

Próximas etapas

Para saber mais sobre um conjunto maior de recursos F#, confira o Faça um tour pelo F#.