F Sharp (linguagem de programação)

F#
ParadigmasMultiparadigma : funcional , imperativo , orientado a objetos , orientado a agentes , metaprogramação , reflexivo , concorrente
FamíliaML : Caml : OCaml
Projetado porDon Syme , Pesquisa da Microsoft
DesenvolvedorMicrosoft , a Fundação de Software F#
Apareceu pela primeira vez2005 ; 19 anos atrás , versão 1.0 ( 2005 )
Lançamento estável
8.0.0 / 14 de novembro de 2023 ; 11 meses atrás ( 2023-11-14 )
Disciplina de digitaçãoEstático , forte , inferido
SOMultiplataforma : .NET framework, Mono
LicençaMIT [1] [2]
Extensões de nome de arquivo.fs, .fsi, .fsx, .fsscript
Sitefsharp.org


aprenda.microsoft.com/en-us/dotnet/fsharp
Influenciado por
C# , Erlang , Haskell , [3] ML , OCaml , [4] [5] Python , Scala
Influenciado
C# , [6] Elm , F* , LiveScript
  • Programação F Sharp no Wikibooks

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]

Resumo das versões

Versão F#
Recursos adicionados
1.0
  • Programação funcional
  • Sindicatos discriminados
  • Registros
  • Tuplas
  • Correspondência de padrões
  • Abreviações de tipo
  • Programação orientada a objetos
  • Estruturas
  • Arquivos de assinatura
  • Arquivos de script
  • Programação imperativa
  • Módulos (sem functores)
  • Módulos aninhados
  • Interoperabilidade .NET
2.0
  • Padrões ativos
  • Unidades de medida
  • Expressões de sequência
  • Programação assíncrona
  • Programação de agentes
  • Membros da extensão
  • Argumentos nomeados
  • Argumentos opcionais
  • Fatiamento de matriz
  • Citações
  • Interoperabilidade nativa
  • Expressões de computação
3.0 [37]
  • Provedores de tipos
  • Expressões de consulta LINQ
  • Atributo mutável CLI
  • Strings com aspas triplas
  • Propriedades automáticas
  • Unidades de medida fornecidas
3.1 [38]
  • Campos de tipo de união nomeados
  • Extensões para fatiamento de matriz
  • Melhorias na inferência de tipos
4.0 [39]
  • Printf em valores unificados
  • Inicializadores de propriedades de extensão
  • Tipos fornecidos não nulos
  • Construtores primários como funções
  • Parâmetros estáticos para métodos fornecidos
  • Interpolação Printf
  • Gramática #if estendida
  • Atributo de chamada de cauda
  • Instanciações de interfaces múltiplas
  • Argumentos de tipo opcional
  • Dicionários Params
4.1 [40]
  • Tuplas de estrutura que interoperam com tuplas C#
  • Anotações de estrutura para registros
  • Anotações de estrutura para uniões discriminadas de caso único
  • Sublinhados em literais numéricos
  • Atributos do argumento de informações do chamador
  • Tipo de resultado e algumas funções básicas de resultado
  • Tipos e módulos mutuamente referenciais dentro do mesmo arquivo
  • Sintaxe implícita de "Módulo" em módulos com nome compartilhado como tipo
  • Byref retorna, suportando métodos de retorno ref C# de consumo
  • Melhorias na mensagem de erro
  • Suporte para 'fixo'
4.5 [28]
  • Alinhamento de versão de binário, pacote e linguagem
  • Suporte para 'Span<T>' e tipos relacionados
  • Capacidade de produzir retornos 'byref'
  • O tipo 'voidptr'
  • Os tipos 'inref<'T>' e 'outref<'T>' para representar 'byref's somente leitura e somente gravação
  • Estruturas 'IsByRefLike'
  • Estruturas 'IsReadOnly'
  • Suporte ao método de extensão para 'byref<'T>'/'inref<'T>'/'outref<'T>'
  • Palavra-chave 'match!' em expressões de computação
  • Upcast relaxado com 'yield' em expressões seq/list/array em F#
  • Recuo relaxado com expressões de lista e array
  • Casos de enumeração emitidos como públicos
4.6
  • Tipos de registros anônimos
