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#)