Referência de palavras-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 que contêm informações mais relevantes.

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 ela é declarada ou que é virtual e tem uma implementação padrão.
and	Associações let (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#) Correspondência padrão (F#)	Usado para fornecer um nome de objeto do 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	Asserções (F#)	Usado para verificar o código durante a depuração.
base	Classes (F#) Herança (F#)	Usado como o nome do objeto do classe base.
begin	Sintaxe 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 em conjunto com uma declaração de método abstrato para criar um método virtual.
delegate	Delegados (F#)	Usado para declarar um delegado.
do	Associações do (F#) Loops: expressão for...to (F#) Loops: expressão for...in (F#) Loops: expressão while...do (F#)	Usado em construções de loop ou executar código imperativo.
done	Sintaxe detalhada (F#)	Na sintaxe detalhada, indica o final de um bloco de código em uma expressão de repetição.
downcast	Conversões cast e conversões (F#)	Usado para converter um tipo que é o mais baixo na cadeia de herança.
downto	Loops: expressão for...to (F#)	Em um for a expressão, usada quando a contagem na ordem inversa.
elif	Expressões condicionais: if...then...else (F#)	Usado na ramificação condicional. Uma forma abreviada da else if.
else	Expressões condicionais: if...then...else (F#)	Usado na ramificação condicional.
end	Estruturas (F#) Uniões discriminadas (F#) Registros (F#) Extensões de tipo (F#) Sintaxe detalhada (F#)	Em definições de tipo e extensões de tipo, indica o fim 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	Tratamento de exceções (F#) Tipos de exceção (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: a expressão try...finally (F#)	Usado em conjunto com try para apresentar um bloco de código que é executado independentemente de se ocorre uma exceção.
for	Loops: expressão for...to (F#) Loops: expressão for...in (F#)	Usado em construções de loop.
fun	Expressões lambda: a palavra-chave fun (F#)	Usado em expressões lambda, também conhecido como anônimas funções.
function	Expressões match (F#) Expressões lambda: a palavra-chave fun (F#)	Usado como uma alternativa mais curta para o fun palavra-chave e um match a expressão em uma expressão lambda que possui um único argumento de correspondência de padrão.
global	Namespaces (F#)	Usado para referência de nível superior.NET namespace.
if	Expressões condicionais: if...then...else (F#)	Usado em construções de ramificação condicionais.
in	Loops: expressão for...in (F#) Sintaxe detalhada (F#)	Usado para expressões de seqüência e, na sintaxe 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 está 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 um resultado for necessária.
let	Associações let (F#)	Usado para associar ou vincular, um nome para a função ou valor.
let!	Fluxos de trabalho assíncronos Expressões de computação	Usado em fluxos de trabalho assíncronos para vincular a um nome para o resultado de uma computação assíncrona ou, em outras expressões de computação, usados para vincular a um nome a um resultado, o que é do tipo de cálculo.
match	Expressões match (F#)	Usado para a ramificação, comparando um valor para 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, ele separar logicamente de outro código.
mutable	Associações let (F#)	Usado para declarar uma variável, ou seja, um valor que pode ser alterado.
namespace	Namespaces (F#)	Usado para associar um nome de um grupo de tipos relacionados e módulos, separar logicamente-lo 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	Referência de símbolos e operadores (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ção (F#)	Usado em uniões discriminadas para indicar o tipo de categorias de valores e nas declarações de delegado e exceção.
open	Declarações de importação: a palavra-chave open (F#)	Usado para disponibilizar o conteúdo de um namespace ou o módulo sem qualificação.
or	Referência de símbolos e operadores (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 ao 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.
return!	Expressões de computação Fluxos de trabalho assíncronos	Usado para indicar uma expressão de cálculo que, quando avaliada, fornece o resultado da expressão de cálculo que o contém.
select	Expressões de consulta (F#)	Usado em expressões de consulta para especificar quais campos ou colunas para extrair. Observe que se trata de uma palavra-chave contextual, que significa que não é realmente uma palavra reservada e age apenas como uma palavra-chave no contexto apropriado.
static	Membros (F#)	Usado para indicar um método ou propriedade que pode ser chamada sem uma instância de um tipo ou membro compartilhado entre todas as instâncias de um tipo de valor.
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 OCaml nas definições do módulo.
then	Expressões condicionais: if...then...else (F#) Construtores (F#)	Usado em expressões condicionais. Também é usado para realizar efeitos colaterais após a construção do objeto.
to	Loops: expressão for...to (F#)	Usado em for loops para indicar um intervalo.
true	Tipos primitivos (F#)	Usado como um booleano literal.
try	Exceções: a expressão try...with (F#) Exceções: a expressão try...finally (F#)	Usada para introduzir um bloco de código que pode gerar uma exceção. Usado em conjunto com with ou finally.
type	Tipos 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	Conversões cast e conversões (F#)	Usado para converter para um tipo que é maior na cadeia de herança.
use	Gerenciamento de recursos: a palavra-chave use (F#)	Usado em vez de let para valores que requerem Dispose a ser chamado para liberar recursos.
use!	Expressões de computação Fluxos de trabalho assíncronos	Usado em vez de let! em fluxos de trabalho assíncronos e de outras expressões de computação para valores que requerem Dispose a ser chamado para liberar recursos.
val	Campos explícitos: a palavra-chave val (F#) Assinaturas (F#) Membros (F#)	Usado em uma assinatura para indicar um valor ou em um tipo para declarar um membro, em situações limitados.
void	Tipos primitivos (F#)	Indica o.NET void type. Usado quando interoperar com os outros.NET diferentes.
when	Restrições (F#)	Usado para condições booleanas (quando guardas) no padrões correspondentes e introduzir uma cláusula constraint para um parâmetro de tipo genérico.
while	Loops: expressão while...do (F#)	Apresenta uma construção de loop.
with	Expressões match (F#) Expressões de objeto (F#) Extensões de tipo (F#) Exceções: a expressão try...with (F#)	Usado junto com o match palavra-chave em expressões de correspondência de 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	Sequências (F#)	Usado em uma expressão de seqüência para produzir um valor para uma seqüência.
yield!	Expressões de computação Fluxos de trabalho assíncronos	Usado em uma expressão de cálculo para acrescentar um conjunto de resultados para a expressão de cálculo que contém o resultado da expressão de uma determinada computação.

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 uso 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

Referência de símbolos e operadores (F#)

Outros recursos

Referência da linguagem F#

Opções do compilador (F#)