Referencia de símbolos y operadores (F#)

En este tema se incluye una tabla de símbolos y operadores que se utilizan en el lenguaje F#.

Tabla de símbolos y operadores

En la siguiente tabla se describen los símbolos utilizados en el lenguaje F#, se incluyen vínculos a temas que proporcionan más información y se facilita una breve descripción de algunos de los usos del símbolo. Los símbolos están ordenados según el orden del juego de caracteres ASCII.

Símbolo u operador	Vínculos	Descripción
!	Celdas de referencia (F#) Expresiones de cálculo (F#)	Desreferencia una celda de referencia. Después de una palabra clave, indica una versión modificada del comportamiento de la misma, controlado por un flujo de trabajo.
!=	No es aplicable.	No se utiliza en F#. Utilice <> para las operaciones de desigualdad.
"	Literales (F#) Cadenas (F#)	Delimita una cadena de texto.
"""	Cadenas (F#)	Delimita una cadena de texto literal. Se diferencia de @"..." en que puede indicar un carácter de comilla mediante el uso de comillas simples en la cadena.
#	Directivas de compilador (F#) Tipos flexibles (F#)	Prefija una directiva de compilador o preprocesador, como #light. Cuando se usa con un tipo, indica un tipo flexible, que hace referencia a un tipo o a cualquiera de sus tipos derivados.
$	No hay más información disponible.	Se utiliza internamente para determinados nombres de variable y función generados por el compilador.
%	Operadores aritméticos (F#) Expresiones de código delimitadas (F#)	Calcula el módulo entero. Se utiliza para ensamblar expresiones en expresiones de código delimitadas con tipo.
%%	Expresiones de código delimitadas (F#)	Se utiliza para ensamblar expresiones en expresiones de código delimitadas sin tipo.
%?	Operadores que aceptan valores NULL (F#)	Calcula el módulo entero, cuando el lado derecho es un tipo que acepta valores NULL.
&	Expresiones match (F#)	Calcula la dirección de un valor mutable para usarlo al interoperar con otros lenguajes. Se utiliza en los patrones AND.
&&	Operadores booleanos (F#)	Calcula la operación AND booleana.
&&&	Operadores bit a bit (F#)	Calcula la operación AND bit a bit.
'	Literales (F#) Generalización automática (F#)	Delimita un literal de carácter único. Indica un parámetro de tipo genérico.
``...``	No hay más información disponible.	Delimita un identificador que de otro modo no sería un identificador válido, como una palabra clave de lenguaje.
( )	Tipo unit (F#)	Representa el valor único del tipo de unidad.
(...)	Tuplas (F#) Sobrecarga de operadores (F#)	Indica el orden en que se evalúan las expresiones. Delimita una tupla. Se utiliza en las definiciones de operador.
(*...*)		Delimita un comentario que podría abarcar varias líneas.
(|...|)	Modelos activos (F#)	Delimita un modelo activo. También se denomina delimitador de modelo activo.
*	Operadores aritméticos (F#) Tuplas (F#) Unidades de medida (F#)	Cuando se utiliza como un operador binario, multiplica los lados izquierdo y derecho. En los tipos, indica el emparejamiento en una tupla. Se utiliza en unidades de medida de tipos.
*?	Operadores que aceptan valores NULL (F#)	Multiplica los lados izquierdo y derecho, si el lado derecho es un tipo que acepta valores NULL.
**	Operadores aritméticos (F#)	Calcula la operación de exponenciación (x ** y significa x elevado a la potencia de y).
+	Operadores aritméticos (F#)	Si se utiliza como un operador binario, suma los lados izquierdo y derecho. Cuando se utiliza como un operador unario, indica una cantidad positiva. (Formalmente, genera el mismo valor sin modificar el signo).
+?	Operadores que aceptan valores NULL (F#)	Suma los lados izquierdo y derecho, si el lado derecho es un tipo que acepta valores NULL.
,	Tuplas (F#)	Separa los elementos de una tupla o los parámetros de tipo.
-	Operadores aritméticos (F#)	Si se utiliza como un operador binario, resta el lado derecho del lado izquierdo. Si se utiliza como un operador unario, realiza una operación de negación.
-	Operadores que aceptan valores NULL (F#)	Resta el lado derecho del lado izquierdo, si el lado derecho es un tipo que acepta valores NULL.
->	Funciones (F#) Expresiones match (F#)	En tipos de función, delimita los argumentos y valores devueltos. Genera una expresión (en expresiones de secuencia); equivalente a la palabra clave yield. Utilizado en expresiones de coincidencia.
.	Miembros (F#) Tipos primitivos (F#)	Tiene acceso a un miembro y separa los nombres individuales de un nombre completo. Especifica un separador decimal en números de punto flotante.
..	Bucles: expresión for...in (F#)	Especifica un intervalo.
.. ..	Bucles: expresión for...in (F#)	Especifica un intervalo y un incremento.
.[...]	Matrices (F#)	Tiene acceso a un elemento de matriz.
/	Operadores aritméticos (F#) Unidades de medida (F#)	Divide el lado izquierdo (numerador) entre el lado derecho (denominador). Se utiliza en unidades de medida de tipos.
/?	Operadores que aceptan valores NULL (F#)	Divide el lado izquierdo entre el lado derecho, si el lado derecho es un tipo que acepta valores NULL.
//		Indica el principio de una sola línea de comentario.
///	Documentación XML (F#)	Indica un comentario XML.
:	Funciones (F#)	En una anotación de tipo, separa un parámetro o nombre de miembro de su tipo.
::	Listas (F#) Expresiones match (F#)	Crea una lista. El elemento del lado izquierdo se anexa a la lista en el lado derecho. Se utiliza en la coincidencia de patrones para separar las partes de una lista.
:=	Celdas de referencia (F#)	Asigna un valor a una celda de referencia.
:>	Conversiones (F#)	Convierte un tipo en otro que está más arriba en la jerarquía.
:?	Expresiones match (F#)	Devuelve true si el valor coincide con el tipo especificado; de lo contrario, devuelve false (operador de prueba de tipo).
:?>	Conversiones (F#)	Convierte un tipo en otro que está por debajo en la jerarquía.
;	Sintaxis detallada (F#) Listas (F#) Registros (F#)	Separa expresiones (se usa principalmente en sintaxis detallada). Separa elementos de una lista. Separa los campos de un registro.
<	Operadores aritméticos (F#)	Calcula la operación “menor que”.
<?	Operadores que aceptan valores NULL (F#)	Calcula la operación “menor que”, si el lado derecho es un tipo que acepta valores NULL.
<<	Funciones (F#)	Compone dos funciones en orden inverso; la segunda se ejecuta primero (operador de composición hacia atrás).
<<<	Operadores bit a bit (F#)	Desplaza hacia la izquierda los bits de la cantidad del lado izquierdo, y lo hace en el número de bits especificado en el lado derecho.
<-	Valores (F#)	Asigna un valor a una variable.
<...>	Generalización automática (F#)	Delimita los parámetros de tipo.
<>	Operadores aritméticos (F#)	Devuelve true si el lado izquierdo no es igual que el lado derecho; de lo contrario, devuelve false.
<>?	Operadores que aceptan valores NULL (F#)	Calcula la operación “no es igual a” cuando el lado derecho es un tipo que acepta valores NULL.
<=	Operadores aritméticos (F#)	Devuelve true si el lado izquierdo es menor o igual que el lado derecho; de lo contrario, devuelve false.
<=?	Operadores que aceptan valores NULL (F#)	Calcula la operación “menor o igual que” cuando el lado derecho es un tipo que acepta valores NULL.
<|	Funciones (F#)	Pasa el resultado de la expresión de la derecha a la función de la izquierda (operador de canalización hacia atrás).
<||	Operators.( <|| )<'T1,'T2,'U> (Función de F#)	Pasa la tupla de dos argumentos del lado derecho a la función del lado izquierdo.
<|||	Operators.( <||| )<'T1,'T2,'T3,'U> (Función de F#)	Pasa la tupla de tres argumentos del lado derecho a la función del lado izquierdo.
<@...@>	Expresiones de código delimitadas (F#)	Delimita una expresión de código con tipos.
<@@...@@>	Expresiones de código delimitadas (F#)	Delimita una expresión de código sin tipos.
=	Operadores aritméticos (F#)	Devuelve true si el lado izquierdo es igual que el lado derecho; de lo contrario, devuelve false.
=?	Operadores que aceptan valores NULL (F#)	Calcula la operación “es igual a” cuando el lado derecho es un tipo que acepta valores NULL.
==	No es aplicable.	No se utiliza en F#. Utilice = para operaciones de igualdad.
>	Operadores aritméticos (F#)	Devuelve true si el lado izquierdo es mayor que el lado derecho; de lo contrario, devuelve false.
>?	Operadores que aceptan valores NULL (F#)	Calcula la operación “mayor que” cuando el lado derecho es un tipo que acepta valores NULL.
>>	Funciones (F#)	Compone dos funciones (operador de composición hacia delante).
>>>	Operadores bit a bit (F#)	Desplaza hacia la derecha los bits de la cantidad del lado izquierdo, y lo hace en el número de posiciones especificado en el lado derecho.
>=	Operadores aritméticos (F#)	Devuelve true si el lado derecho es menor o igual que el lado izquierdo; de lo contrario, devuelve false.
>=?	Operadores que aceptan valores NULL (F#)	Calcula la operación “mayor o igual que” cuando el lado derecho es un tipo que acepta valores NULL.
?	Parámetros y argumentos (F#)	Especifica un argumento opcional. Se usa como operador para método dinámico y llamadas de propiedad. Debe proporcionar su propia implementación.
? ... <- ...	No hay más información disponible.	Se usa como operador para establecer propiedades dinámicas. Debe proporcionar su propia implementación.
?>=, ?>, ?<=, ?<, ?=, ?<>, ?+, ?-, ?*, ?/	Operadores que aceptan valores NULL (F#)	Equivalente a los operadores correspondientes sin el prefijo ?; en la izquierda hay un tipo que acepta valores NULL.
>=?, >?, <=?, <?, =?, <>?, +?, -?, *?, /?	Operadores que aceptan valores NULL (F#)	Equivalente a los operadores correspondientes sin el sufijo ?; en la derecha hay un tipo que acepta valores NULL.
?>=?, ?>?, ?<=?, ?<?, ?=?, ?<>?, ?+?, ?-?, ?*?, ?/?	Operadores que aceptan valores NULL (F#)	Equivalente a los operadores correspondientes sin los signos de interrogación circundantes, donde ambos lados son tipos que aceptan valores NULL.
@	Listas (F#) Cadenas (F#)	Concatena dos listas. Cuando se coloca delante de un literal de cadena, indica que la cadena debe interpretarse literalmente, sin interpretación alguna de los caracteres de escape.
[...]	Listas (F#)	Delimita los elementos de una lista.
[|...|]	Matrices (F#)	Delimita los elementos de una matriz.
[<...>]	Atributos (F#)	Delimita un atributo.
\	Cadenas (F#)	Produce el escape del carácter siguiente; se utiliza en los literales de carácter y de cadena.
^	Parámetros de tipo resueltos estáticamente (F#) Cadenas (F#)	Especifica los parámetros de tipo que deben resolverse en tiempo de compilación, no en tiempo de ejecución. Concatena cadenas.
^^^	Operadores bit a bit (F#)	Calcula la operación OR exclusiva bit a bit.
_	Expresiones match (F#) Genéricos (F#)	Indica un patrón de carácter comodín. Especifica un parámetro genérico anónimo.
`	Generalización automática (F#)	Se utiliza internamente para indicar un parámetro de tipo genérico.
{...}	Secuencias (F#) Registros (F#)	Delimita expresiones de secuencia y expresiones de cálculo. Se utiliza en definiciones de registro.
|	Expresiones match (F#)	Delimita casos de coincidencia individuales, casos de unión discriminada individuales y valores de la enumeración.
||	Operadores booleanos (F#)	Calcula la operación OR booleana.
|||	Operadores bit a bit (F#)	Calcula la operación OR bit a bit.
|>	Funciones (F#)	Pasa el resultado del lado izquierdo a la función del lado derecho (operador de canalización hacia delante).
||>	Operators.( ||> )<'T1,'T2,'U> (Función de F#)	Pasa la tupla de dos argumentos del lado izquierdo a la función del lado derecho.
|||>	Operators.( |||> )<'T1,'T2,'T3,'U> (Función de F#)	Pasa la tupla de tres argumentos del lado izquierdo a la función del lado derecho.
~~	Sobrecarga de operadores (F#)	Se utiliza para declarar una sobrecarga para el operador unario de negación.
~~~	Operadores bit a bit (F#)	Calcula la operación NOT bit a bit.
~-	Sobrecarga de operadores (F#)	Se utiliza para declarar una sobrecarga para el operador unario menos.
~+	Sobrecarga de operadores (F#)	Se utiliza para declarar una sobrecarga para el operador unario más.

Precedencia de operadores

En la siguiente tabla se muestra, de menor a mayor, el orden de precedencia de operadores y otras palabras clave de expresiones del lenguaje F#. También se indica la asociatividad, si corresponde.

Operador	Asociatividad
as	Derecho
when	Derecho
| (barra vertical)	Izquierdo
;	Derecho
let	No asociativo
function, fun, match, try	No asociativo
if	No asociativo
->	Derecho
:=	Derecho
,	No asociativo
or, ||	Izquierdo
&, &&	Izquierdo
<op, >op, =, |op, &op	Izquierdo
&&&, |||, ^^^, ~~~, <<<, >>>	Izquierdo
^op	Derecho
::	Derecho
:?>, :?	No asociativo
-op, +op, (binario)	Izquierdo
*op, /op, %op	Izquierdo
**op	Derecho
f x (aplicación de función)	Izquierdo
| (coincidencia de patrones)	Derecho
operadores de prefijo (+op, -op, %, %%, &, &&, !op, ~op)	Izquierdo
.	Izquierdo
f(x)	Izquierdo
f<types>	Izquierdo

F# es compatible con la sobrecarga de operadores personalizados. Esto significa que puede definir sus propios operadores. En la tabla anterior, op puede ser cualquier secuencia válida (posiblemente vacía) de caracteres de operador, ya sea integrados o definidos por el usuario. Por lo tanto, puede utilizar esta tabla para determinar qué secuencia de caracteres se utilizará para que un operador personalizado logre alcanzar el nivel deseado de precedencia. Los caracteres . iniciales se omiten cuando el compilador determina la precedencia.

Vea también

Referencia

Sobrecarga de operadores (F#)

Otros recursos

Referencia del lenguaje F#