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#.
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.
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.
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#.
Para saber mais sobre um conjunto maior de recursos F#, confira o Faça um tour pelo F#.
Comentários do .NET
O .NET é um projeto código aberto. Selecione um link para fornecer comentários: