Referencia de símbolos y operadores (F#)

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

Tabla de símbolos y operadores

En la tabla siguiente se describen los símbolos usados en el lenguaje F#, se incluyen vínculos a temas que proporcionan más información y se describen brevemente algunos de los usos de los símbolos.Los símbolos se muestran en el orden en que aparecen en el 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 de su comportamiento, controlado por un flujo de trabajo.
!=	No es aplicable	No se usa en F#.Use <> para las operaciones de desigualdad.
"	Literales (F#) Cadenas (F#)	Delimita una cadena de texto.
"""	Cadenas (F#)	Delimita una cadena de texto textual.Diferencia de @"..." en que puede indicar uno solo mediante un escape de la cadena.
#	Directivas de compilador (F#) Tipos flexibles (F#)	Se usa como prefijo de una directiva de preprocesador o de compilador; por ejemplo, #light. Cuando se usa con un tipo, indica un tipo flexible, que hace referencia a un tipo o cualquiera de sus tipos derivados.
$	No hay más información disponible.	Se usa internamente para determinados nombres de variable y de función generados por el compilador.
%	Operadores aritméticos (F#) Expresiones de código delimitadas (F#)	Calcula el resto de la división de enteros.Se utiliza para unir expresiones delimitadas.
%?	Operadores que aceptan valores NULL (F#)	Calcula el resto entero, al lado derecho es un tipo que acepta valores NULL.
&	Expresiones match (F#)	Calcula la dirección de un valor mutable, que se usa al interoperar con otros lenguajes. Se usa en los modelos 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 un único carácter. 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 legal, como una palabra clave del lenguaje.
( )	Tipo unit (F#)	Representa el valor único del tipo unit.
(...)	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 usa como operador binario, multiplica el lado izquierdo y el lado derecho. En los tipos, indica el emparejamiento en una tupla. Se usa en los tipos de unidades de medida.
*?	Operadores que aceptan valores NULL (F#)	Multiplica los lados izquierdo y derecho, al 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 y).
+	Operadores aritméticos (F#)	Cuando se usa como operador binario, suma el lado izquierdo y el lado derecho. Cuando se usa como operador unario, indica una cantidad positiva.(Formalmente, genera el mismo valor sin modificar el signo.)
+?	Operadores que aceptan valores NULL (F#)	Agrega los lados izquierdo y derecho, al 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#)	Cuando se usa como operador binario, resta el lado derecho del lado izquierdo. Cuando se usa como operador unario, realiza una operación de negación.
-	Operadores que aceptan valores NULL (F#)	Resta el lado derecho del lado izquierdo, al lado derecho es un tipo que acepta valores NULL.
->	Funciones (F#) Expresiones match (F#)	En los tipos de función, delimita los argumentos y valores devueltos. Genera una expresión (en expresiones de secuencia); es equivalente a la palabra clave yield. Se usa en expresiones de coincidencia.
.	Miembros (F#) Tipos primitivos (F#)	Obtiene 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#)	Obtiene 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 usa en los tipos de unidades de medida.
/?	Operadores que aceptan valores NULL (F#)	Divide el lado izquierdo del lado derecho, cuando el lado derecho es un tipo que acepta valores NULL.
//		Indica el principio de un comentario de una sola línea.
///	Documentación XML (F#)	Indica un comentario XML.
:	Funciones (F#)	En una anotación de tipo, separa un nombre de parámetro o de miembro de su tipo.
::	Listas (F#) Expresiones match (F#)	Crea una lista.El elemento del lado izquierdo se anexa a la lista del lado derecho. Se usa en la coincidencia de modelos para separar los elementos de una lista.
:=	Celdas de referencia (F#)	Asigna un valor a una celda de referencia.
:>	Conversiones (F#)	Convierte un tipo en otro de un nivel superior de la jerarquía.
:?	Expresiones match (F#)	Devuelve true si el valor coincide con el tipo especificado; de lo contrario, devuelve false (operador de comprobación de tipos).
:?>	Conversiones (F#)	Convierte un tipo en otro de un nivel inferior de la jerarquía.
;	Sintaxis detallada (F#) Listas (F#) Registros (F#)	Separa expresiones (se usa principalmente en sintaxis detallada). Separa los 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 menos que la operación, al lado derecho es un tipo que acepta valores NULL.
<<	Funciones (F#)	Realiza la composición de dos funciones en orden inverso; la segunda función se ejecuta en primer lugar (operador de composición hacia atrás).
<<<	Operadores bit a bit (F#)	Desplaza los bits de la cantidad del lado izquierdo hacia la izquierda 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 “menor o igual que” la operación cuando el lado derecho es un tipo que acepta valores NULL.
<|	Funciones (F#)	Pasa el resultado de la expresión del lado derecho a la función del lado izquierdo (operador de canalización hacia atrás).
<||	Operators.( <|| )<'T1,'T2,'U> (Función de F#)	Pasa la tupla de dos argumentos en el lado derecho a la función del lado izquierdo.
<|||	Operators.( <||| )<'T1,'T2,'T3,'U> (Función de F#)	Pasa la tupla de tres argumentos en el lado derecho a la función del lado izquierdo.
<@...@>	Expresiones de código delimitadas (F#)	Delimita una expresión de código con tipo.
<@@...@@>	Expresiones de código delimitadas (F#)	Delimita una expresión de código sin tipo.
=	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 “igual que” cuando el lado derecho es un tipo que acepta valores NULL.
==	No es aplicable	No se usa en F#.Use = para las 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 el “greather que la operación cuando el lado derecho es un tipo que acepta valores NULL.
>>	Funciones (F#)	Realiza la composición de dos funciones (operador de composición hacia delante)
>>>	Operadores bit a bit (F#)	Desplaza los bits de la cantidad del lado izquierdo hacia la derecha el número de posiciones especificado en el lado derecho.
>=	Operadores aritméticos (F#)	Devuelve true si el lado derecho es mayor o igual que el lado izquierdo; de lo contrario, devuelve false.
>=?	Operadores que aceptan valores NULL (F#)	Calcula “mayor o la operación de igual” 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 las llamadas a propiedades y métodos dinámicos.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#)	Equivale a los operadores correspondientes sin?prefijo, donde es un tipo que acepta valores NULL a la izquierda.
>=?, >?, <=?, <?, =?, <>?, +?, -?, *?, /?	Operadores que aceptan valores NULL (F#)	Equivale a los operadores correspondientes sin?sufijo, donde es un tipo que acepta valores NULL a la derecha.
?>=?, ?>?, ?<=?, ?<?, ?=?, ?<>?, ?+?, ?-?, ?*?, ?/?	Operadores que aceptan valores NULL (F#)	Equivalente a los operadores correspondientes sin signos de interrogación adyacentes, donde tipos ambos lados que acepta 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 y que no deben interpretarse 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#)	Carácter de escape que invoca una interpretación alternativa del carácter siguiente; se utiliza en 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 y 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 modelo de caracteres 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 computación. Se utiliza en definiciones de registro.
|	Expresiones match (F#)	Delimita casos de coincidencia individuales, casos de unión discriminada individuales y valores de 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 en el lado izquierdo a la función en el lado derecho.
|||>	Operators.( |||> )<'T1,'T2,'T3,'U> (Función de F#)	Pasa la tupla de tres argumentos en el lado izquierdo a la función en el lado derecho.
~~	Sobrecarga de operadores (F#)	Se utiliza para declarar una sobrecarga del 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 del operador unario menos.
~+	Sobrecarga de operadores (F#)	Se utiliza para declarar una sobrecarga del operador unario más.

Precedencia de operadores

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

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

F# admite la sobrecarga de operadores personalizada.Esto significa que el usuario puede definir sus propios operadores.En la tabla anterior, op puede ser cualquier secuencia válida (puede que vacía) de caracteres de operador, ya sea integrada o definida por el usuario.Por consiguiente, se puede usar esta tabla para determinar la secuencia de caracteres que debe utilizarse para que un operador personalizado tenga el nivel de prioridad deseado.Se omiten los caracteres . iniciales cuando el compilador determina la prioridad.

Vea también

Referencia

Sobrecarga de operadores (F#)

Otros recursos

Referencia del lenguaje F#