F Sharp (linguagem de programação)
![]() | |
Paradigmas | Multiparadigma : funcional , imperativo , orientado a objetos , orientado a agentes , metaprogramação , reflexivo , concorrente |
---|---|
Família | ML : Caml : OCaml |
Projetado por | Don Syme , Pesquisa da Microsoft |
Desenvolvedor | Microsoft , a Fundação de Software F# |
Apareceu pela primeira vez | 2005 | , versão 1.0
Lançamento estável | 8.0.0 / 14 de novembro de 2023 |
Disciplina de digitação | Estático , forte , inferido |
SO | Multiplataforma : .NET framework, Mono |
Licença | MIT [1] [2] |
Extensões de nome de arquivo | .fs, .fsi, .fsx, .fsscript |
Site | fsharp.org
|
Influenciado por | |
C# , Erlang , Haskell , [3] ML , OCaml , [4] [5] Python , Scala | |
Influenciado | |
C# , [6] Elm , F* , LiveScript | |
F# (pronuncia-se F sustenido ) é uma linguagem de programação de propósito geral , de alto nível , fortemente tipada e multiparadigma que abrange métodos de programação funcional , imperativo e orientado a objetos . É mais frequentemente usada como uma linguagem de infraestrutura de linguagem comum (CLI) multiplataforma no .NET , mas também pode gerar código JavaScript [7] e de unidade de processamento gráfico (GPU). [8]
O F# é desenvolvido pela F# Software Foundation , [9] Microsoft e contribuidores abertos. Um compilador de código aberto e multiplataforma para F# está disponível na F# Software Foundation. [10] F# é uma linguagem totalmente suportada no Visual Studio [11] e JetBrains Rider . [12] Plug-ins que suportam F# existem para muitos editores amplamente utilizados, incluindo Visual Studio Code , Vim e Emacs .
F# é um membro da família de linguagens ML e se originou como uma implementação do .NET Framework de um núcleo da linguagem de programação OCaml . [4] [5] Também foi influenciado por C# , Python , Haskell , [3] Scala e Erlang .
História
Versões
Versão F# |
Especificação de idioma | Data | Plataformas | Tempo de execução |
---|---|---|---|---|
1.x | Maio de 2005 [13] | Windows | .NET 1.0 - 3.5 | |
2.0 | Agosto de 2010 | Abril de 2010 [14] | Linux , macOS , Windows | .NET 2.0 - 4.0, Mono |
3.0 | Novembro de 2012 | Agosto de 2012 [15] | Linux , macOS , Windows ; JavaScript , [7] GPU [8] |
.NET 2.0 - 4.5, Mono |
3.1 | Novembro de 2013 | Outubro de 2013 [16] | Linux , macOS , Windows ; JavaScript , [7] GPU [8] |
.NET 2.0 - 4.5, Mono |
4.0 | Janeiro de 2016 | Julho de 2015 [17] | ||
4.1 | Maio de 2018 | Março de 2017 [18] | Linux , macOS , Windows ,
JavaScript , [7] GPU [8] |
.NET 3.5 - 4.6.2, .NET , Mono |
4.5 | Agosto de 2018 [19] | Linux , macOS , Windows ,
JavaScript , [7] GPU [8] |
.NET 4.5 - 4.7.2, [20] SDK do .NET Core 2.1.400 [21] | |
4.6 | Março de 2019 [22] | Linux , macOS , Windows ,
JavaScript , [7] GPU [8] |
.NET 4.5 - 4.7.2, [23] SDK do .NET Core 2.2.300 [24] | |
4.7 | Setembro de 2019 [25] | Linux , macOS , Windows ,
JavaScript , [7] GPU [8] |
.NET 4.5 - 4.8, [26] SDK do .NET Core 3.0.100 [27] | |
5.0 | Novembro de 2020 [28] | Linux , macOS , Windows ,
JavaScript , [7] GPU [8] |
.NET SDK 5.0.100 [29] | |
6.0 | Novembro de 2021 [30] | Linux , macOS , Windows ,
JavaScript , [7] GPU [8] |
.NET SDK 6.0.100 [31] | |
7.0 | Novembro de 2022 [32] | Linux , macOS , Windows ,
JavaScript , [7] GPU [8] |
.NET SDK 7.0.100 [33] | |
8.0 | Novembro de 2023 [34] | Linux , macOS , Windows ,
JavaScript , [7] GPU [8] |
.NET SDK 8.0.100 [35] |
Evolução da linguagem
O F# usa um processo de desenvolvimento e engenharia aberto. O processo de evolução da linguagem é gerenciado por Don Syme da Microsoft Research como o ditador benevolente vitalício (BDFL) para o design da linguagem, junto com a F# Software Foundation. Versões anteriores da linguagem F# foram projetadas pela Microsoft e pela Microsoft Research usando um processo de desenvolvimento fechado.
O F# foi incluído pela primeira vez no Visual Studio na edição de 2010 , no mesmo nível do Visual Basic (.NET) e do C# (embora como uma opção), e permanece em todas as edições posteriores, tornando a linguagem amplamente disponível e bem suportada.
O F# é originário da Microsoft Research, Cambridge, Reino Unido. A linguagem foi originalmente projetada e implementada por Don Syme , [4] segundo quem na equipe fsharp, eles dizem que o F é para "Diversão". [36] Andrew Kennedy contribuiu para o design de unidades de medida . [4] O Visual F# Tools para Visual Studio é desenvolvido pela Microsoft. [4] A F# Software Foundation desenvolveu o compilador e as ferramentas de código aberto F#, incorporando a implementação do compilador de código aberto fornecida pela equipe do Microsoft Visual F# Tools. [9]
Versão F# |
Recursos adicionados |
---|---|
1.0 |
|
2.0 |
|
3.0 [37] |
|
3.1 [38] |
|
4.0 [39] |
|
4.1 [40] |
|
4.5 [28] |
|
4.6 |
|
4.7 [41] |
|
5.0 [42] |
|
6.0 [43] |
|
7.0 [44] |
|
8.0 [45] |
|
Visão geral do idioma
Programação funcional
F# é uma linguagem funcional-first fortemente tipada com um grande número de capacidades que são normalmente encontradas apenas em linguagens de programação funcional , enquanto suporta recursos orientados a objetos disponíveis em C#. Juntos, esses recursos permitem que programas em F# sejam escritos em um estilo completamente funcional e também permitem que estilos funcionais e orientados a objetos sejam misturados.
Exemplos de características funcionais são:
- Tudo é uma expressão
- Inferência de tipo (usando inferência de tipo Hindley-Milner )
- Funciona como cidadão de primeira classe
- Funções anônimas com semântica de captura (ou seja, fechamentos )
- Variáveis e objetos imutáveis
- Suporte de avaliação preguiçoso
- Funções de ordem superior
- Funções aninhadas
- Currying
- Correspondência de padrões
- Tipos de dados algébricos
- Tuplas
- Compreensão de lista
- Suporte ao padrão de mônada (chamado de expressões de computação [47] )
- Otimização de chamada de cauda [48]
F# é uma linguagem baseada em expressões que usa avaliação ansiosa e também, em alguns casos, avaliação preguiçosa . Cada declaração em F#, incluindo if
expressões, try
expressões e loops, é uma expressão componível com um tipo estático. [49] Funções e expressões que não retornam nenhum valor têm um tipo de retorno de unit
. F# usa a let
palavra-chave para vincular valores a um nome. [49] Por exemplo:
deixe x = 3 + 4
vincula o valor 7
ao nome x
.
Novos tipos são definidos usando a type
palavra-chave. Para programação funcional, F# fornece os tipos tuple , record , discriminated union , list , option e result . [49] Uma tupla representa um conjunto de n valores, onde n ≥ 0. O valor n é chamado de aridade da tupla. Uma 3-tupla seria representada como (A, B, C)
, onde A, B e C são valores de tipos possivelmente diferentes. Uma tupla pode ser usada para armazenar valores somente quando o número de valores é conhecido em tempo de design e permanece constante durante a execução.
Um registro é um tipo onde os membros de dados são nomeados. Aqui está um exemplo de definição de registro:
tipo R = { Nome : string Idade : int }
Os registros podem ser criados como }. A palavra-chave é usada para criar uma cópia de um registro, como em }, que cria um novo registro copiando e alterando o valor do campo (assumindo que o registro criado no último exemplo foi nomeado ).
let r = { Name="AB"; Age=42
with
{ r with Name="CD"
r
Name
r
Um tipo de união discriminado é uma versão de tipo seguro de uniões C. Por exemplo,
tipo A = | UnionCaseX de string | UnionCaseY de int
Valores do tipo union podem corresponder a qualquer caso union. Os tipos dos valores transportados por cada caso union são incluídos na definição de cada caso.
O tipo de lista é uma lista vinculada imutável representada usando uma notação ( é o operador cons ) ou uma abreviação como . Uma lista vazia é escrita . O tipo de opção é um tipo de união discriminado com escolhas ou . Os tipos F# podem ser genéricos , implementados como tipos .NET genéricos.
head::tail
::
[item1; item2; item3]
[]
Some(x)
None
F# suporta funções lambda e closures . [49] Todas as funções em F# são valores de primeira classe e são imutáveis. [49] Funções podem ser curried . Sendo valores de primeira classe, funções podem ser passadas como argumentos para outras funções. Como outras linguagens de programação funcional, F# permite composição de funções usando os operadores >>
and <<
.
F# forneceexpressões de sequência [50]que definem uma sequênciaseq { ... }
, lista[ ... ]
ou array[| ... |]
através de código que gera valores. Por exemplo,
seq { para b em 0 .. 25 faça se b < 15 então produza b * b }
forma uma sequência de quadrados de números de 0 a 14 filtrando números do intervalo de números de 0 a 25. Sequências são geradoras – valores são gerados sob demanda (ou seja, são avaliados preguiçosamente ) – enquanto listas e matrizes são avaliadas avidamente.
O F# usa correspondência de padrões para vincular valores a nomes. A correspondência de padrões também é usada ao acessar uniões discriminadas – a união é correspondida por valores em relação às regras de padrões e uma regra é selecionada quando uma correspondência é bem-sucedida. O F# também oferece suporte a padrões ativos como uma forma de correspondência de padrões extensível. [51] É usado, por exemplo, quando existem várias maneiras de correspondência em um tipo. [49]
O F# oferece suporte a uma sintaxe geral para definir cálculos composicionais chamadosexpressões de computação . Expressões de sequência, computações assíncronas e consultas são tipos particulares de expressões de computação. Expressões de computação são uma implementação dopadrãomônada[50]
Programação imperativa
O suporte F# para programação imperativa inclui
for
laçoswhile
laços- matrizes , criadas com a
[| ... |]
sintaxe - tabela hash , criada com a
dict [ ... ]
sintaxe ouSystem.Collections.Generic.Dictionary<_,_>
tipo.
Valores e campos de registro também podem ser rotulados como mutable
. Por exemplo:
// Defina 'x' com valor inicial '1'
deixe mutável x = 1 // Altere o valor de 'x' para '3' x <- 3
Além disso, o F# oferece suporte ao acesso a todos os tipos e objetos CLI, como aqueles definidos no System.Collections.Generic
namespace que define estruturas de dados imperativas.
Programação orientada a objetos
Como outras linguagens Common Language Infrastructure (CLI), F# pode usar tipos CLI por meio de programação orientada a objetos. [49] O suporte F# para programação orientada a objetos em expressões inclui:
- Notação de ponto, por exemplo,
x.Name
- Expressões de objeto, por exemplo, }
{ new obj() with member x.ToString() = "hello"
- Construção de objetos, por exemplo,
new Form()
- Testes de tipo, por exemplo,
x :? string
- Coerções de tipo, por exemplo,
x :?> string
- Argumentos nomeados, por exemplo,
x.Method(someArgument=1)
- Setters nomeados, por exemplo,
new Form(Text="Hello")
- Argumentos opcionais, por exemplo,
x.Method(OptionalArgument=1)
O suporte para programação orientada a objetos em padrões inclui
- Testes de tipo, por exemplo,
:? string as s
- Padrões ativos, que podem ser definidos sobre tipos de objetos [51]
As definições de tipo de objeto F# podem ser class, struct, interface, enum ou delegate type definitions, correspondendo aos formulários de definição encontrados em C# . Por exemplo, aqui está uma classe com um construtor que recebe um nome e uma idade e declara duas propriedades.
/// Uma definição simples de tipo de objeto
type Person ( nome : string , idade : int ) = membro x . Nome = nome membro x . Idade = idade
Programação assíncrona
O F# oferece suporte à programação assíncrona por meio de fluxos de trabalho assíncronos . [52] Um fluxo de trabalho assíncrono é definido como uma sequência de comandos dentro de um async{ ... }
, como em
deixe asynctask = async { deixe req = WebRequest . Crie ( url ) deixe! resposta = req . GetResponseAsync () use fluxo = resposta . GetResponseStream () use streamreader = novo Sistema . IO . StreamReader ( fluxo ) retorne streamreader . ReadToEnd () }
O let!
indica que a expressão à direita (obter a resposta) deve ser feita de forma assíncrona, mas o fluxo só deve continuar quando o resultado estiver disponível. Em outras palavras, do ponto de vista do bloco de código, é como se obter a resposta fosse uma chamada de bloqueio, enquanto do ponto de vista do sistema, o thread não será bloqueado e pode ser usado para processar outros fluxos até que o resultado necessário para este fique disponível.
O bloco async pode ser invocado usando a Async.RunSynchronously
função. Vários blocos async podem ser executados em paralelo usando a Async.Parallel
função que pega uma lista de async
objetos (no exemplo, asynctask
é um objeto async) e cria outro objeto async para executar as tarefas nas listas em paralelo. O objeto resultante é invocado usando Async.RunSynchronously
. [52]
A inversão de controle em F# segue este padrão. [52]
Desde a versão 6.0, o F# oferece suporte à criação, consumo e retorno de tarefas .NET diretamente. [53]
abra System.Net.Http deixe fetchUrlAsync ( url : string ) = // string -> Task<string> tarefa { use cliente = novo HttpClient () deixe! resposta = cliente . GetAsync ( url ) deixe! conteúdo = resposta . Conteúdo . ReadAsStringAsync () faça ! Tarefa . Atraso 500 retorne conteúdo }
// Uso
let fetchPrint () = let task = task { let! data = fetchUrlAsync "https://example.com" printfn $ "{data}" } task . Wait ()
Programação paralela
A programação paralela é suportada em parte por meio do Async.Parallel
e Async.Start
de outras operações que executam blocos assíncronos em paralelo.
A programação paralela também é suportada por meio de Array.Parallel
operadores de programação funcional na biblioteca padrão F#, uso direto do System.Threading.Tasks
modelo de programação de tarefas, uso direto do pool de threads .NET e threads .NET e por meio da tradução dinâmica do código F# para mecanismos de execução paralela alternativos, como código GPU [8] .
Unidades de medida
O sistema de tipo F# suporta unidades de medida para verificação de números. [54]
Em F#, você pode atribuir unidades de medida, como metros ou quilogramas, a valores de ponto flutuante, inteiros sem sinal [55] e inteiros com sinal. Isso permite que o compilador verifique se a aritmética envolvendo esses valores é dimensionalmente consistente, ajudando a evitar erros comuns de programação ao garantir que, por exemplo, comprimentos não sejam adicionados erroneamente a tempos.
O recurso de unidades de medida integra-se com a inferência de tipo F# para exigir anotações de tipo mínimas no código do usuário. [56]
[< Medida >] tipo m // metro [< Medida >] tipo s // segundo
deixe distância = 100 . 0 < m > // float<m> deixe tempo = 5 . 0 < s > // float<s> deixe velocidade = distância / tempo // float<m/s>
[< Medida >] tipo kg // quilograma [< Medida >] tipo N = ( kg * m )/( s ^ 2 ) // Newtons [< Medida >] tipo Pa = N /( m ^ 2 ) // Pascals
[< Medida >] tipo dias let better_age = 3u < dias > // uint<dias>
O verificador de tipo estático do F# fornece essa funcionalidade em tempo de compilação, mas as unidades são apagadas do código compilado. Consequentemente, não é possível determinar a unidade de um valor em tempo de execução.
Metaprogramação
O F# permite algumas formas de personalização de sintaxe por meio de metaprogramação para oferecer suporte à incorporação de linguagens específicas de domínio personalizadas na linguagem F#, principalmente por meio de expressões de computação. [49]
O F# inclui um recurso para metaprogramação em tempo de execução chamado citações. [57] Uma expressão de citação é avaliada como uma representação de árvore de sintaxe abstrata das expressões F#. Da mesma forma, definições rotuladas com o [<ReflectedDefinition>]
atributo também podem ser acessadas em seu formato de citação. As citações F# são usadas para vários propósitos, incluindo compilar código F# em código JavaScript [7] e GPU [8] . As citações representam suas expressões de código F# como dados para uso por outras partes do programa, ao mesmo tempo em que exigem que seja um código F# sintaticamente correto.
Programação rica em informações
O F# 3.0 introduziu uma forma de metaprogramação em tempo de compilação por meio da geração de tipos estaticamente extensíveis, chamada de provedores de tipos F#. [58] Os provedores de tipos F# permitem que o compilador e as ferramentas F# sejam estendidos com componentes que fornecem informações de tipo ao compilador sob demanda em tempo de compilação. Os provedores de tipos F# têm sido usados para fornecer acesso fortemente tipado a fontes de informações conectadas de forma escalável, incluindo o gráfico de conhecimento Freebase . [59]
No F# 3.0, os recursos de cotação e expressão de computação do F# são combinados para implementar consultas LINQ . [60] Por exemplo:
// Use o provedor de tipo OData para criar tipos que podem ser usados para acessar o banco de dados Northwind.
abra Microsoft.FSharp.Data.TypeProviders
digite Northwind = ODataService < "http://services.odata.org/Northwind/Northwind.svc" > deixe db = Northwind . GetDataContext ()
// Uma expressão de consulta.
let query1 = query { for customer in db . Os clientes selecionam o cliente }
A combinação de provedores de tipos, consultas e programação funcional fortemente tipada é conhecida como programação rica em informações . [61]
Programação de agentes
O F# suporta uma variação do modelo de programação de ator por meio da implementação na memória de agentes assíncronos leves. Por exemplo, o código a seguir define um agente e posta 2 mensagens:
tipo Mensagem = | Enfileirar de string | Desenfileirar de AsyncReplyChannel < Opção < string >>
// Fornece acesso simultâneo a uma lista de strings
let listManager = MailboxProcessor . Start ( fun inbox -> let rec messageLoop list = async { let! msg = inbox . Receive () match msg with | Enqueue item -> return ! messageLoop ( item :: list )
| Dequeue replyChannel -> lista de correspondências com | [] -> replyChannel . Responder Nenhum return ! messageLoop lista | head :: tail -> replyChannel . Responder ( Algum head ) return ! messageLoop tail }
// Inicie o loop com uma lista vazia
messageLoop [] )
// Uso
async { // Enfileirar algumas strings listManager . Post ( Enfileirar "Olá" ) listManager . Post ( Enfileirar "Mundo" )
// Desfila e processa as strings
let! str = listManager . PostAndAsyncReply ( Dequeue ) str |> Option . iter ( printfn "Desfila: %s" )
}
|> Assíncrono . Iniciar
Ferramentas de desenvolvimento
- O Visual Studio , com as ferramentas Visual F# da Microsoft instaladas, pode ser usado para criar, executar e depurar projetos F#. As ferramentas Visual F# incluem um console interativo read–eval–print loop (REPL) hospedado pelo Visual Studio que pode executar código F# conforme ele é escrito. O Visual Studio para Mac também oferece suporte total a projetos F#.
- O Visual Studio Code contém suporte total para F# por meio da extensão Ionide.
- O F# pode ser desenvolvido com qualquer editor de texto. Suporte específico existe em editores como o Emacs .
- O JetBrains Rider é otimizado para o desenvolvimento do código F# a partir da versão 2019.1. [62]
- O LINQPad oferece suporte ao F# desde a versão 2.x. [ de quem? ]
Comparação de ambientes de desenvolvimento integrados
IDE | Licença | Windows | Linux | Mac OS | Desenvolvedor |
---|---|---|---|---|---|
Microsoft Visual Studio | Proprietário (padrão) Freeware (edição comunitária) |
Sim | Não | Sim | Microsoft |
Código do Visual Studio [63] | Proprietário ( código binário ) Licença MIT ( código fonte ) |
Sim | Sim | Sim | Microsoft |
Cavaleiro [64] | Proprietário | Sim | Sim | Sim | JetBrains |
Áreas de aplicação
F# é uma linguagem de programação de propósito geral .
Programação web
O SAFE Stack é uma pilha F# de ponta a ponta para desenvolver aplicativos da web. Ele usa ASP.NET Core no lado do servidor e Fable no lado do cliente. [65]
Uma opção alternativa de ponta a ponta do F# é a estrutura WebSharper . [66]
Desenvolvimento de aplicativos multiplataforma
O F# pode ser usado junto com o Visual Studio Tools for Xamarin para desenvolver aplicativos para iOS e Android . A biblioteca Fabulous fornece uma interface funcional mais confortável.
Programação analítica
Entre outros, o F# é usado para programação financeira quantitativa, [67] negociação de energia e otimização de portfólio, [68] aprendizado de máquina, [69] inteligência empresarial [70] e jogos sociais no Facebook . [71]
Na década de 2010, o F# foi posicionado como uma alternativa otimizada ao C# . A capacidade de script do F# e a compatibilidade entre linguagens com todos os produtos da Microsoft o tornaram popular entre os desenvolvedores. [72]
Roteiro
O F# pode ser usado como uma linguagem de script, principalmente para scripts de loop de leitura-avaliação-impressão (REPL) de desktop. [73]
Comunidade de código aberto
A comunidade de código aberto F# inclui a F# Software Foundation [9] e o F# Open Source Group no GitHub . [10] Projetos F# de código aberto populares incluem:
- Fable, um transpilador de F# para Javascript baseado no Babel.
- Paket, um gerenciador de pacotes alternativo para .NET que ainda pode usar repositórios NuGet , mas tem gerenciamento de versão centralizado.
- FAKE, um sistema de construção compatível com F#.
- Giraffe, um middleware orientado funcionalmente para ASP.NET Core .
- Suave, uma biblioteca leve de desenvolvimento e servidor web.
Compatibilidade
O F# apresenta um "modo de compatibilidade de ML" legado que pode compilar diretamente programas escritos em um grande subconjunto de OCaml, aproximadamente, sem functores, objetos, variantes polimórficas ou outras adições.
Exemplos
Seguem alguns pequenos exemplos:
// Este é um comentário para um programa de exemplo hello world.
printfn "Hello World!"
Uma definição de tipo de registro. Registros são imutáveis por padrão e são comparados por igualdade estrutural.
tipo Pessoa = { Nome : string Sobrenome : string Idade : int }
// Criando uma instância do registro
let person = { FirstName = "John" ; LastName = "Doe" ; Age = 30 }
Uma classe Person com um construtor que recebe um nome, uma idade e duas propriedades imutáveis.
/// Este é um comentário de documentação para uma definição de tipo.
type Person ( name : string , age : int ) = member x . Name = name member x . Age = age /// instanciação de classe let mrSmith = Person ( "Smith" , 42 )
Um exemplo simples que é frequentemente usado para demonstrar a sintaxe de linguagens funcionais é a função fatorial para inteiros não negativos de 32 bits, aqui mostrada em F#:
/// Usando expressão de correspondência de padrões
let rec fatorial n = match n with | 0 -> 1 | _ -> n * fatorial ( n - 1 )
/// Para funções de argumento único, há açúcar sintático (função de correspondência de padrões):
let rec factorial = function | 0 -> 1 | n -> n * factorial ( n - 1 ) /// Usando operador fold e range let factorial n = [ 1 .. n ] |> Seq . fold (*) 1
Exemplos de iteração:
/// Iteração usando um loop 'for'
let printList lst = for x in lst do printfn $ "{x}"
/// Iteração usando uma função de ordem superior
let printList2 lst = List . iter ( printfn "%d" ) lst
/// Iteração usando uma função recursiva e correspondência de padrões
let rec printList3 lst = match lst with | [] -> () | h :: t -> printfn "%d" h printList3 t
Exemplos de Fibonacci:
/// Fórmula do número de Fibonacci
[< TailCall >]
deixe fib n = deixe rec g n f0 f1 = combine n com | 0 -> f0 | 1 -> f1 | _ -> g ( n - 1 ) f1 ( f0 + f1 ) g n 0 1
/// Outra abordagem - uma sequência infinita preguiçosa de números de Fibonacci
let fibSeq = Seq .unfold ( fun ( a , b ) - > Some ( a + b , ( b , a + b ) ) ) ( 0,1 )
// Imprime fibs pares
[ 1 .. 10 ] |> Lista . map fib |> Lista . filter ( fun n -> ( n % 2 ) = 0 ) |> printList
// Mesma coisa, usando uma expressão de lista
[ for i in 1 .. 10 do let r = fib i if r % 2 = 0 then yield r ] |> printList
Um exemplo de programa do Windows Forms:
// Abra a biblioteca do Windows Forms
abra System.Windows.Forms
// Crie uma janela e defina algumas propriedades
let form = new Form ( Visible = true , TopMost = true , Text = "Bem-vindo ao F#" )
// Crie um rótulo para mostrar algum texto no formato
let label = let x = 3 + ( 4 * 5 ) new Label ( Text = $ "{x}" )
// Adicione o rótulo ao
formulário form . Controles . Adicionar ( rótulo )
// Por fim, execute o formulário
[< System . STAThread >]
Application . Run ( form )
Exemplo de programação paralela assíncrona (tarefas paralelas de CPU e E/S):
/// Um detector de números primos simples
let isPrime ( n : int ) = let bound = int ( sqrt ( float n )) seq { 2 .. bound } |> Seq . forall ( fun x -> n % x <> 0 )
// Estamos usando fluxos de trabalho assíncronos
let primeAsync n = async { return ( n , isPrime n ) }
/// Retorna primos entre m e n usando múltiplas threads
let primes m n = seq { m .. n } |> Seq . map primeAsync |> Async . Parallel |> Async . RunSynchronously |> Array . filter snd |> Array . map fst
// Executar um teste
primos 1000000 1002000 |> Array . iter ( printfn "%d" )
Veja também
Notas
- ^ "Licença da F# Software Foundation". GitHub . 14 de outubro de 2021.
- ^ "Licença F# da Microsoft". GitHub . 16 de outubro de 2021.
- ^ ab Syme, Granicz e Cisternino (2007: 2)
- ^ abcde "F# Reconhecimentos históricos". Microsoft .
- ^ ab Syme, Don (2006). "Aproveitando os componentes de metaprogramação do .NET do F#".
[F#] está enraizado no design do Core ML e, em particular, tem uma linguagem central amplamente compatível com a do OCaml
- ^ para assíncrono
- ^ abcdefghijkl The F# Software Foundation. "Usando F# para aplicativos da Web" . Recuperado em 2020-07-30 .
- ^ abcdefghijklm The F# Software Foundation. "Usando F# para programação de GPU". Arquivado do original em 2019-12-25 . Recuperado em 2019-12-25 .
- ^ abc The F# Software Foundation. "The F# Software Foundation" . Recuperado em 2012-11-24 .
- ^ ab The F# Software Foundation. "F# Compiler (edição de código aberto) @ github" . Recuperado em 2012-11-24 .
- ^ "Desenvolver com Visual F# no Visual Studio" . Recuperado em 2020-07-30 .
- ^ "F#" . Recuperado em 2020-07-30 .
- ^ Syme, Don. "F# 1.0.8 lançado". Microsoft . Recuperado em 7 de setembro de 2014 .
- ^ Syme, Don. "F# 2.0 lançado como parte do Visual Studio 2010". Microsoft . Recuperado em 7 de setembro de 2014 .
- ^ Zander, Jason. "Visual Studio 2012 e .NET Framework 4.5 lançados na web". Microsoft . Recuperado em 7 de setembro de 2014 .
- ^ "Visual Studio 2013 lançado para web". Microsoft . Recuperado em 7 de setembro de 2014 .
- ^ "Anunciando o RTM do Visual F# 4.0". Microsoft . Recuperado em 15 de setembro de 2015 .
- ^ "Anunciando o F# 4.1 e as Ferramentas do Visual F# para o Visual Studio 2017" . Recuperado em 2017-03-08 .
- ^ "Anunciando F# 4.5". Microsoft. 14 de agosto de 2018. Recuperado em 14 de agosto de 2018 .
- ^ "FSharp.Core 4.5.0".
- ^ "Baixe o .NET Core 2.1 (Linux, macOS e Windows)". Microsoft . Recuperado em 13 de maio de 2021 .
- ^ "Anunciando F# 4.6". Microsoft. 29 de março de 2019. Recuperado em 29 de março de 2019 .
- ^ "FSharp.Core 4.6.0".
- ^ "Baixe o .NET Core 2.2 (Linux, macOS e Windows)". Microsoft . Recuperado em 13 de maio de 2021 .
- ^ "Anunciando F# 4.7". Microsoft. 23 de setembro de 2019. Recuperado em 23 de setembro de 2019 .
- ^ "FSharp.Core 4.7.0".
- ^ "Baixe o .NET Core 3.0 (Linux, macOS e Windows)". Microsoft . Recuperado em 13 de maio de 2021 .
- ^ ab "Anunciando F# 5". 10 de novembro de 2020.
- ^ "Baixe .NET 5.0 (Linux, macOS e Windows)". Microsoft . Recuperado em 13 de maio de 2021 .
- ^ "F# 6 está oficialmente aqui!". 9 de novembro de 2021.
- ^ "Baixe .NET 6.0 (Linux, macOS e Windows)". Microsoft . Recuperado em 14 de novembro de 2021 .
- ^ "Anunciando F# 7". 8 de novembro de 2022.
- ^ "Baixe o .NET 7.0 (Linux, macOS e Windows)". Microsoft . Recuperado em 8 de novembro de 2022 .
- ^ "Anunciando F# 8". 14 de novembro de 2023.
- ^ "Baixe o .NET 8.0 (Linux, macOS e Windows)". Microsoft . Recuperado em 14 de novembro de 2023 .
- ^ Edwards, Kathryn (23 de dezembro de 2008). "O AZ das linguagens de programação: F#". Network World . IDG. Arquivado do original em 13 de novembro de 2018 . Recuperado em 8 de agosto de 2016 .
- ^ McNamara, Brian. "Mais sobre os recursos de linguagem do F# 3.0". Microsoft . Recuperado em 7 de setembro de 2014 .
- ^ McNamara, Brian. "Anunciando um pré-lançamento do F# 3.1". Microsoft . Recuperado em 7 de setembro de 2014 .
- ^ "Anunciando o RTM do Visual F# 4.0" . Recuperado em 2017-03-08 .
- ^ "Anunciando o F# 4.1 e as Ferramentas do Visual F# para o Visual Studio 2017" . Recuperado em 2017-03-08 .
- ^ "Anunciando F# 4.7". 23 de setembro de 2019.
- ^ "Anunciando F# 5". 10 de novembro de 2020.
- ^ "O que há de novo no F# 6 - Guia F#". 10 de março de 2023.
- ^ "Anunciando F# 7". 8 de novembro de 2022.
- ^ "Anunciando F# 8". 14 de novembro de 2023.
- ^ "Simplificando cálculos em F# com a nova palavra-chave 'while!'". 20 de setembro de 2023.
- ^ "F Sharp Programming/Computation Expressions - Wikibooks, livros abertos para um mundo aberto". en.wikibooks.org . Recuperado em 2022-01-21 .
- ^ kexugit (8 de julho de 2011). "Chamadas de cauda em F#". docs.microsoft.com . Recuperado em 22/04/2022 .
- ^ abcdefgh "Visão geral da linguagem F#" (PDF) . Recuperado em 2007-12-14 .
- ^ ab "Alguns detalhes sobre expressões de computação em F#" . Recuperado em 2007-12-14 .
- ^ ab "Pattern Matching in F# Part 2 : Padrões Ativos". Arquivado do original em 2012-12-09 . Recuperado em 2012-11-24 .
- ^ abc "Introdução aos fluxos de trabalho assíncronos do F#" . Recuperado em 2007-12-14 .
- ^ "Expressões de Tarefa". 19 de abril de 2022. Recuperado em 2023-01-15 .
- ^ "Unidades de Medida (F#)" . Recuperado em 2012-11-24 .
- ^ "Ampliar unidades de medida para incluir mais tipos numéricos". GitHub .
- ^ "Unidades de Medida em F#: Parte Um, Introdução às Unidades" . Recuperado em 2012-11-24 .
- ^ "Code Quotations (F#)" . Recuperado em 2012-11-24 .
- ^ "Type Providers" . Recuperado em 2012-11-24 .
- ^ "Novo relatório técnico da Microsoft Research: Suporte de linguagem fortemente tipada para fontes de informação em escala de Internet" . Recuperado em 2012-11-24 .
- ^ "Query Expressions (F#)" . Recuperado em 2012-11-24 .
- ^ "F# 3.0 – LINQ + Type Providers= Programação Rica em Informação" . Recuperado em 2012-11-24 .
- ^ Alexander Kurakin (15 de março de 2019). "Rider 2019.1 inicia seu programa de acesso antecipado!".
- ^ "Use F# no Windows". F# Software Foundation . Recuperado em 2018-08-07 .
- ^ "Características – Rider". JetBrains . Recuperado em 2018-08-07 .
- ^ "Fable: JavaScript do qual você pode se orgulhar!". fable.io . Recuperado em 2017-12-09 .
- ^ Intellifactory. "WebSharper home" . Recuperado em 2012-11-24 .
- ^ "Microsoft Case Studies: Microsoft Visual Studio 2012 - Financial Services Firm". Microsoft . Recuperado em 2012-11-25 .
- ^ "F# para negociação de energia e otimização de portfólio" . Recuperado em 25/11/2012 .
- ^ "Estudo de caso da Microsoft: Grange Insurance". Microsoft . Recuperado em 2012-11-25 .
- ^ Trelford, Phil (2007). "Aprendendo com F#". Anais do 4º workshop ACM SIGPLAN sobre usuários comerciais de programação funcional - CUFP '07 . pp. 1–2. doi :10.1145/1362702.1362709. ISBN 9781450378444. S2CID 24018363 . Recuperado em 25/11/2012 .
- ^ "F# Job in Facebook Social Gaming" . Recuperado em 25/11/2012 .
- ^ "F# Developer Testimonials" . Recuperado em 25 de maio de 2021 .
- ^ "Scripting em F#". 12 de setembro de 2008. Recuperado em 2020-01-17 .
Referências
- Syme, Don ; Granicz, Adam; Cisternino, Antonio (2007), Especialista F# , Apress
- Harrop, Jon (2010), Visual F# 2010 para Computação Técnica , Flying Frog Consultancy
- Pickering, Robert (2007), Fundamentos do F# , Apress
- Smith, Chris (2009), Programação F# , O'Reilly
- Petricek, Tomas (2009), Programação funcional do mundo real com exemplos em F# e C# , Manning Publications
- Hansen, Michael; Rischel, Hans (2013), Programação Funcional Usando F# , Cambridge University Press
- Astborg, Johan (2013), F# para Finanças Quantitativas, Packt Publishing
- Lundin, Mikael (2015), Testando com F#, Packt Publishing
Links externos
- Site oficial The F# Software Foundation
- O Grupo F# Open Source no GitHub
- O Visual F# Developer Center arquivado em 2008-11-19 no Wayback Machine
- Experimente F# para aprender F# em um navegador da web
- Site de trechos F#
- O blog da equipe do Visual F#
- O site original da Microsoft Research para F#
- The F# Survival Guide, dezembro de 2009 (livro baseado na Web)
- A especificação da linguagem F#
- Uma introdução à programação em F# Arquivado em 2011-07-13 no Wayback Machine
- Um tutorial mostrando o processo de obtenção de um design funcional; inclui teste e codificação paralela