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

Este tópico inclui uma tabela de símbolos e operadores são usados no idioma F#.

Tabela de símbolos e operadores

A tabela a seguir descreve os símbolos usados na linguagem F#, fornece links para tópicos que fornecem mais informações e fornece uma breve descrição de alguns dos usos do símbolo. Símbolos são ordenados de acordo com o ASCII pedidos de conjunto de caracteres.

Símbolo ou o operador	Links	Descrição
!	Células de referência (F#) Expressões de computação (F#)	Cancela a referência de uma célula de referência. Após uma palavra-chave, indica uma versão modificada do comportamento da palavra-chave, conforme controlado por um fluxo de trabalho.
!=	Não aplicável.	Não usado no F#. Use <> para operações de desigualdade.
"	Literais (F#)	Delimita uma seqüência de caracteres de texto.
#	Diretivas de compilador (F#) Tipos flexíveis (F#)	Prefixos de uma diretiva do pré-processador ou compilador, tais como #light. Quando usado com um tipo, indica um tipo flexível, que se refere a um tipo ou qualquer um dos seus tipos derivados.
$	Não há mais informações disponíveis.	Usado internamente para determinados nomes de variáveis e funções gerado pelo compilador.
%	Operadores aritméticos (F#) Cotações de código (F#)	Calcula o módulo inteiro. Usado para splicing cotações.
&	Corresponder expressões (F#)	Calcula o endereço de um valor mutável, para uso quando interoperar com outras linguagens. Usado e padrões.
&&	Operadores booleanos (F#)	Calcula a operação E Boolean.
&&&	Operadores bit a bit (F#)	Calcula a operação a bit.
'	Literais (F#) Generalização automática (F#)	Delimita um literal de caractere único. Indica um parâmetro de tipo genérico.
``...``	Não há mais informações disponíveis.	Delimita um identificador que não seriam um identificador legal, como, por exemplo, uma palavra-chave de idioma.
( )	Tipo de unidade (F#)	Representa um único valor do tipo de unidade.
(...)	Tuplas (F#) Operador de sobrecarga (F#)	Indica a ordem na qual as expressões são avaliadas. Delimita uma tupla. Usado em definições de operador.
(*...*)		Delimita a um comentário que poderia abranger várias linhas.
(|...|)	Padrões de ativos (F#)	Delimita a um ativo padrão. Também chamado de os clipes de banana.
*	Operadores aritméticos (F#) Tuplas (F#) Unidades de medida (F#)	Quando usado como um operador binário, multiplica os lados esquerdo e direito. Tipos, indica uma tupla de emparelhamento. Usada em unidades de tipos de medida.
**	Operadores aritméticos (F#)	Calcula a operação de exponenciação (x ** y significa x à potência de y).
+	Operadores aritméticos (F#)	Quando usado como um operador binário, adiciona os lados esquerdo e direito. Quando usado como um operador unário, indica uma quantidade positiva. (Formalmente, ele produz o mesmo valor com o sinal inalterado.)
,	Tuplas (F#)	Separa os elementos de uma tupla ou parâmetros de tipo.
-	Operadores aritméticos (F#)	Quando usado como um operador binário, subtrai o lado direito do lado esquerdo. Quando usado como um operador unário, executa uma operação de negação.
->	Funções (F#) Corresponder expressões (F#)	Tipos de função, delimita os argumentos e valores de retorno. Produz uma expressão (em expressões de seqüência); equivalente a yield palavra-chave. Usado em expressões de correspondência
.	Membros (F#) Tipos primitivos (F#)	Acessa um membro e separa os nomes individuais em um nome totalmente qualificado. Especifica um ponto decimal nos números de ponto flutuante.
..	Loops: loop for... na expressão (F#)	Especifica um intervalo.
.. ..	Loops: loop for... na expressão (F#)	Especifica um intervalo em conjunto com um incremento.
.[...]	Matrizes (F#)	Acessa um elemento de matriz.
/	Operadores aritméticos (F#) Unidades de medida (F#)	Divide o lado esquerdo (Numerador) pelo lado direito (denominador). Usada em unidades de tipos de medida.
//		Indica o início de um comentário de linha única.
///	Documentação XML (F#)	Indica um comentário XML.
:	Funções (F#)	Em uma anotação de tipo separa um nome de parâmetro ou membro de seu tipo.
::	Listas (F#) Corresponder expressões (F#)	Cria uma lista. O elemento no lado esquerdo é acrescentado à lista no lado direito. Usado na correspondência de padrões para separar as partes de uma lista.
:=	Células de referência (F#)	Atribui um valor a uma célula de referência.
:>	Elenco e conversões (F#)	Converte um tipo para tipo superior na hierarquia.
:?	Corresponder expressões (F#)	Retorna true se o valor corresponde ao tipo especificado; Caso contrário, retornará false (operador de teste de tipo).
:?>	Elenco e conversões (F#)	Converte um tipo para um tipo que é inferior na hierarquia.
;	Sintaxe muito detalhada (F#) Listas (F#) Registros (F#)	Separa as expressões (usadas principalmente em sintaxe muito detalhada). Separa os elementos de uma lista. Separa os campos de um registro.
<	Operadores aritméticos (F#)	Calcula o menor-que a operação.
<<	Funções (F#)	Compõe duas funções na ordem inversa; o outro é executado primeiro (operador de composição para trás).
<<<	Operadores bit a bit (F#)	Desloca o bits na quantidade no lado esquerdo para a esquerda pelo número de bits especificado no lado direito.
<-	Valores (F#)	Atribui um valor a uma variável.
<...>	Generalização automática (F#)	Delimita os parâmetros de tipo.
<>	Operadores aritméticos (F#)	Retorna true se o lado esquerdo não é igual à direita; Caso contrário, retorna false.
<=	Operadores aritméticos (F#)	Retorna true se o lado esquerdo é menor ou igual à direita; Caso contrário, retorna false.
<|	Funções (F#)	Passa o resultado da expressão à direita para a função no lado esquerdo (operador pipe com versões anteriores).
<@...@>	Cotações de código (F#)	Delimita uma cotação de código digitado.
<@@...@@>	Cotações de código (F#)	Delimita uma cotação de código sem tipo.
=	Operadores aritméticos (F#)	Retorna true se o lado esquerdo for igual à direita; Caso contrário, retorna false.
==	Não aplicável.	Não usado no F#. Use = para operações de igualdade.
>	Operadores aritméticos (F#)	Retorna true se o lado esquerdo for maior que o lado direito; Caso contrário, retorna false.
>>	Funções (F#)	Compõe duas funções (operador de composição direta).
>>>	Operadores bit a bit (F#)	A quantidade no lado esquerdo para a direita pelo número de bits turnos coloca especificado no lado direito.
>=	Operadores aritméticos (F#)	Retorna true se o lado direito é maior ou igual à esquerda; Caso contrário, retorna false.
?	Parâmetros e argumentos (F#)	Especifica um argumento opcional. Usado como um operador para chamadas de método e propriedade dinâmicas. Você deve fornecer sua própria implementação.
? ... <- ...	Não há mais informações disponíveis.	Usado como um operador para propriedades dinâmicas de configuração. Você deve fornecer sua própria implementação.
@	Listas (F#) Seqüências de caracteres (F#)	Concatena duas listas. Quando colocado antes de uma seqüência de caracteres literal, indica que a seqüência de caracteres deve ser interpretado textualmente, com nenhuma interpretação de caracteres de escape.
[...]	Listas (F#)	Delimita os elementos de uma lista.
[|...|]	Matrizes (F#)	Delimita os elementos de uma matriz.
[<...>]	Atributos (F#)	Delimita um atributo.
\	Seqüências de caracteres (F#)	Expõe o próximo caractere; usado em caracteres literais de seqüência de caracteres.
^	Resolvido estaticamente os parâmetros de tipo (F#) Seqüências de caracteres (F#)	Especifica os parâmetros de tipo devem ser resolvidos em tempo de compilação, não em tempo de execução. Concatenar seqüências.
^^^	Operadores bit a bit (F#)	Calcula a operação OR exclusiva bit a bit.
_	Corresponder expressões (F#) Genéricos (F#)	Indica um padrão de curinga. Especifica um parâmetro genérico anônimo.
`	Generalização automática (F#)	Usado internamente para indicar um parâmetro de tipo genérico.
{...}	Seqüências (F#) Registros (F#)	Delimita as expressões de seqüência e expressões de computação. Usado em definições de registros.
|	Corresponder expressões (F#)	Delimita os casos de correspondência individual, casos de união discriminados individuais e valores de enumeração.
||	Operadores booleanos (F#)	Calcula a operação ou booleano.
|||	Operadores bit a bit (F#)	Calcula a operação OR bit a bit.
|>	Funções (F#)	Passa o resultado da esquerda para a função no lado direito (operador pipe direta).
~~	Operador de sobrecarga (F#)	Usado para declarar uma sobrecarga de operador de negação unário.
~~~	Operadores bit a bit (F#)	Calcula o operador bit a bit não a operação.
~-	Operador de sobrecarga (F#)	Usado para declarar uma sobrecarga para o operador unário operador de subtração.
~+	Operador de sobrecarga (F#)	Usado para declarar uma sobrecarga de operador de adição unário.

Precedência de operador

A tabela a seguir mostra a ordem de precedência de operadores e outras palavras-chave da expressão F# idioma, em ordem de precedência mais baixa para a precedência mais alta. Também listados é a associatividade de operadores, se aplicável.

Operador	Associatividade
as	Direita
when	Direita
| (pipe)	À esquerda
;	Direita
let	Nonassociative
function, fun, match, try	Nonassociative
if	Nonassociative
->	Direita
:=	Direita
,	Nonassociative
or, ||	À esquerda
&, &&	À esquerda
<op, >op, =, |op, &op	À esquerda
^op	Direita
::	Direita
:?>, :?	Nonassociative
-op, +op, (binary)	À esquerda
*op, /op, %op	À esquerda
**op	Direita
f x(aplicativo de função)	À esquerda
| (padrões correspondentes)	Direita
Operadores de prefixo (+op, -op, %, %, &, & &,!op, ~op)	À esquerda
.	À esquerda
f(x)	À esquerda
f<types>	À esquerda

F# oferece suporte a sobrecarga de operador personalizado. Isso significa que você pode definir seus próprios operadores. Na tabela anterior, op pode ser qualquer seqüência (possivelmente vazia) válida de caracteres de operador, internos ou definido pelo usuário. Assim, você pode usar esta tabela para determinar qual seqüência de caracteres a ser usado para um operador personalizado para atingir o nível desejado de precedência. Principais . caracteres são ignorados quando o compilador determina precedência.

Consulte também

Referência

Operador de sobrecarga (F#)

Outros recursos

Referência de linguagem do F#

Histórico de alterações

Date	History	Motivo
Outubro de 2010	Adicionadas informações sobre os operadores de igualdade e desigualdade.	Aprimoramento de informações.