F Sharp (linguagem de programação)

Da Wikipédia, a enciclopédia livre
Ir para a navegação Saltar para pesquisar
F#
F Sharp logo.svg
Logomarca F#
ParadigmaMulti-paradigma : funcional , imperativo , orientado a objetos , metaprogramação , reflexivo , concorrente
FamíliaML
Projetado porDon Syme , Microsoft Research
DesenvolvedorMicrosoft , The F# Software Foundation
Apareceu pela primeira vez2005 ; 17 anos atrás , versão 1.0 ( 2005 )
Versão estável
6.0 [1] Edite isso no Wikidata / 19 de outubro de 2021 ; 7 meses atrás ( 19 de outubro de 2021 )
Disciplina de digitaçãoEstático , forte , inferido
SOMultiplataforma : .NET , .NET Framework , Mono
LicençaLicença MIT [2] [3]
Extensões de nome de arquivo.fs, .fsi, .fsx, .fsscript
Local na rede Internetfsharp .org
Influenciado por
C# , Erlang , Haskell , [4] ML , OCaml , [5] [6] Python , Scala
Influenciado
C# , [7] Elm , F* , LiveScript

F# (pronuncia- se F sharp ) é uma linguagem de programação funcional, de propósito geral, fortemente tipada e multiparadigma que engloba métodos de programação funcionais , imperativos e orientados a objetos . É mais frequentemente usado como uma linguagem de infraestrutura de linguagem comum (CLI) multiplataforma em .NET , mas também pode gerar código JavaScript [8] e unidade de processamento gráfico (GPU). [9]

F# é desenvolvido pela F# Software Foundation , [10] Microsoft e colaboradores abertos. Um compilador de plataforma cruzada de código aberto para F# está disponível na F# Software Foundation. [11] F# é uma linguagem totalmente suportada no Visual Studio [12] e JetBrains Rider . [13] Existem plug-ins que suportam F# para muitos editores amplamente usados, principalmente a extensão Ionide para Visual Studio Code e integração com outros editores, como Vim e Emacs .

F# é um membro da família de linguagens ML e originado como uma implementação .NET Framework de um núcleo da linguagem de programação OCaml . [5] [6] Também foi influenciado por C# , Python , Haskell , [4] Scala e Erlang .

História

Versões

Versão Especificação do idioma Encontro Plataformas Tempo de execução
F# 1.x Maio de 2005 [14] janelas .NET 1.0 - 3.5
F# 2.0 agosto de 2010 Abril de 2010 [15] Linux , macOS , Windows .NET 2.0 - 4.0, Mono
F# 3.0 Novembro de 2012 Agosto de 2012 [16] Linux , macOS , Windows ;
JavaScript , [8] GPU [9]
.NET 2.0 - 4.5, Mono
F# 3.1 novembro de 2013 Outubro de 2013 [17] Linux , macOS , Windows ;
JavaScript , [8] GPU [9]
.NET 2.0 - 4.5, Mono
F# 4.0 Janeiro de 2016 Julho de 2015 [18]
F# 4.1 Maio de 2018 Março de 2017 [19] Linux , macOS , Windows ,

JavaScript , [8] GPU [9]

.NET 3.5 - 4.6.2, .NET Core , Mono
F# 4.5 Agosto de 2018 [20] Linux , macOS , Windows ,

JavaScript , [8] GPU [9]

.NET 4.5 - 4.7.2, [21] .NET Core SDK 2.1.400 [22]
F# 4.6 Março de 2019 [23] Linux , macOS , Windows ,

JavaScript , [8] GPU [9]

.NET 4.5 - 4.7.2, [24] .NET Core SDK 2.2.300 [25]
F# 4.7 Setembro de 2019 [26] Linux , macOS , Windows ,

JavaScript , [8] GPU [9]

.NET 4.5 - 4.8, [27] .NET Core SDK 3.0.100 [28]
F# 5.0 Novembro de 2020 [29] Linux , macOS , Windows ,

JavaScript , [8] GPU [9]

SDK .NET 5.0.100 [30]
F# 6.0 Novembro de 2021 [31] Linux , macOS , Windows ,

JavaScript , [8] GPU [9]

SDK .NET 6.0.100 [32]

Evolução da linguagem

