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

Este tópico inclui uma tabela de símbolos e operadores usados na linguagem 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 contêm mais informações e fornece uma breve descrição de alguns dos usos do símbolo. Os símbolos são organizados de acordo com a ordem de conjunto de caracteres ASCII.

Símbolo ou 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 é usada em F#. Use <> para operações de desigualdade.
"	Literais (F#) Cadeias de caracteres (F#)	Delimita uma cadeia de texto.
"""	Cadeias de caracteres (F#)	Delimita uma cadeia de caracteres textuais. Difere de @"..." em que você pode indicar um caractere de aspas usando aspas simples na cadeia de caracteres.
#	Diretivas de compilador (F#) Tipos flexíveis (F#)	Prefixos de uma diretiva de pré-processador ou compilador, tal como #light. Quando usado com um tipo, indica um tipo flexível, que se refere a um tipo ou a qualquer um de seus tipos derivados.
$	Não há mais informações disponíveis.	Usado internamente para determinados nomes de variáveis e de funções gerados pelo compilador.
%	Operadores aritméticos (F#) Citações de código (F#)	Calcula o módulo de inteiro. Usado para união de expressões em cotações de códigos digitados.
%%	Citações de código (F#)	Usado para união de expressões em cotações de códigos não digitados.
%?	Operadores anuláveis (F#)	Calcula o módulo de inteiro, quando o lado direito for um tipo que permite valor nulo.
&	Expressões match (F#)	Calcula o endereço de um valor mutável, para uso ao interoperar com outros idiomas. Usado em padrões AND.
&&	Operadores boolianos (F#)	Calcula a operação AND booleana.
&&&	Operadores bit a bit (F#)	Calcula a operação AND bit 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 seria um identificador legal, como uma palavra-chave de idioma.
( )	Tipo unit (F#)	Representa um único valor do tipo de unidade.
(...)	Tuplas (F#) Sobrecarga de operador (F#)	Indica a ordem na qual as expressões são avaliadas. Delimita uma tupla. Usado em definições de operador.
(*...*)		Delimita um comentário que poderia abranger várias linhas.
(|...|)	Padrões ativos (F#)	Delimita um padrão ativo. Também chamado de pipe ativo.
*	Operadores aritméticos (F#) Tuplas (F#) Unidades de medida (F#)	Quando usado como um operador binário, multiplica os lados esquerdo e direito. Em tipos, indica emparelhamento em uma tupla. Usado em unidades de tipos de medida.
*?	Operadores anuláveis (F#)	Multiplica os lados esquerdo e direito, quando o lado direito for um tipo que permite valor nulo.
**	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).
+?	Operadores anuláveis (F#)	Adiciona os lados esquerdo e direito, quando o lado direito for um tipo que permite valor nulo.
,	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.
-	Operadores anuláveis (F#)	Subtrai o lado direito do lado esquerdo, quando o lado direito for um tipo que permite valor nulo.
->	Funções (F#) Expressões match (F#)	Em tipos de função, delimita argumentos e valores de retorno. Gera uma expressão (em expressões de sequência); equivalente à palavra-chave yield. Usado em expressões de correspondência
.	Membros (F#) Tipos primitivos (F#)	Acessa um membro e separa nomes individuais em um nome totalmente qualificado. Especifica um ponto decimal em números de ponto flutuante.
..	Loops: expressão for...in (F#)	Especifica um intervalo.
.. ..	Loops: expressão for...in (F#)	Especifica um intervalo com um incremento.
.[...]	Matrizes (F#)	Acessa um elemento de matriz.
/	Operadores aritméticos (F#) Unidades de medida (F#)	Divide o lado esquerdo (numerador) pelo direito (denominador). Usado em unidades de tipos de medida.
/?	Operadores anuláveis (F#)	Divide o lado esquerdo pelo lado direito, quando o lado direito for um tipo que permite valor nulo.
//		Indica o início de um comentário de uma linha.
///	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 de membro do seu tipo.
::	Listas (F#) Expressões match (F#)	Cria uma lista. O elemento no lado esquerdo é anexado à 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.
:>	Conversões cast e conversões (F#)	Converte um tipo em um tipo que seja superior na hierarquia.
:?	Expressões match (F#)	Retorna true se o valor corresponder ao tipo especificado; caso contrário, retorna false (operador de teste do tipo).
:?>	Conversões cast e conversões (F#)	Converte um tipo em um tipo que seja inferior na hierarquia.
;	Sintaxe detalhada (F#) Listas (F#) Registros (F#)	Separa expressões (usadas principalmente na sintaxe detalhada). Separa elementos de uma lista. Separa campos de um registro.
<	Operadores aritméticos (F#)	Calcula a operação menor que.
<?	Operadores anuláveis (F#)	Calcula a operação menor que, quando o lado direito for um tipo que permite valor nulo.
<<	Funções (F#)	Compõe duas funções em ordem inversa; a segunda é executada primeiro (operador de composição invertida).
<<<	Operadores bit a bit (F#)	Desloca 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 parâmetros de tipo.
<>	Operadores aritméticos (F#)	Retorna true se o lado esquerdo não for igual ao direito; caso contrário, retorna false.
<>?	Operadores anuláveis (F#)	Calcula a operação "diferente de", quando o lado direito for um tipo que permite valor nulo.
<=	Operadores aritméticos (F#)	Retorna true se o lado esquerdo for menor ou igual ao lado direito; caso contrário, retorna false.
<=?	Operadores anuláveis (F#)	Calcula a operação "menor ou igual a", quando o lado direito for um tipo que permite valor nulo.
<|	Funções (F#)	Passa o resultado da expressão no lado direito para a função no lado esquerdo (operador barra vertical invertida).
<||	Função Operators.( <|| )<'T1,'T2,'U> (F#)	Passa a tupla de dois argumentos no lado direito para a função no lado esquerdo.
<|||	Função Operators.( <||| )<'T1,'T2,'T3,'U> (F#)	Passa a tupla de três argumentos no lado direito para a função no lado esquerdo.
<@...@>	Citações de código (F#)	Delimita uma cotação de código digitado.
<@@...@@>	Citações de código (F#)	Delimita uma cotação de código não digitado.
=	Operadores aritméticos (F#)	Retorna true se o lado esquerdo for igual ao lado direito; caso contrário, retorna false.
=?	Operadores anuláveis (F#)	Calcula a operação "igual", quando o lado direito for um tipo que permite valor nulo.
==	Não aplicável.	Não é usada em 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.
>?	Operadores anuláveis (F#)	Calcula a operação "maior que", quando o lado direito for um tipo que permite valor nulo.
>>	Funções (F#)	Compõe duas funções (operador de composição direta).
>>>	Operadores bit a bit (F#)	Desloca bits na quantidade no lado esquerdo para a direita pelo número de casas especificado no lado direito.
>=	Operadores aritméticos (F#)	Retorna true se o lado direito for maior ou igual ao lado esquerdo; caso contrário, retorna false.
>=?	Operadores anuláveis (F#)	Calcula a operação "maior ou igual a", quando o lado direito for um tipo que permite valor nulo.
?	Parâmetros e argumentos (F#)	Especifica um argumento opcional. Usado como um operador de 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 de propriedades de configuração dinâmica. Você deve fornecer sua própria implementação.
?>=, ?>, ?<=, ?<, ?=, ?<>, ?+, ?-, ?*, ?/	Operadores anuláveis (F#)	Equivalente aos operadores correspondentes sem o prefixo ? em que um tipo que permite valor nulo está à esquerda.
>=?, >?, <=?, <?, =?, <>?, +?, -?, *?, /?	Operadores anuláveis (F#)	Equivalente aos operadores correspondentes sem o sufixo ? em que um tipo que permite valor nulo está à direita.
?>=?, ?>?, ?<=?, ?<?, ?=?, ?<>?, ?+?, ?-?, ?*?, ?/?	Operadores anuláveis (F#)	Equivalente aos operadores correspondentes sem pontos de interrogação adjacentes, em que os dois lados são tipos que permitem valor nulo.
@	Listas (F#) Cadeias de caracteres (F#)	Concatena duas listas. Quando colocado antes de uma sequência literal, indica que a sequência deve ser interpretada textualmente, sem 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.
\	Cadeias de caracteres (F#)	Pula o próximo caractere; usado em literal de caractere ou em sequência literal.
^	Parâmetros de tipo resolvidos estaticamente (F#) Cadeias de caracteres (F#)	Especifica os parâmetros de tipo que devem ser resolvidos no tempo de compilação, não no tempo de execução. Concatena sequências.
^^^	Operadores bit a bit (F#)	Calcula a operação OR exclusiva bit a bit.
_	Expressões match (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.
{...}	Sequências (F#) Registros (F#)	Delimita expressões de sequência e expressões de computação. Usado em definições de registro.
|	Expressões match (F#)	Delimita casos de correspondência individuais, casos de união discriminada individuais e valores de enumeração.
||	Operadores boolianos (F#)	Calcula a operação OR booleana.
|||	Operadores bit a bit (F#)	Calcula a operação OR bit a bit.
|>	Funções (F#)	Passa o resultado do lado esquerdo para a função no lado direito (operador barra vertical direta).
||>	Função Operators.( ||> )<'T1,'T2,'U> (F#)	Passa a tupla de dois argumentos no lado esquerdo para a função no lado direito.
|||>	Função Operators.( |||> )<'T1,'T2,'T3,'U> (F#)	Passa a tupla de três argumentos no lado esquerdo para a função no lado direito.
~~	Sobrecarga de operador (F#)	Usado para declarar uma sobrecarga para o operador de negação unário.
~~~	Operadores bit a bit (F#)	Calcula a operação NOT bit a bit.
~-	Sobrecarga de operador (F#)	Usado para declarar uma sobrecarga para o operador de subtração unário.
~+	Sobrecarga de operador (F#)	Usado para declarar uma sobrecarga para o operador de adição unário.

Precedência do Operador

A tabela a seguir mostra a ordem de precedência de operadores e outras palavras-chave da expressão na linguagem F#, na ordem de precedência mais baixa para a mais alta. Também é listada a capacidade de associação, se aplicável.

Operador	Associatividade
as	Direita
when	Direita
| (barra vertical)	Esquerda
;	Direita
let	Não associativo
function, fun, match, try	Não associativo
if	Não associativo
->	Direita
:=	Direita
,	Não associativo
or, ||	Esquerda
&, &&	Esquerda
<op, >op, =, |op, &op	Esquerda
&&&, |||, ^^^, ~~~, <<<, >>>	Esquerda
^op	Direita
::	Direita
:?>, :?	Não associativo
-op, +op, (binário)	Esquerda
*op, /op, %op	Esquerda
**op	Direita
f x (aplicativo de função)	Esquerda
| (correspondência padrão)	Direita
operadores de prefixo (+op, -op, %, %%, &, &&, !op, ~op)	Esquerda
.	Esquerda
f(x)	Esquerda
f<types>	Esquerda

F# oferece suporte à sobrecarga de operador personalizado. Isso significa que você pode definir seus próprio operadores. Na tabela anterior, op pode ser qualquer sequência (possivelmente vazia) válida de caracteres de operador, internos ou definidos pelo usuário. Dessa forma, é possível usar esta tabela para determinar qual sequência de caracteres usar para que um operador personalizado atinja o nível desejado de precedência. Os caracteres . à esquerda são ignorados quando o compilador determina a precedência.

Consulte também

Referência

Sobrecarga de operador (F#)

Outros recursos

Referência da linguagem F#