4.7 [41]
  • Rendimentos implícitos
  • Não é mais necessário sublinhado duplo
  • Relaxamentos de recuo para parâmetros passados ​​para construtores e métodos estáticos
  • função 'nome de'
  • Classes estáticas abertas
5.0 [42]
  • FSharp.Core agora tem como alvo apenas netstandard2.0
  • Referências de pacotes em scripts F#
  • Suporte para Jupyter, nteract e VSCode Notebooks
  • Interpolação de Strings
  • Suporte para nameof
  • Declarações de tipo aberto
  • Fatiamento aprimorado
  • Melhorias nas citações do F#
  • Expressões de Computação Aplicativa
  • Rastreamentos de pilha aprimorados em expressões de computação assíncronas e outras expressões de computação F#
  • Interoperabilidade .NET aprimorada
  • Desempenho de mapa e conjunto aprimorado no FSharp.Core
  • Desempenho do compilador aprimorado
  • Análise de compilador aprimorada para autores de biblioteca
6.0 [43]
  • Tarefas
  • Indexação mais simples
  • Aumentos em “padrões ativos”
  • Operações personalizadas sobrecarregadas em expressões de computação
  • padrões “como”
  • Revisões de sintaxe de recuo
  • Mais conversões implícitas
  • Mais conversões de upcast implícitas
  • Conversões implícitas de inteiros
  • Suporte de primeira classe para conversões implícitas no estilo .NET
  • Avisos opcionais para conversões implícitas
  • Formatação para números binários
  • Descartes em uso de encadernações
  • Diretiva do otimizador InlineIfLambda
  • Código retomável
  • Mais funções de coleta
  • O mapa tem chaves e valores
  • Mais intrínsecos para NativePtr
  • Mais tipos numéricos com anotações de unidade
  • Avisos informativos para operadores simbólicos raramente usados
7.0 [44]
  • Suporte a membros abstratos estáticos em interfaces
  • Facilitando o trabalho com SRTPs (parâmetros de tipo resolvidos estaticamente)
  • Verificação de propriedades necessárias
  • Escopo init e propriedades somente init
  • Suporte a montagens de referência
  • Implantações autocontidas do F# e AOT nativo
  • Adicionado suporte para matrizes Nd até a classificação 32.
  • Paridade de funções do módulo de resultado com Opção.
  • Correções no codegen de máquinas de estado retomáveis ​​para as compilações de tarefas.
  • Melhor codegen para getters de propriedade sem efeitos colaterais gerados pelo compilador
  • Suporte ao compilador específico da plataforma ARM64 e ao alvo ARM64 no compilador F#. Suporte ao cache do gerenciador de dependências #r
  • Suporte para verificação de tipo paralelo e verificação de projeto (experimental, pode ser habilitado por meio da configuração do VS ou pelos autores de ferramentas)
  • Correções de bugs e melhorias diversas.
8.0 [45]
  • _.Propriedade abreviada para (fun x -> x.Property)
  • Cópia e atualização de campo de registro aninhado
  • enquanto! (enquanto bang) característica [46]
  • Sintaxe de interpolação de string estendida
  • Use e componha literais de string para printf e funções relacionadas
  • Operadores aritméticos em literais
  • Sintaxe de intersecção de restrição de tipo
  • Ligação fixa estendida
  • Definição mais fácil do método [<Extensão>]
  • Membros estáticos em interfaces
  • Let estático em uniões discriminadas, registros, estruturas e tipos sem construtores primários
  • try-with dentro de expressões de coleção seq{}, [] e [||]
  • Chamadas recursivas e yield! dentro do manipulador de exceções
  • Atributo de chamada de cauda
  • [<Struct>] sindicatos agora podem ter > 49 casos
  • Regras de recuo rigorosas
  • Novos diagnósticos do compilador
  • Interruptores para paralelização do compilador

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:

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 ifexpressões, tryexpressõ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 letpalavra-chave para vincular valores a um nome. [49] Por exemplo:

deixe x = 3 + 4     

vincula o valor 7ao nome x.

