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

Este tópico inclui uma tabela de símbolos e os operadores que são usados na linguagem de F#.

Tabela de símbolos e dos operadores

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

Símbolo ou operador	Links	Descrição
!	Fazer referência a células (F#) Expressões de computação (F#)	Desreferencia uma célula de referência. Após a palavra-chave, indica uma versão modificada do comportamento de palavras-chave como controlada por um fluxo de trabalho.
!=	Não aplicável.	Não usado em F#.Use <> para operações de desigualdade.
"	Literais (F#) Seqüências de caracteres (F#)	Limita uma cadeia de caracteres de texto.
"""	Seqüências de caracteres (F#)	Limita uma cadeia de caracteres textuais.Difere de @"..." que você pode indicar um caractere aspas simples usando uma aspas na cadeia de caracteres.
#	Diretivas de compilador (F#) Tipos flexíveis (F#)	Prefixar uma diretiva pré-processamento ou do compilador, como #light. Quando usado com um tipo, indica um tipo flexível, que faz referência a um tipo ou qualquer um de seus tipos derivados.
$	Não mais informações disponíveis.	Internamente para determinados nomes gerados pelo compilador usados da variável e de função.
%	Operadores aritméticos (F#) Cotações de código (F#)	Calcula o módulo inteiro.Usado para cotações de totalmente.
%?	Operadores anuláveis (F#)	Calcula o módulo inteiro, quando o lado direito é um tipo anulável.
&	Expressões de correspondência (F#)	Calcula o endereço de um valor mutável, para uso quando interoperar com outros idiomas. Usado em AND padrão.
&&	Operadores booleanos (F#)	Calcula o valor booleano AND a operação.
&&&	Operadores bit a bit (F#)	Calcula o bit a bit a operação.
'	Literais (F#) Generalização automática (F#)	Limita um caractere literal único. Indica um parâmetro de tipo genérico.
``...``	Não mais informações disponíveis.	Limita um identificador de outra forma não um identificador válido, como um palavras-chave da linguagem.
( )	Tipo de unidade (F#)	Representa o valor de tipo de unidade.
(...)	Tuplas (F#) Operador de sobrecarga (F#)	Indica a ordem em que as expressões são avaliadas. Limita um tuple. Usado em definições do operador.
(*...*)		Limita um comentário que pode abranger várias linhas.
(|...|)	Padrões de ativos (F#)	Limita um padrão ativo.Também chamados Clipes de banana.
*	Operadores aritméticos (F#) Tuplas (F#) Unidades de medida (F#)	Quando usado como um operador binário, multiplica a esquerda e os lados da direita. Os tipos, indica o emparelhamento em um tuple. Usado em unidades de tipos de medida.
*?	Operadores anuláveis (F#)	Na esquerda e os lados direitos, quando o lado direito é um tipo anulável.
**	Operadores aritméticos (F#)	Calcula a operação exponentiation (x ** y significa x à potência y).
+	Operadores aritméticos (F#)	Quando usado como um operador binário, adicione a esquerda e os lados da direita. Quando usado como um operador unário, indica um valor positivo.(Formalmente, gera o mesmo valor com o sinal inalterado.)
+?	Operadores anuláveis (F#)	Adiciona a esquerda e os lados direitos, quando o lado direito é um tipo anulável.
,	Tuplas (F#)	Separa os elementos de um tuple, 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, executar uma operação de negação.
-	Operadores anuláveis (F#)	Subtrai o lado direito do lado esquerdo, quando o lado direito é um tipo anulável.
->	Funções (F#) Expressões de correspondência (F#)	Em tipos de função, limita argumentos e valores de retorno. Produz uma expressão em ordem expressões (;) equivalente a palavra-chave de yield . Usado em expressões de correspondência
.	Membros (F#) Tipos primitivos (F#)	Acessa um membro, e separar nomes individuais em um nome totalmente qualificado. Especifica um ponto decimal em 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 juntamente 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 (). Usado em unidades de tipos de medida.
/?	Operadores anuláveis (F#)	Divide o lado esquerdo pelo lado direito, quando o lado direito é um tipo anulável.
//		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 ou um nome de membro do tipo.
::	Listas (F#) Expressões de correspondência (F#)	Cria uma lista.O elemento à esquerda é acrescentada à lista no lado direito. Usado em busca de padrão para separar partes de uma lista.
:=	Fazer referência a células (F#)	Atribui um valor a uma célula de referência.
:>	Elenco e conversões (F#)	Converter um tipo para o tipo que é superior na hierarquia.
:?	Expressões de correspondência (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#)	Converter um tipo para um tipo que é mais abaixo na hierarquia.
;	Sintaxe detalhada (F#) Listas (F#) Registros (F#)	Separa expressões (usadas principalmente na sintaxe extensa). Separa os elementos de uma lista. Separa os campos de um registro.
<	Operadores aritméticos (F#)	Calcula símbolo de menor que a operação.
<?	Operadores anuláveis (F#)	Calcula menos da operação, quando o lado direito é um tipo anulável.
<<	Funções (F#)	Compondo duas funções em ordem inversa; segundo é executado primeiro inverso de composição (operador).
<<<	Operadores bit a bit (F#)	Desloca bit na quantidade no lado esquerdo à esquerda pelo número de bits especificados no lado direito.
<-	Valores (F#)	Atribui um valor a uma variável.
<...>	Generalização automática (F#)	Limita parâmetros de tipo.
<>	Operadores aritméticos (F#)	Retorna true se o lado esquerdo não é igual ao lado direito; caso contrário, retornará falsos.
<>?	Operadores anuláveis (F#)	Calcula a operação “não igual” quando o lado direito é um tipo anulável.
<=	Operadores aritméticos (F#)	Retorna true se o lado esquerdo é menor ou igual ao lado direito; caso contrário, retornará falsos.
<=?	Operadores anuláveis (F#)	Calcula “menor ou igual a” a operação quando o lado direito é um tipo anulável.
<|	Funções (F#)	Passa o resultado da expressão no lado direito para a função no lado esquerdo (operador inverso de pipe).
<||	Operadores.( <|| )<'T1,'T2,' U > Função (F#)	Passa o tuple de dois argumentos no lado direito para a função no lado esquerdo.
<|||	Operadores.( <||| )< U 'T1, 'T2', T3,' > Função (F#)	Passa o tuple de três argumentos no lado direito para a função no lado esquerdo.
<@...@>	Cotações de código (F#)	Limita uma aspas tipada de código.
<@@...@@>	Cotações de código (F#)	Limita uma aspas sem tipo de código.
=	Operadores aritméticos (F#)	Retorna true se o lado esquerdo é igual ao lado direito; caso contrário, retornará falsos.
=?	Operadores anuláveis (F#)	Calcula a operação “igual” quando o lado direito é um tipo anulável.
==	Não aplicável.	Não usado em F#.Use = para operações de igualdade.
>	Operadores aritméticos (F#)	Retorna true se o lado esquerdo for maior do que o lado direito; caso contrário, retornará falsos.
>?	Operadores anuláveis (F#)	Calcula o greather “de” a operação quando o lado direito é um tipo anulável.
>>	Funções (F#)	Compondo duas funções (operador frente de composição).
>>>	Operadores bit a bit (F#)	Desloca bit na quantidade no lado esquerdo à direita pelo número de locais especificados no lado direito.
>=	Operadores aritméticos (F#)	Retorna true se o lado direito é maior ou igual ao lado esquerdo; caso contrário, retornará falsos.
>=?	Operadores anuláveis (F#)	Calcula “maior que ou igual a operação de” quando o lado direito é um tipo anulável.
?	Parâmetros e argumentos (F#)	Especifica um argumento opcional. Usado como um operador para dinâmicos chamadas de método e propriedade.Você deve fornecer sua própria implementação.
? ... <- ...	Não mais informações disponíveis.	Usado como um operador para definir propriedades dinâmicas.Você deve fornecer sua própria implementação.
?>=, ?>, ?<=, ?<, ?=, ?<>, ?+, ?-, ?*, ?/	Operadores anuláveis (F#)	Equivalente aos operadores correspondentes sem?prefixo, onde um tipo anulável é à esquerda.
>=?, >?, <=?, <?, =?, <>?, +?, -?, *?, /?	Operadores anuláveis (F#)	Equivalente aos operadores correspondentes sem?suffix, onde um tipo anulável é à direita.
?>=?, ?>?, ?<=?, ?<?, ?=?, ?<>?, ?+?, ?-?, ?*?, ?/?	Operadores anuláveis (F#)	Equivalente aos operadores correspondentes sem pontos de interrogação adjacentes, onde os dois lados são tipos anuláveis.
@	Listas (F#) Seqüências de caracteres (F#)	Concatena duas listas. Quando colocado antes de uma cadeia de caracteres literal, indica que a cadeia de caracteres deve ser interpretada verbatim, sem a interpretação de caracteres de escape.
[...]	Listas (F#)	Limitar os elementos de uma lista.
[|...|]	Matrizes (F#)	Limitar os elementos de uma matriz.
[<...>]	Atributos (F#)	Limita um atributo.
\	Seqüências de caracteres (F#)	Escapres o próximo caractere; usado em literais de caracteres e de cadeia de caracteres.
^	Resolvido estaticamente os parâmetros de tipo (F#) Seqüências de caracteres (F#)	Especifica os parâmetros de tipo que devem ser resolvidos em tempo de compilação, não no tempo de execução. Concatena cadeias de caracteres.
^^^	Operadores bit a bit (F#)	Calcula o exclusive a operação OU bit a bit.
_	Expressões de correspondência (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#)	Limita expressões de sequência e expressões de computação. Usado nas definições de registro.
|	Expressões de correspondência (F#)	Limita casos individuais de correspondência, caso discriminados individuais de união, e valores de enumeração.
||	Operadores booleanos (F#)	Calcula o valor booleano OU a operação.
|||	Operadores bit a bit (F#)	Calcula o OPERADOR bit a bit a operação.
|>	Funções (F#)	Passa o resultado do lado esquerdo para a função no lado direito (encaminhar o operador de pipe).
||>	Operadores.( ||> ) <'T1,'T2,' U > Função (F#)	Passa o tuple de dois argumentos no lado esquerdo para a função no lado direito.
|||>	Operadores.( |||> ) < U 'T1, 'T2', T3,' > Função (F#)	Passa o tuple de três argumentos no lado esquerdo para a função no lado direito.
~~	Operador de sobrecarga (F#)	Usado para declarar uma sobrecarga para o operador unário de negação.
~~~	Operadores bit a bit (F#)	Calcula NÃO a operação bit a bit.
~-	Operador de sobrecarga (F#)	Usado para declarar uma sobrecarga para o operador unário menos o operador.
~+	Operador de sobrecarga (F#)	Usado para declarar uma sobrecarga para o operador unário mais o operador.

Precedência de operadores

A tabela a seguir mostra a ordem de precedência de operadores e outros palavra-chave da expressão na linguagem de F#, em ordem de precedência inferior para a precedência mais alta.Também é listado o associatividade, se aplicável.

Operator	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
&&&, |||, ^^^, ~~~, <<<, >>>	Esquerda
^op	Direita
::	Direita
:?>, :?	Nonassociative
-op, +op, (binário)	Esquerda
*op, /op, %op	Esquerda
**op	Direita
f x (aplicativo) de função	Esquerda
| (correspondência de 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óprios operadores.Na tabela anterior, op pode ser (possivelmente) sequência de caracteres vazia válido do operador, internos ou definidos pelo usuário.Assim, você pode usar esta tabela para determinar que sequência de caracteres a ser usado para que um operador personalizado atingir o nível desejado de precedência.Os caracteres do primeiro de . são ignorados quando o compilador determina a precedência.

Consulte também

Referência

Operador de sobrecarga (F#)

Outros recursos

Referência de linguagem do F#