O F# usa um processo aberto de desenvolvimento e engenharia. O processo de evolução da linguagem é gerenciado por Don Syme da Microsoft Research como o ditador benevolente para a vida (BDFL) para o design da linguagem, juntamente com a F# Software Foundation. As versões anteriores da linguagem F# foram projetadas pela Microsoft e pela Microsoft Research usando um processo de desenvolvimento fechado.

F# é originário da Microsoft Research , Cambridge, Reino Unido. A linguagem foi originalmente projetada e implementada por Don Syme , [5] segundo quem na equipe do fsharp, eles dizem que o F é para "Diversão". [33] Andrew Kennedy contribuiu para o desenho das unidades de medida . [5] As Ferramentas do Visual F# para Visual Studio são desenvolvidas pela Microsoft. [5] 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 Microsoft Visual F# Tools. [10]

Resumo das versões
Recursos adicionados
F# 1.0
  • Programação funcional
  • Sindicatos discriminados
  • Registros
  • Tuplas
  • Correspondência de padrões
  • Tipo de abreviações
  • Programação orientada a objetos
  • Estruturas
  • Arquivos de assinatura
  • Arquivos de script
  • Programação imperativa
  • Módulos (sem functores)
  • Módulos aninhados
  • Interoperabilidade .NET
F# 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
  • Cotações
  • Interoperabilidade nativa
  • Expressões de computação
F# 3.0 [34]
  • Provedores de tipo
  • Expressões de consulta LINQ
  • CLIAtributo mutável
  • Strings com aspas triplas
  • Propriedades automáticas
  • Unidades de medida fornecidas
F# 3.1 [35]
  • Campos de tipo de união nomeados
  • Extensões para fatiamento de matriz
  • Aprimoramentos de inferência de tipo
F# 4.0 [36]
  • Imprimir em valores unitizados
  • Inicializadores de propriedade de extensão
  • Tipos fornecidos não nulos
  • Construtores primários como funções
  • Parâmetros estáticos para métodos fornecidos
  • Interpolação de impressão
  • Gramática #if estendida
  • Atributo de chamada de cauda
  • Múltiplas instâncias de interface
  • Argumentos de tipo opcionais
  • Dicionários de parâmetros
F# 4.1 [37]
  • 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 "Módulo" implícita em módulos com nome compartilhado como tipo
  • Byref retorna, suportando métodos de retorno de referência C# que consomem
  • Melhorias na mensagem de erro
  • Suporte para 'fixo'
F# 4.5 [29]
  • Alinhamento de versão de binário, pacote e idioma
  • 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>'
  • 'partida!' palavra-chave em expressões de computação
  • Upcast relaxado com 'yield' em expressões F# seq/list/array
  • Recuo relaxado com expressões de lista e matriz
  • Casos de enumeração emitidos como públicos
F# 4.6
  • Tipos anônimos
F# 4.7 [38]
  • Rendimentos implícitos
  • Não há mais sublinhado duplo necessário
  • Relaxamentos de recuo para parâmetros passados ​​para construtores e métodos estáticos
  • função 'nome de'
  • Abrir classes estáticas
F# 5.0 [39]
  • FSharp.Core agora tem como alvo apenas o netstandard2.0
  • Referências de pacote em scripts F#
  • Suporte para notebooks Jupyter, nteract e VSCode
  • Interpolação de String
  • Suporte para nameof
  • Declarações de tipo aberto
  • Fatiamento aprimorado
  • Melhorias nas cotações do F#
  • Expressões de Computação Aplicativa
  • Traços de pilha aprimorados em F# assíncrono e outras expressões de computação
  • Interoperabilidade .NET aprimorada
  • Melhor desempenho de mapa e conjunto no FSharp.Core
  • Melhor desempenho do compilador
  • Análise de compilador aprimorada para autores de bibliotecas
F# 6.0 [40]
  • Tarefas
  • Indexação mais simples
  • Aumenta para "padrões ativos"
  • Operações personalizadas sobrecarregadas em expressões de computação
  • padrões “como”
  • Revisões de sintaxe de recuo
  • Conversões implícitas adicionais
  • Conversões upcast implícitas adicionais
  • Conversões de inteiro implícitas
  • 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 vinculações de uso
  • Diretiva do otimizador InlineIfLambda
  • Código recuperável
  • Funções de coleção adicionais
  • O mapa tem chaves e valores
  • Intrínsecos adicionais para NativePtr
  • Tipos numéricos adicionais com anotações de unidade
  • Avisos informativos para operadores simbólicos raramente usados

