Referência de linguagem do F#

Esta seção é uma referência para a linguagem de F#, um direcionamento de linguagem programação multi-paradigm o.NET da Microsoft. A linguagem F# oferece suporte a modelos de programação funcionais, orientada a objeto e imperativos.

Tokens de F#

A tabela a seguir mostra os tópicos de referência que fornecem as tabelas de palavras-chave, símbolos e literais usados como tokens em F#.

Título	Descrição
Referência de palavra-chave (F#)	Contém links para informações sobre palavras-todos os F# chave.
Símbolo e o referência de operador (F#)	Contém uma tabela de símbolos e operadores são usados no idioma F#.
Literais (F#)	Descreve a sintaxe para valores literais em F# e como especificar o tipo de informações para F# literais.

Conceitos da linguagem do F#

A tabela a seguir mostra os tópicos de referência disponíveis que descrevem os conceitos da linguagem.

Título	Descrição
Funções (F#)	Funções são a unidade fundamental da execução do programa em qualquer linguagem de programação. Como em outros idiomas, uma função F# tem um nome pode ter parâmetros e levar argumentos e tem um corpo. F# também suporta construções de programação funcionais como, por exemplo, tratando de funções como valores, usando funções sem nome em expressões, composição de funções para formar novas funções, funções curried e a definição implícita de funções por meio do aplicativo parcial dos argumentos da função.
Tipos de F#	Descreve os tipos que são usados em F# e como os tipos de F# são nomeados e descritos.
Inferência de tipo (F#)	Descreve como o compilador F# infere os tipos de valores, variáveis, parâmetros e valores de retorno.
Generalização automática (F#)	Descreve as construções genéricas em F#.
Herança (F#)	Descreve a herança, que é usada para o modelo de "é-um" relação de formação de subtipos, na programação orientada a objeto.
Membros (F#)	Descreve os membros de tipos de objeto F#.
Parâmetros e argumentos (F#)	Descreve o suporte de linguagem para definição de parâmetros e passar argumentos para funções, métodos e propriedades. Ele inclui informações sobre como passar por referência.
Operador de sobrecarga (F#)	Descreve como sobrecarregar operadores aritméticos em uma classe ou um tipo de registro e no nível global.
Elenco e conversões (F#)	Descreve o suporte para conversões de tipo em F#.
Controle de acesso (F#)	Descreve o controle de acesso em F#. Controle de acesso significa declarando que os clientes são capazes de usar determinados elementos do programa, como, por exemplo, tipos, métodos, funções e assim por diante.
Padrões correspondentes (F#)	Descreve os padrões, que são regras para transformar os dados de entrada são usados em todo o idioma F# para extrair dados de comparar com um padrão, decompõem a dados em partes constituintes ou extrair informações de dados de várias maneiras.
Padrões de ativos (F#)	Descreve os padrões de ativos. Active padrões permitem definir partições nomeadas que subdividir os dados de entrada. Você pode usar padrões de ativos para decompor os dados de maneira personalizada para cada partição.
Declarações (F#)	Descreve o assert a expressão, que é um recurso de depuração, você pode usar para testar uma expressão. Em caso de falha no modo de depuração, uma declaração gera uma caixa de diálogo de erro do sistema.
Exceção de tratamento (F#)	Contém informações sobre suporte no idioma F# de manipulação de exceção.
Atributos (F#)	Descreve os atributos, que permitem que os metadados a serem aplicadas a uma construção de programação.
Gerenciamento de recursos: O uso de palavra-chave (F#)	Descreve as palavras-chave use e using, que pode controlar a inicialização e a liberação de recursos
Espaços para nome (F#)	Descreve o suporte de namespace em F#. Um espaço para nome lhe permite organizar o código em áreas de funcionalidade relacionada, permitindo que você anexe um nome a um agrupamento de elementos do programa.
Módulos (F#)	Descreve os módulos. Um módulo do F# é um agrupamento de F# código, como, por exemplo, valores, tipos e valores de função, em um programa F#. Agrupar os códigos em módulos ajuda a manter o código relacionado e ajuda a evitar conflitos de nome no seu programa.
Declarações de importação: A palavra-chave aberta (F#)	Descreve como open works. Uma declaração de importação Especifica um namespace cujos elementos que você pode referenciar sem usar um nome totalmente qualificado ou um módulo.
Assinaturas (F#)	Descreve os arquivos de assinatura e assinaturas. Um arquivo de assinatura contém informações sobre as assinaturas públicas de um conjunto de F# elementos do programa, como, por exemplo, tipos, namespaces e módulos. Ele pode ser usado para especificar a acessibilidade desses elementos de programa.
Documentação XML (F#)	Descreve o suporte para gerar arquivos de documentação para comentários doc XML, os comentários também conhecido como tripla de barra. Você pode produzir documentação de comentários de código em F#, assim como nos outros.NET idiomas.
Sintaxe muito detalhada (F#)	Descreve a sintaxe para construções de F# quando leve sintaxe não está habilitado. A sintaxe detalhada é indicada pela #light "off" diretiva na parte superior do arquivo de código.

Tipos de F#

A tabela a seguir mostra os tópicos de referência disponíveis que descrevem os tipos suportados pelo idioma F#.

Título	Descrição
Valores (F#)	Descreve os valores, que são imutáveis quantidades que têm um tipo específico; valores podem ser os números integral ou de ponto flutuante, caracteres ou texto, listas, seqüências, matrizes, tuplas, uniões discriminadas, registros, tipos de classe ou valores de função.
Tipos primitivos (F#)	Descreve os tipos primitivos fundamentais que são usados no idioma F#. Ele também fornece o correspondente.NET e os valores mínimos e máximo para cada tipo.
Tipo de unidade (F#)	Descreve o unit o tipo, que é um tipo que indica a ausência de um valor específico; o unit o tipo tem apenas um único valor, que atua como um espaço reservado quando nenhum outro valor existe ou é necessária.
Seqüências de caracteres (F#)	Descreve as seqüências de caracteres em F#. O string tipo representa texto imutável, como uma seqüência de caracteres do Unicode. stringé um alias para String na.NET Framework.
Tuplas (F#)	Descreve tuplas, que são agrupamentos de valores sem nome mas ordenados, possivelmente de diferentes tipos.
Listas (F#)	Descreve as listas. Uma lista no F# é uma série ordenada e imutável, de elementos todos do mesmo tipo.
Opções (F#)	Descreve o tipo de opção. Uma opção F# é usada quando um valor pode ou não existir. Uma opção tem um tipo subjacente e qualquer um pode armazenar valores desse tipo ou não tenha um valor.
Seqüências (F#)	Descreve as seqüências. Uma seqüência é uma série de lógica de elementos todos de um tipo. Elementos individuais de seqüência são calculados somente se necessário, para que a representação pode ser menor que a contagem de uma elemento literal indica.
Matrizes (F#)	Descreve as matrizes. Arrays são seqüências de tamanho fixo, com base em zero, mutáveis de elementos de dados consecutivos, todos do mesmo tipo.
Registros (F#)	Descreve os registros. Registros representam agregações simples de valores nomeados, opcionalmente com membros.
Uniões discriminadas (F#)	Descreve o uniões discriminadas, que fornece suporte para valores que podem ser um dos inúmeros casos nomeados, cada um com tipos e valores possivelmente diferentes.
Enumerações (F#)	Descreve as enumerações são tipos que possuem um conjunto definido de valores nomeados. Você pode usá-los no lugar de literais para tornar o código mais legível e fácil manutenção.
Células de referência (F#)	Descreve as células de referência, que são locais de armazenamento que permitem criar variáveis mutáveis com a semântica de referência.
Abreviações de tipo (F#)	Descreve as abreviações de tipo, que são nomes alternativos para os tipos.
Classes (F#)	Descreve as classes, que são os tipos que representam os objetos que podem ter propriedades, métodos e eventos.
Estruturas (F#)	Descreve as estruturas, quais são os tipos de objeto compacto que podem ser mais eficientes do que uma classe para tipos que possuem uma pequena quantidade de dados e o comportamento simples.
Interfaces (F#)	Descreve interfaces, que especificam conjuntos de membros relacionados que implementam a outras classes.
Classes abstratas (F#)	Descreve as classes abstratas, que são classes que deixar alguns ou todos os membros que não implementados, para que as implementações podem ser fornecidas pelas classes derivadas.
Extensões de tipo (F#)	Descreve as extensões de tipos, que permitem que você adicionar novos membros a um tipo de objeto definido anteriormente.
Tipos flexíveis (F#)	Descreve tipos flexíveis. Uma anotação de tipo flexível é uma indicação de que um parâmetro, variável ou o valor tem um tipo que é compatível com o tipo especificado, onde a compatibilidade é determinada pela posição na hierarquia de orientada a objeto de classes ou interfaces.
Delegados (F#)	Descreve os delegados, que representam uma chamada de função como um objeto.
Unidades de medida (F#)	Descreve as unidades de medida. Flutuante valores de ponto de F# pode ter associados unidades de medida, que geralmente são usadas para indicar o comprimento, volume, em massa e assim por diante.

Expressões de F#

A tabela a seguir lista os tópicos que descrevem as expressões F#.

Título	Descrição
Expressões condicionais: IF... em seguida,... else (F#)	Descreve o if...then...else a expressão, que executa a diferentes ramificações do código e também é avaliada como um valor diferente, dependendo da expressão booleana fornecido.
Corresponder expressões (F#)	Descreve o match a expressão, que fornece controle de ramificação que se baseia a comparação de uma expressão com um conjunto de padrões.
Loops: loop for... a expressão (F#)	Descreve o for...to a expressão, que é usado para iterar em um loop através de um intervalo de valores de uma variável de loop.
Loops: loop for... na expressão (F#)	Descreve o for...in expressão, uma construção de loop que é usada para iterar sobre as correspondências de um padrão de uma coleção enumerável, como uma expressão de intervalo, seqüência, lista, matriz ou outra construção que oferece suporte à enumeração.
Loops: While... fazer expressão (F#)	Descreve o while...do a expressão, que é usado para realizar execução de iterativa (loop), enquanto uma condição de teste especificada for verdadeira.
Expressões de objeto (F#)	Descreve as expressões de objeto, o que são expressões que criar novas instâncias de um tipo de objeto criado dinamicamente e anônimo que se baseia em um tipo de base existente, uma interface ou um conjunto de interfaces.
Computações lentas (F#)	Descreve as computações lentas, o que são cálculos que não são avaliados imediatamente, mas em vez disso, são avaliados quando o resultado for realmente necessário.
Expressões de computação (F#)	Descreve as expressões de computação em F#, que fornecem uma sintaxe conveniente para escrever as computações que podem ser seqüenciadas e combinados usando construções de fluxo de controle e ligações. Eles podem ser usados para fornecer uma sintaxe conveniente para mônadas, um recurso de programação funcional que pode ser usado para gerenciar dados, controle e os efeitos colaterais em programas funcionais. Um tipo de expressão de cálculo, o fluxo de trabalho assíncrono, oferece suporte para computações assíncronas e paralelas. Para obter mais informações, consulte Fluxos de trabalho assíncronos (F#).
Fluxos de trabalho assíncronos (F#)	Descreve um recurso de linguagem que permite que você escreva código assíncrono de forma que está muito próxima da maneira você naturalmente escreveria código síncrono de fluxos de trabalho assíncronos.
Cotações de código (F#)	Descreve a cotações do código, um recurso de linguagem que permite gerar e trabalhar com expressões de código F# programaticamente.

Construções de suporte do compilador

A tabela a seguir lista os tópicos que descrevem as construções de suporte a compilador especiais.

Tópico	Descrição
Diretivas de compilador (F#)	Descreve as diretivas de processador e diretivas de compilador.
Linha de código-fonte, arquivos e identificadores de caminho (F#)	Descreve os identificadores de __LINE__, __SOURCE_DIRECTORY__ e __SOURCE_FILE__, que são valores internos que permitem que você acessar o número da linha de origem, o diretório e nome de arquivo no seu código.

Consulte também

Outros recursos

Visual F#

F# (FSC. exe) referência de compilador