Referência de palavra-chave (F#)

Este tópico contém links para informações sobre palavras-todos os F# chave.

Tabela de palavra-chave F#

A tabela a seguir mostra todos os F# palavras-chave em ordem alfabética, juntamente com breves descrições e links para tópicos relevantes que contêm mais informações.

Keyword	Link	Descrição
abstract	Membros (F#) Classes abstratas (F#)	Indica um método que não tem nenhuma implementação do tipo no qual é declarada ou que é virtual e tem uma implementação do padrão.
and	Deixe as ligações (F#) Membros (F#) Restrições (F#)	Usado em mutuamente recursiva ligações, em declarações de propriedade e com várias restrições sobre parâmetros genéricos.
as	Classes (F#) Padrões correspondentes (F#)	Usado para dar um nome de objeto de objeto de classe atual. Também é usado para dar um nome a um padrão de todo dentro de uma correspondência de padrão.
assert	Declarações (F#)	Usado para verificar o código durante a depuração.
base	Classes (F#) Herança (F#)	Usado como o nome do objeto de classe base.
begin	Sintaxe muito detalhada (F#)	Na sintaxe detalhada, indica o início de um bloco de código.
class	Classes (F#)	Na sintaxe detalhada, indica o início de uma definição de classe.
default	Membros (F#)	Indica uma implementação de um método abstrato; usado junto com uma declaração de método abstrato para criar um método virtual.
delegate	Delegados (F#)	Usado para declarar um delegado.
do	fazer ligações (F#) Loops: loop for... a expressão (F#) Loops: loop for... na expressão (F#) Loops: While... fazer expressão (F#)	Usado em construções de loop ou executar código imperativo.
done	Sintaxe muito detalhada (F#)	Na sintaxe detalhada, indica o final de um bloco de código em uma expressão de repetição.
downcast	Elenco e conversões (F#)	Usado para converter um tipo que é o mais baixo na cadeia de herança.
downto	Loops: loop for... a expressão (F#)	Em um for a expressão, usada quando a contagem em ordem inversa.
elif	Expressões condicionais: IF... em seguida,... else (F#)	Usada na ramificação condicional. Uma forma abreviada da else if.
else	Expressões condicionais: IF... em seguida,... else (F#)	Usada na ramificação condicional.
end	Estruturas (F#) Uniões discriminadas (F#) Registros (F#) Extensões de tipo (F#) Sintaxe muito detalhada (F#)	Definições de tipo e extensões de tipo, indica o final de uma seção de definições de membro. Na sintaxe detalhada, usado para especificar o final de um bloco de código que inicia com a begin palavra-chave.
exception	Exceção de tratamento (F#) Tipos de exceções (F#)	Usado para declarar um tipo de exceção.
extern	Funções externas (F#)	Indica que um elemento declarado do programa é definido em outro assembly ou binário.
false	Tipos primitivos (F#)	Usado como um booleano literal.
finally	Exceções: O bloco try... finalmente expressão (F#)	Usado junto com try para apresentar um bloco de código que é executado independentemente, por exemplo, se uma exceção ocorrerá.
for	Loops: loop for... a expressão (F#) Loops: loop for... na expressão (F#)	Usado em construções de loop.
fun	Expressões lambda: A diversão de palavra-chave (F#)	Usado em expressões lambda, também conhecido como anônimas funções.
function	Corresponder expressões (F#) Expressões lambda: A diversão de palavra-chave (F#)	Usado como uma alternativa mais curta para o fun palavra-chave e um match a expressão em uma expressão lambda que tem de padrões coincidentes em um único argumento.
global	Espaços para nome (F#)	Usado para referência de nível superior.NET namespace.
if	Expressões condicionais: IF... em seguida,... else (F#)	Usado em construções de ramificação condicionais.
in	Loops: loop for... na expressão (F#) Sintaxe muito detalhada (F#)	Usado para expressões de seqüência e, em uma sintaxe muito detalhada, para separar expressões de ligações.
inherit	Herança (F#)	Usado para especificar uma classe base ou interface base.
inline	Funções (F#) Funções embutidas (F#)	Usado para indicar uma função que deve ser integrada diretamente no código do chamador.
interface	Interfaces (F#)	Usado para declarar e implementar interfaces.
internal	Controle de acesso (F#)	Usado para especificar que um membro é visível dentro de um assembly, mas não fora dela.
lazy	Computações lentas (F#)	Usado para especificar um cálculo que deve ser executada somente quando é necessário um resultado.
let	Deixe as ligações (F#)	Usado para associar ou vincular, um nome de um valor ou uma função.
match	Corresponder expressões (F#)	Usado para a filial, comparando o valor de um padrão.
member	Membros (F#)	Usado para declarar uma propriedade ou método em um tipo de objeto.
module	Módulos (F#)	Usado para associar um nome de um grupo de tipos relacionados, valores e funções, separar logicamente a partir de outro código.
mutable	Deixe as ligações (F#)	Usado para declarar uma variável, ou seja, um valor que pode ser alterado.
namespace	Espaços para nome (F#)	Usado para associar um nome de um grupo de tipos relacionados e módulos, separar logicamente a partir de outro código.
new	Construtores (F#) Restrições (F#)	Usado para declarar, definir ou chamar um construtor que cria ou que pode criar um objeto. Também usado nas restrições de parâmetro genérico para indicar que um tipo deve ter um construtor determinados.
not	Símbolo e o referência de operador (F#) Restrições (F#)	Não é realmente uma palavra-chave. No entanto, not struct em combinação, é usado como uma restrição de parâmetro genérico.
null	Valores nulos (F#) Restrições (F#)	Indica a ausência de um objeto. Também é usado nas restrições de parâmetro genérico.
of	Uniões discriminadas (F#) Delegados (F#) Tipos de exceções (F#)	Usado em uniões discriminadas para indicar o tipo de categorias de valores e nas declarações de delegado e a exceção.
open	Declarações de importação: A palavra-chave aberta (F#)	Usado para disponibilizar o conteúdo de um namespace ou o módulo sem qualificação.
or	Símbolo e o referência de operador (F#) Restrições (F#)	Usado com condições booleanas como um valor booleano or operador. Equivalente a ||. Também é usado nas restrições do membro.
override	Membros (F#)	Usado para implementar uma versão de um método abstrato ou virtual que difere da versão base.
private	Controle de acesso (F#)	Restringe o acesso a um membro para o código no mesmo tipo ou módulo.
public	Controle de acesso (F#)	Permite o acesso a um membro de fora do tipo.
rec	Funções (F#)	Usado para indicar que uma função recursiva.
return	Fluxos de trabalho assíncronos (F#) Expressões de computação (F#)	Usado para indicar um valor para fornecer como resultado de uma expressão de cálculo.
static	Membros (F#)	Usado para indicar um método ou propriedade que pode ser chamada sem uma instância de um tipo ou um membro de valor que é compartilhado entre todas as instâncias de um tipo.
struct	Estruturas (F#) Restrições (F#)	Usado para declarar um tipo de estrutura. Também é usado nas restrições de parâmetro genérico. Usado para compatibilidade de OCaml nas definições de módulo.
then	Expressões condicionais: IF... em seguida,... else (F#) Construtores (F#)	Usado em expressões condicionais. Também é usado para executar os efeitos colaterais após a construção do objeto.
to	Loops: loop for... a expressão (F#)	Usado em for loops para indicar um intervalo.
true	Tipos primitivos (F#)	Usado como um booleano literal.
try	Exceções: O bloco try... com a expressão (F#) Exceções: O bloco try... finalmente expressão (F#)	Usada para introduzir um bloco de código que pode gerar uma exceção. Usado junto com with ou finally.
type	Tipos de F# Classes (F#) Registros (F#) Estruturas (F#) Enumerações (F#) Uniões discriminadas (F#) Abreviações de tipo (F#) Unidades de medida (F#)	Usado para declarar uma classe, registro, estrutura, união discriminada, tipo de enumeração, unidade de medida, ou digite a abreviação.
upcast	Elenco e conversões (F#)	Usado para converter um tipo que é maior na cadeia de herança.
use	Gerenciamento de recursos: O uso de palavra-chave (F#)	Usado em vez de let para valores que exigem Dispose a ser chamado para recursos livres.
val	Campos explícitos: O val palavra-chave (F#) Assinaturas (F#) Membros (F#)	Usado em uma assinatura para indicar um valor ou em um tipo para declarar um membro, em situações de limitada.
void	Tipos primitivos (F#)	Indica o.NET void tipo. Usado quando interoperar com outros.NET idiomas.
when	Restrições (F#)	Usado para condições booleanas (quando guardas) no padrão de correspondências e introduzir uma cláusula de restrição para um parâmetro de tipo genérico.
while	Loops: While... fazer expressão (F#)	Apresenta uma construção de loop.
with	Corresponder expressões (F#) Expressões de objeto (F#) Extensões de tipo (F#) Exceções: O bloco try... com a expressão (F#)	Usado junto com o match palavra-chave em expressões correspondentes padrão. Também usado em expressões de objeto, expressões de cópia de registros e extensões de tipo para apresentar as definições de membro e apresentar os manipuladores de exceção.
yield	Seqüências (F#)	Usado em uma expressão de seqüência para produzir um valor para uma seqüência.

Além disso, os símbolos a seguir são reservados no F#, porque elas são palavras-chave na linguagem OCaml:

asr

land

lor

lsl

lsr

lxor

mod

sig

Se você usar o --mlcompatibility opção de compilador, essas palavras-chave está disponíveis para serem usados como identificadores.

Os símbolos a seguir são reservados como palavras-chave para a expansão futura da linguagem F#:

atomic	break	checked	component	const	constraint	constructor
continue	eager	event	external	fixed	functor	include
method	mixin	object	parallel	process	protected	pure
sealed	tailcall	trait	virtual	volatile

Consulte também

Referência

Símbolo e o referência de operador (F#)

Outros recursos

Referência de linguagem do F#

Opções do compilador (F#)