Visão geral do idioma

Programação funcional

Apesar de oferecer suporte a recursos orientados a objetos disponíveis em C#, o F# é uma linguagem de primeira função fortemente tipada com um grande número de recursos que normalmente são encontrados apenas em linguagens de programação funcionais . 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 recursos funcionais são:

F# é uma linguagem baseada em expressão que usa avaliação ansiosa e também, em alguns casos , avaliação preguiçosa . Cada instrução em F#, incluindo ifexpressões, tryexpressões e loops, é uma expressão que pode ser composta com um tipo estático. [43] Funções e expressões que não retornam nenhum valor têm um tipo de retorno de unit. F# usa a palavra- letchave para vincular valores a um nome. [43] Por exemplo:

seja  x  =  3  +  4

vincula o valor 7ao nome x.

Novos tipos são definidos usando a palavra- typechave. Para programação funcional, o F# fornece os tipos tuple , record , discriminated union , list , option e result . [43] Uma tupla representa um conjunto de n valores, onde n ≥ 0. O valor n é chamado de aridade da tupla. Uma tupla de 3 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 em que 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 denominado ). let r = { Name="AB"; Age=42 }with{ 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

Os valores do tipo de união podem corresponder a qualquer caso de união. Os tipos de valores transportados por cada caso de união estã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 opções ou . Os tipos F# podem ser genéricos , implementados como tipos .NET genéricos. head::tail::[item1; item2; item3][]Some(x)None

F# dá suporte a funções e encerramentos lambda . [43] Todas as funções em F# são valores de primeira classe e são imutáveis. [43] As funções podem ser curry . Sendo valores de primeira classe, as funções podem ser passadas como argumentos para outras funções. Assim como outras linguagens de programação funcional, o F# permite a composição de funções (ciência da computação) usando os operadores e .>><<

F# forneceexpressões de sequência [44] 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 os números do intervalo de números de 0 a 25. As sequências são geradoras – os valores são gerados sob demanda (ou seja, são avaliados preguiçosamente ) – enquanto as listas e matrizes são avaliadas avidamente .

O F# usa a 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 é o valor correspondido em relação às regras de padrão 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. [45] É usado, por exemplo, quando existem várias formas de correspondência em um tipo. [43]

O F# oferece suporte a uma sintaxe geral para definir cálculos de composição 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. As expressões de computação são uma implementação dopadrãomônada[44]

Programação imperativa

O suporte a F# para programação imperativa inclui

Valores e campos de registro também podem ser rotulados como mutable. Por exemplo:

// Define 'x' com valor inicial '1' 
let  mutable  x  =  1 
// Muda o valor de 'x' para '3' 
x  <-  3

Além disso, o F# oferece suporte ao acesso a todos os tipos e objetos da CLI, como aqueles definidos no System.Collections.Genericnamespace que define as estruturas de dados imperativas.

Programação orientada a objetos

Como outras linguagens de Common Language Infrastructure (CLI), o F# pode usar tipos de CLI por meio de programação orientada a objetos. [43] O suporte do 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 [45]

As definições de tipo de objeto do F# podem ser definições de classe, struct, interface, enum ou de tipo delegado, 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.

/// Um ​​tipo de definição de tipo de objeto 
simples  Person ( name  :  string ,  age  :  int )  = 
    member  x . Nome  =  nome 
    do membro  x . Idade  =  idade

Programação assíncrona

O F# oferece suporte à programação assíncrona por meio de fluxos de trabalho assíncronos . [46] Um fluxo de trabalho assíncrono é definido como uma sequência de comandos dentro de um async{ ... }, como em

let  asynctask  =  
    async  {  let  req  =  WebRequest . Criar ( url ) 
            vamos!  resposta  =  req . GetResponseAsync () 
            use  stream  =  response . GetResponseStream () 
            use  streamreader  =  new  System . IO . StreamReader ( stream ) 
            retorna  streamreader . ReadToEnd ()  }