Novos tipos são definidos usando a typepalavra-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=42with{ r with Name="CD"rNamer

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ços
  • while laços
  • matrizes , criadas com a [| ... |]sintaxe
  • tabela hash , criada com a dict [ ... ]sintaxe ou System.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.Genericnamespace 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.RunSynchronouslyfunção. Vários blocos async podem ser executados em paralelo usando a Async.Parallelfunção que pega uma lista de asyncobjetos (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.Parallele Async.Startde outras operações que executam blocos assíncronos em paralelo.

A programação paralela também é suportada por meio de Array.Paralleloperadores de programação funcional na biblioteca padrão F#, uso direto do System.Threading.Tasksmodelo 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

Á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

  1. ^ "Licença da F# Software Foundation". GitHub . 14 de outubro de 2021.
  2. ^ "Licença F# da Microsoft". GitHub . 16 de outubro de 2021.
  3. ^ ab Syme, Granicz e Cisternino (2007: 2)
  4. ^ abcde "F# Reconhecimentos históricos". Microsoft .
  5. ^ 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
  6. ^ para assíncrono
  7. ^ abcdefghijkl The F# Software Foundation. "Usando F# para aplicativos da Web" . Recuperado em 2020-07-30 .
  8. ^ abcdefghijklm The F# Software Foundation. "Usando F# para programação de GPU". Arquivado do original em 2019-12-25 . Recuperado em 2019-12-25 .
  9. ^ abc The F# Software Foundation. "The F# Software Foundation" . Recuperado em 2012-11-24 .
  10. ^ ab The F# Software Foundation. "F# Compiler (edição de código aberto) @ github" . Recuperado em 2012-11-24 .
  11. ^ "Desenvolver com Visual F# no Visual Studio" . Recuperado em 2020-07-30 .
  12. ^ "F#" . Recuperado em 2020-07-30 .
  13. ^ Syme, Don. "F# 1.0.8 lançado". Microsoft . Recuperado em 7 de setembro de 2014 .
  14. ^ Syme, Don. "F# 2.0 lançado como parte do Visual Studio 2010". Microsoft . Recuperado em 7 de setembro de 2014 .
  15. ^ Zander, Jason. "Visual Studio 2012 e .NET Framework 4.5 lançados na web". Microsoft . Recuperado em 7 de setembro de 2014 .
  16. ^ "Visual Studio 2013 lançado para web". Microsoft . Recuperado em 7 de setembro de 2014 .
  17. ^ "Anunciando o RTM do Visual F# 4.0". Microsoft . Recuperado em 15 de setembro de 2015 .
  18. ^ "Anunciando o F# 4.1 e as Ferramentas do Visual F# para o Visual Studio 2017" . Recuperado em 2017-03-08 .
  19. ^ "Anunciando F# 4.5". Microsoft. 14 de agosto de 2018. Recuperado em 14 de agosto de 2018 .
  20. ^ "FSharp.Core 4.5.0".
  21. ^ "Baixe o .NET Core 2.1 (Linux, macOS e Windows)". Microsoft . Recuperado em 13 de maio de 2021 .
  22. ^ "Anunciando F# 4.6". Microsoft. 29 de março de 2019. Recuperado em 29 de março de 2019 .
  23. ^ "FSharp.Core 4.6.0".
  24. ^ "Baixe o .NET Core 2.2 (Linux, macOS e Windows)". Microsoft . Recuperado em 13 de maio de 2021 .
  25. ^ "Anunciando F# 4.7". Microsoft. 23 de setembro de 2019. Recuperado em 23 de setembro de 2019 .
  26. ^ "FSharp.Core 4.7.0".
  27. ^ "Baixe o .NET Core 3.0 (Linux, macOS e Windows)". Microsoft . Recuperado em 13 de maio de 2021 .
  28. ^ ab "Anunciando F# 5". 10 de novembro de 2020.
  29. ^ "Baixe .NET 5.0 (Linux, macOS e Windows)". Microsoft . Recuperado em 13 de maio de 2021 .
  30. ^ "F# 6 está oficialmente aqui!". 9 de novembro de 2021.
  31. ^ "Baixe .NET 6.0 (Linux, macOS e Windows)". Microsoft . Recuperado em 14 de novembro de 2021 .
  32. ^ "Anunciando F# 7". 8 de novembro de 2022.
  33. ^ "Baixe o .NET 7.0 (Linux, macOS e Windows)". Microsoft . Recuperado em 8 de novembro de 2022 .
  34. ^ "Anunciando F# 8". 14 de novembro de 2023.
  35. ^ "Baixe o .NET 8.0 (Linux, macOS e Windows)". Microsoft . Recuperado em 14 de novembro de 2023 .
  36. ^ 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 .
  37. ^ McNamara, Brian. "Mais sobre os recursos de linguagem do F# 3.0". Microsoft . Recuperado em 7 de setembro de 2014 .
  38. ^ McNamara, Brian. "Anunciando um pré-lançamento do F# 3.1". Microsoft . Recuperado em 7 de setembro de 2014 .
  39. ^ "Anunciando o RTM do Visual F# 4.0" . Recuperado em 2017-03-08 .
  40. ^ "Anunciando o F# 4.1 e as Ferramentas do Visual F# para o Visual Studio 2017" . Recuperado em 2017-03-08 .
  41. ^ "Anunciando F# 4.7". 23 de setembro de 2019.
  42. ^ "Anunciando F# 5". 10 de novembro de 2020.
  43. ^ "O que há de novo no F# 6 - Guia F#". 10 de março de 2023.
  44. ^ "Anunciando F# 7". 8 de novembro de 2022.
  45. ^ "Anunciando F# 8". 14 de novembro de 2023.
  46. ^ "Simplificando cálculos em F# com a nova palavra-chave 'while!'". 20 de setembro de 2023.
  47. ^ "F Sharp Programming/Computation Expressions - Wikibooks, livros abertos para um mundo aberto". en.wikibooks.org . Recuperado em 2022-01-21 .
  48. ^ kexugit (8 de julho de 2011). "Chamadas de cauda em F#". docs.microsoft.com . Recuperado em 22/04/2022 .
  49. ^ abcdefgh "Visão geral da linguagem F#" (PDF) . Recuperado em 2007-12-14 .
  50. ^ ab "Alguns detalhes sobre expressões de computação em F#" . Recuperado em 2007-12-14 .
  51. ^ ab "Pattern Matching in F# Part 2 : Padrões Ativos". Arquivado do original em 2012-12-09 . Recuperado em 2012-11-24 .
  52. ^ abc "Introdução aos fluxos de trabalho assíncronos do F#" . Recuperado em 2007-12-14 .
  53. ^ "Expressões de Tarefa". 19 de abril de 2022. Recuperado em 2023-01-15 .
  54. ^ "Unidades de Medida (F#)" . Recuperado em 2012-11-24 .
  55. ^ "Ampliar unidades de medida para incluir mais tipos numéricos". GitHub .
  56. ^ "Unidades de Medida em F#: Parte Um, Introdução às Unidades" . Recuperado em 2012-11-24 .
  57. ^ "Code Quotations (F#)" . Recuperado em 2012-11-24 .
  58. ^ "Type Providers" . Recuperado em 2012-11-24 .
  59. ^ "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 .
  60. ^ "Query Expressions (F#)" . Recuperado em 2012-11-24 .
  61. ^ "F# 3.0 – LINQ + Type Providers= Programação Rica em Informação" . Recuperado em 2012-11-24 .
  62. ^ Alexander Kurakin (15 de março de 2019). "Rider 2019.1 inicia seu programa de acesso antecipado!".
  63. ^ "Use F# no Windows". F# Software Foundation . Recuperado em 2018-08-07 .
  64. ^ "Características – Rider". JetBrains . Recuperado em 2018-08-07 .
  65. ^ "Fable: JavaScript do qual você pode se orgulhar!". fable.io . Recuperado em 2017-12-09 .
  66. ^ Intellifactory. "WebSharper home" . Recuperado em 2012-11-24 .
  67. ^ "Microsoft Case Studies: Microsoft Visual Studio 2012 - Financial Services Firm". Microsoft . Recuperado em 2012-11-25 .
  68. ^ "F# para negociação de energia e otimização de portfólio" . Recuperado em 25/11/2012 .
  69. ^ "Estudo de caso da Microsoft: Grange Insurance". Microsoft . Recuperado em 2012-11-25 .
  70. ^ 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 .
  71. ^ "F# Job in Facebook Social Gaming" . Recuperado em 25/11/2012 .
  72. ^ "F# Developer Testimonials" . Recuperado em 25 de maio de 2021 .
  73. ^ "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
  • 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
Obtido em "https://pt.wikipedia.org/w/index.php?title=F_Sharp_(linguagem_de_programação)&oldid=1235460569"