O let!indica que a expressão à direita (obtendo 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 receber a resposta fosse uma chamada de bloqueio, enquanto do ponto de vista do sistema, a thread não será bloqueada e poderá ser usada para processar outros fluxos enquanto o resultado necessário para este não se torna disponível.

O bloco assíncrono pode ser invocado usando a Async.RunSynchronouslyfunção. Vários blocos assíncronos podem ser executados em paralelo usando a Async.Parallelfunção que pega uma lista de asyncobjetos (no exemplo, asynctaské um objeto assíncrono) e cria outro objeto assíncrono para executar as tarefas nas listas em paralelo. O objeto resultante é invocado usando Async.RunSynchronously. [46] A inversão de controle em F# segue este padrão. [46]

Programação paralela

A programação paralela é suportada parcialmente por meio do Async.Parallel, Async.Starte outras operações que executam blocos assíncronos em paralelo.

A programação paralela também é suportada através dos Array.Paralleloperadores de programação funcional na biblioteca padrão do F#, uso direto do System.Threading.Tasksmodelo de programação de tarefas, uso direto do pool de threads .NET e threads .NET e através da tradução dinâmica do código F# para mecanismos alternativos de execução paralela, como Código GPU [9] .

Unidades de medida

O sistema de tipo F# oferece suporte a unidades de medida para verificação de números. [47] O recurso de unidades de medida se integra à inferência de tipo F# para exigir anotações de tipo mínimas no código do usuário. [48]

Metaprogramação

O F# permite algumas formas de personalização de sintaxe por meio de metaprogramação para dar suporte à incorporação de linguagens específicas de domínio personalizadas na linguagem F#, principalmente por meio de expressões de computação. [43]

O F# inclui um recurso para metaprogramação em tempo de execução chamado cotações. [49] Uma expressão de cotação é avaliada como uma representação de árvore de sintaxe abstrata das expressões F#. Da mesma forma, as definições rotuladas com o [<ReflectedDefinition>]atributo também podem ser acessadas em sua forma de cotação. As citações em F# são usadas para vários propósitos, inclusive para compilar código F# em código JavaScript [8] e GPU [9] . (As citações representam suas expressões de código F# como dados para uso por outras partes do programa, exigindo 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 tipo extensível estaticamente chamada de provedores de tipo F#. [50] Os provedores de tipo F# permitem que o compilador e as ferramentas do F# sejam estendidos com componentes que fornecem informações de tipo ao compilador sob demanda em tempo de compilação. Os provedores de tipo F# têm sido usados ​​para fornecer acesso fortemente tipado a fontes de informações conectadas de maneira escalável, incluindo o gráfico de conhecimento do Freebase . [51]

No F# 3.0, os recursos de expressão de cálculo e cotação do F# são combinados para implementar consultas LINQ . [52] 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

type  Northwind  =  ODataService < "http://services.odata.org/Northwind/Northwind.svc" > 
deixe  db  =  Northwind . GetDataContext ()

// Uma expressão de consulta. 
deixe  query1  =  query  {  for  customer  in  db . Os clientes  selecionam o 
                     cliente }  

A combinação de provedores de tipo, consultas e programação funcional fortemente tipada é conhecida como programação rica em informações . [53]

Programação de agentes

O F# dá suporte a uma variação do modelo de programação Actor por meio da implementação na memória de agentes assíncronos leves. Por exemplo, o código a seguir define um agente e publica 2 mensagens:

let  counter  = 
    MailboxProcessor . Start ( fun  inbox  -> 
        let  rec  loop  n  = 
            async  {  do  printfn  "n = %d, esperando..."  n 
                    let!  msg  =  inbox . Receive () 
                    return !  loop ( n + msg )  } 
        loop  0 )

Ferramentas de desenvolvimento

  • O Visual Studio , com as ferramentas Visual F# da Microsoft instaladas, pode ser usado para criar, executar e depurar projetos em F#. As ferramentas do Visual F# incluem um console interativo REPL ( read-eval-print loop ) hospedado no Visual Studio que pode executar o 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 completo para F# por meio da extensão Ionide .
  • F# pode ser desenvolvido com qualquer editor de texto. Existe suporte específico em editores como o Emacs .
  • O JetBrains Rider é otimizado para o desenvolvimento do código F# a partir da versão 2019.1. [54]
  • O LINQPad oferece suporte a F# desde a versão 2.x. [ de quem? ]

Áreas de aplicação

F# é uma linguagem de programação de uso 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. [55]

Uma opção F# de ponta a ponta alternativa é a estrutura WebSharper . [56]

Desenvolvimento de aplicativos multiplataforma

O F# pode ser usado junto com as Ferramentas do Visual Studio para Xamarin para desenvolver aplicativos para iOS e Android . A biblioteca Fabulous oferece uma interface funcional mais confortável.

Programação analítica

Entre outros, o F# é usado para programação financeira quantitativa, [57] negociação de energia e otimização de portfólio, [58] aprendizado de máquina, [59] inteligência de negócios [60] e jogos sociais no Facebook . [61]

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. [62]

Scripts

F# pode ser usado como uma linguagem de script, principalmente para scripts REPL ( read-eval-print loop ) de desktop. [63]

Comunidade de código aberto

A comunidade de código aberto do F# inclui a F# Software Foundation [10] e o F# Open Source Group no GitHub . [11] Projetos populares em F# de código aberto incluem:

  • Fable , um transpilador de F# para Javascript baseado em 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 compilação amigável ao F#.
  • Giraffe , um middleware funcionalmente orientado para ASP.NET Core .
  • Suave , um servidor web leve e uma biblioteca de desenvolvimento 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 algumas pequenas amostras:

// Este é um comentário para um exemplo de programa hello world. 
printfn  "Olá Mundo!"

Uma classe Person com um construtor que recebe um nome e uma idade e duas propriedades imutáveis.

/// Este é um comentário de documentação para uma definição de tipo. 
tipo  Pessoa ( nome  :  string ,  idade  :  int )  = 
    membro  x . Nome  =  nome 
    do membro  x . Idade  =  idade
    
/// 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 mostrado em F#:

/// Usando a expressão de correspondência de padrões 
deixe  rec  fatorial  n  = 
    corresponder  n  com 
    |  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  fatorial  =  function  
    |  0  ->  1  
    |  n  ->  n  *  fatorial  ( n  -  1 )
    
/// Usando o operador fold e range 
deixe  fatorial  n  =  [ 1 .. n ]  |>  Seq . dobra  (*)  1

Exemplos de iteração:

/// Iteração usando um loop 'for' 
let  printList lst  =  for  
    x  in  lst  do printfn " %  d" 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 
let  fib  n  = 
    let  rec  g  n  f0  f1  = 
        combinar  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 
deixe  fibSeq  =  Seq . desdobrar  ( fun  ( a , b )  ->  Some ( a + b ,  ( b ,  a + b )))  ( 0 , 1 )

// Imprime mesmo fibs 
[ 1  ..  10 ] 
|>  List . mapa      fib 
|>  Lista . filter   ( fun  n  ->  ( n  %  2 )  =  0 ) 
|>  printList


// Mesma coisa , usando uma expressão de lista [  for  i  in  1 .. 10  let 
    r = fib i if r % 2 = 0 then yield r ] |> printList    
             
 

Um exemplo de programa Windows Forms:

// Abra a biblioteca Windows Forms 
open  System.Windows.Forms

// Cria uma janela e define algumas propriedades 
let  form  =  new  Form ( Visible = true ,  TopMost = true ,  Text = "Welcome to F#" )

// Cria um rótulo para mostrar algum texto no formulário 
let  label  = 
    let  x  =  3  +  ( 4  *  5 ) 
    new  Label ( Text  =  $ "{x}" )

// Adiciona o rótulo ao formulário de 
formulário . Controles . Adicionar ( etiqueta )

// Finalmente, execute o formulário 
[< System . STAThread >] 
Aplicação . Executar ( formulário )

Exemplo de programação paralela assíncrona (tarefas de CPU e E/S paralelas):

/// Um ​​detector de número primo simples 
let  isPrime  ( n : int )  = 
   let  bound  =  int  ( sqrt  ( float  n )) 
   seq  { 2  ..  bound }  |>  Seq . forall  ( diversão  x  ->  n  %  x  <>  0 )

// Estamos usando fluxos de trabalho assíncronos 
let  primeAsync  n  = 
    async  {  return  ( n ,  isPrime  n )  }

/// Retorna primos entre me n usando vários threads 
let  primos  m  n  = 
    seq  { m  ..  n } 
        |>  Seq . map  primeAsync 
        |>  Async . Paralelo 
        |>  Assíncrono . ExecutarSincronicamente 
        |>  Matriz . filtro  snd 
        |>  Matriz . mapa  fst

// Executar um teste 
primes  1000000  1002000 
    |>  Array . iter  ( printfn  "%d" )

Veja também

Notas

  1. ^ https://devblogs.microsoft.com/dotnet/announcing-net-6/ .
  2. ^ "Licença da F# Software Foundation" . GitHub . 14 de outubro de 2021.
  3. ^ "Licença F# da Microsoft" . GitHub . 16 de outubro de 2021.
  4. ^ a b Syme, Granicz & Cisternino (2007 : 2)
  5. ^ a b c d e "F# Reconhecimentos Históricos" . Recuperado em 24/11/2012 .
  6. ^ a b Syme, Don (2006). "Aproveitando os Componentes de Meta-programação .NET do F#" . [F#] está enraizado no design Core ML e, em particular, possui uma linguagem central amplamente compatível com a do OCaml
  7. ^ para assíncrono
  8. ^ a b c d e f g h i j The F# Software Foundation. "Usando F# para aplicativos da Web" . Recuperado 2020-07-30 .
  9. ^ a b c d e f g h i j k The F# Software Foundation. "Usando F# para programação de GPU" . Arquivado a partir do original em 25/12/2019 . Recuperado 2019-12-25 .
  10. ^ a b c A Fundação de Software de F#. "A Fundação de Software F#" . Recuperado em 24/11/2012 .
  11. ^ a b A Fundação de Software de F#. "F# Compiler (edição de código aberto) @ github" . Recuperado em 24/11/2012 .
  12. ^ "Desenvolva com o Visual F# no Visual Studio" . Recuperado 2020-07-30 .
  13. ^ "F#" . Recuperado 2020-07-30 .
  14. ^ Sime, Don. "F# 1.0.8 lançado" . Microsoft . Recuperado em 7 de setembro de 2014 .
  15. ^ Sime, Don. "F# 2.0 lançado como parte do Visual Studio 2010" . Microsoft . Recuperado em 7 de setembro de 2014 .
  16. ^ Zander, Jason. "Visual Studio 2012 e .NET Framework 4.5 lançados na web" . Microsoft . Recuperado em 7 de setembro de 2014 .
  17. ^ "Visual Studio 2013 lançado para web" . Microsoft . Recuperado em 7 de setembro de 2014 .
  18. ^ "Anunciando o RTM do Visual F# 4.0" . Microsoft . Recuperado em 15 de setembro de 2015 .
  19. ^ "Anunciando o F# 4.1 e as Ferramentas do Visual F# para Visual Studio 2017" . Recuperado 2017-03-08 .
  20. ^ "Anunciando F# 4.5" . Microsoft. 14 de agosto de 2018 . Recuperado em 14 de agosto de 2018 .
  21. ^ "FSharp.Core 4.5.0" .
  22. ^ "Baixar .NET Core 2.1 (Linux, macOS e Windows)" . Microsoft . Recuperado em 13 de maio de 2021 .
  23. ^ "Anunciando F# 4.6" . Microsoft. 29 de março de 2019 . Recuperado em 29 de março de 2019 .
  24. ^ "FSharp.Core 4.6.0" .
  25. ^ "Baixar .NET Core 2.2 (Linux, macOS e Windows)" . Microsoft . Recuperado em 13 de maio de 2021 .
  26. ^ "Anunciando F# 4.7" . Microsoft. 23 de setembro de 2019 . Recuperado em 23 de setembro de 2019 .
  27. ^ "FSharp.Core 4.7.0" .
  28. ^ "Baixar .NET Core 3.0 (Linux, macOS e Windows)" . Microsoft . Recuperado em 13 de maio de 2021 .
  29. ^ a b "Anunciando F# 5" . 10 de novembro de 2020.
  30. ^ "Baixar .NET 5.0 (Linux, macOS e Windows)" . Microsoft . Recuperado em 13 de maio de 2021 .
  31. ^ "F# 6 está oficialmente aqui!" . 9 de novembro de 2021.
  32. ^ "Baixar .NET 6.0 (Linux, macOS e Windows)" . Microsoft . Recuperado em 14 de novembro de 2021 .
  33. ^ Edwards, Kathryn (23 de dezembro de 2008). "A AZ das linguagens de programação: F#" . networkworld . com . IDG. Arquivado a partir do original em 13 de novembro de 2018 . Recuperado em 8 de agosto de 2016 .
  34. ^ McNamara, Brian. "Mais sobre os recursos de linguagem do F# 3.0" . Microsoft . Recuperado em 7 de setembro de 2014 .
  35. ^ McNamara, Brian. "Anunciando um pré-lançamento do F# 3.1" . Microsoft . Recuperado em 7 de setembro de 2014 .
  36. ^ "Anunciando o RTM do Visual F# 4.0" . Recuperado 2017-03-08 .
  37. ^ "Anunciando o F# 4.1 e as Ferramentas do Visual F# para Visual Studio 2017" . Recuperado 2017-03-08 .
  38. ^ "Anunciando F# 4.7" . 23 de setembro de 2019.
  39. ^ "Anunciando F# 5" . 10 de novembro de 2020.
  40. ^ "O que há de novo em F# 6 - Guia F#" .
  41. ^ "F Sharp Programação/Expressões de Computação - Wikibooks, livros abertos para um mundo aberto" . en.wikibooks.org . Recuperado 2022-01-21 .
  42. ^ kexgit. "Chamadas de cauda em F#" . docs.microsoft . com . Recuperado 2022-04-22 .
  43. ^ a b c d e f g h "F# Language Overview" (PDF) . Recuperado em 2007-12-14 .
  44. ^ a b "Alguns detalhes sobre expressões de computação F#" . Recuperado em 2007-12-14 .
  45. ^ a b "Correspondência de padrões em F# Parte 2: Padrões ativos" . Arquivado a partir do original em 2012-12-09 . Recuperado em 24/11/2012 .
  46. ^ a b c "Introduzindo fluxos de trabalho assíncronos de F#" . Recuperado em 2007-12-14 .
  47. ^ "Unidades de Medida (F#)" . Recuperado em 24/11/2012 .
  48. ^ "Unidades de Medida em F#: Parte Um, Introduzindo Unidades" . Recuperado em 24/11/2012 .
  49. ^ "Cotações de código (F #)" . Recuperado em 24/11/2012 .
  50. ^ "Fornecedores de tipo" . Recuperado em 24/11/2012 .
  51. ^ "Relatório de tecnologia novo da Microsoft Research: Suporte de idioma fortemente tipado para fontes de informação em escala de Internet" . Recuperado em 24/11/2012 .
  52. ^ "Expressões de consulta (F#)" . Recuperado em 24/11/2012 .
  53. ^ "F# 3.0 – LINQ + Provedores de tipo = Programação rica em informações" . Recuperado em 24/11/2012 .
  54. ^ Alexandre Kurakin. "Rider 2019.1 inicia seu programa de acesso antecipado!" .
  55. ^ "Fable: JavaScript que você pode se orgulhar!" . fábula.io . Recuperado 2017-12-09 .
  56. ^ Intelifactory. "Casa WebSharper" . Recuperado em 24/11/2012 .
  57. ^ "Estudos de caso da Microsoft: Microsoft Visual Studio 2012 - Empresa de serviços financeiros" . Microsoft . Recuperado em 25/11/2012 .
  58. ^ "F# para negociação de energia e otimização de portfólio" . Recuperado em 25/11/2012 .
  59. ^ "Estudo de caso da Microsoft: Seguro Grange" . Microsoft . Recuperado em 25/11/2012 .
  60. ^ Trelford, Phil (2007). "Aprendendo com F#" . Actas do 4 º workshop ACM SIGPLAN sobre Utilizadores Comerciais de Programação Funcional - CUFP '07 . Copa '07. págs. 1–2. doi : 10.1145/1362702.1362709 . ISBN 9781450378444. S2CID  24018363 . Recuperado em 25/11/2012 .
  61. ^ "F# Job no Facebook Social Gaming" . Recuperado em 25/11/2012 .
  62. ^ "Depoimentos de desenvolvedores F#" . Recuperado em 25 de maio de 2021 .
  63. ^ "Script em F#" . Recuperado 2020-01-17 .

Referências

  • Syme, Don ; Granicz, Adam; Cisternino, Antonio (2007), Expert F# , Apress
  • Harrop, Jon (2010), Visual F# 2010 for Technical Computing , Flying Frog Consultancy
  • Pickering, Robert (2007), Fundamentos de 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# for Quantitative Finance , Packt Publishing
  • Lundin, Mikael (2015), Testando com F# , Packt Publishing

Links externos