Tuplas
Una tupla es una agrupación de valores sin nombre pero ordenados, posiblemente de tipos diferentes. Las tuplas pueden ser tipos de referencia o estructuras.
Sintaxis
(element, ... , element)
struct(element, ... ,element )
Comentarios
Cada elemento de la sintaxis anterior puede ser cualquier expresión de F# válida.
Ejemplos
Entre los ejemplos de tuplas se incluyen pares, triples, entre otros, de los mismos tipos o diferentes. En el código siguiente se muestran algunos ejemplos.
(1, 2)
// Triple of strings.
("one", "two", "three")
// Tuple of generic types.
(a, b)
// Tuple that has mixed types.
("one", 1, 2.0)
// Tuple of integer expressions.
(a + 1, b + 1)
// Struct Tuple of floats
struct (1.025f, 1.5f)
Obtener valores individuales
Puede usar la coincidencia de patrones para tener acceso a los elementos de tupla y asignar nombres, como se muestra en el código siguiente.
let print tuple1 =
match tuple1 with
| (a, b) -> printfn "Pair %A %A" a b
También puede deconstruir una tupla mediante la coincidencia de patrones fuera de una expresión a match través del let enlace:
let (a, b) = (1, 2)
// Or as a struct
let struct (c, d) = struct (1, 2)
O bien, puede crear coincidencias de patrones en tuplas como entradas para las funciones:
let getDistance ((x1,y1): float*float) ((x2,y2): float*float) =
// Note the ability to work on individual elements
(x1*x2 - y1*y2)
|> abs
|> sqrt
Si solo necesita un elemento de la tupla, se puede usar el carácter comodín (el carácter de subrayado) para evitar la creación de un nuevo nombre para un valor que no necesita.
let (a, _) = (1, 2)
Copiar elementos de una tupla de referencia en una tupla de estructura también es sencillo:
// Create a reference tuple
let (a, b) = (1, 2)
// Construct a struct tuple from it
let struct (c, d) = struct (a, b)
Las funciones fst y snd (solo tuplas de referencia) devuelven el primer y segundo elemento de una tupla, respectivamente.
let c = fst (1, 2)
let d = snd (1, 2)
No hay ninguna función integrada que devuelva el tercer elemento de un triple, pero puede escribir fácilmente uno como se indica a continuación.
let third (_, _, c) = c
Por lo general, es mejor usar la coincidencia de patrones para acceder a elementos de tupla individuales.
Uso de tuplas
Las tuplas proporcionan una manera cómoda de devolver varios valores de una función, como se muestra en el ejemplo siguiente. En este ejemplo se realiza la división de enteros y se devuelve el resultado redondeado de la operación como primer miembro de un par de tuplas y el resto como segundo miembro del par.
let divRem a b =
let x = a / b
let y = a % b
(x, y)
Las tuplas también se pueden usar como argumentos de función cuando se quiere evitar la asociación implícita de argumentos de función implícitos en la sintaxis de función habitual.
let sumNoCurry (a, b) = a + b
La sintaxis habitual para definir la función permite definir una función que es la aplicación parcial del primer argumento de la función, como se muestra let sum a b = a + b en el código siguiente.
let sum a b = a + b
let addTen = sum 10
let result = addTen 95
// Result is 105.
El uso de una tupla como parámetro deshabilita el uso de una tupla. Para obtener más información, vea "Aplicación parcial de argumentos" en Functions.
Nombres de tipos de tupla
Al escribir el nombre de un tipo que es una tupla, se usa el * símbolo para separar elementos. Para una tupla que consta de , y , como , el tipo int float se string (10, 10.0, "ten") escribiría como se muestra a continuación.
int * float * string
Tenga en cuenta que los paréntesis externos son obligatorios al crear un alias de tipo para un tipo de tupla de estructura.
type TupleAlias = string * float
type StructTupleAlias = (struct (string * float))
Interoperación con tuplas de C#
C# 7.0 introdujo tuplas en el lenguaje. Las tuplas en C# son estructuras y son equivalentes a las tuplas de estructura en F#. Si necesita interoperar con C#, debe usar tuplas de estructura.
Esto es fácil de hacer. Por ejemplo, imagine que tiene que pasar una tupla a una clase de C# y, a continuación, consumir su resultado, que también es una tupla:
namespace CSharpTupleInterop
{
public static class Example
{
public static (int, int) AddOneToXAndY((int x, int y) a) =>
(a.x + 1, a.y + 1);
}
}
En el código de F#, puede pasar una tupla de struct como parámetro y consumir el resultado como una tupla de estructura.
open TupleInterop
let struct (newX, newY) = Example.AddOneToXAndY(struct (1, 2))
// newX is now 2, and newY is now 3
Conversión entre tuplas de referencia y tuplas de estructura
Dado que las tuplas de referencia y las tuplas de estructura tienen una representación subyacente completamente diferente, no se pueden convertir implícitamente. Es decir, el código como el siguiente no se compilará:
// Will not compile!
let (a, b) = struct (1, 2)
// Will not compile!
let struct (c, d) = (1, 2)
// Won't compile!
let f(t: struct(int*int)): int*int = t
Debe crear coincidencias de patrones en una tupla y construir la otra con las partes constituyentes. Por ejemplo:
// Pattern match on the result.
let (a, b) = (1, 2)
// Construct a new tuple from the parts you pattern matched on.
let struct (c, d) = struct (a, b)
Forma compilada de tuplas de referencia
En esta sección se explica la forma de las tuplas cuando se compilan. La información aquí no es necesaria para leer a menos que tenga como destino .NET Framework 3.5 o inferior.
Las tuplas se compilan en objetos de uno de varios tipos genéricos, todos denominados , que se sobrecargan en la aridad o en el número de System.Tuple parámetros de tipo. Los tipos de tupla aparecen con este formato cuando se ven desde otro lenguaje, como C# o Visual Basic, o cuando se usa una herramienta que no conoce las construcciones de F#. Los Tuple tipos se introdujeron en .NET Framework 4. Si tiene como destino una versión anterior de .NET Framework, el compilador usa versiones de de la System.Tuple versión 2.0 de la biblioteca principal de F#. Los tipos de esta biblioteca solo se usan para las aplicaciones que tienen como destino las versiones 2.0, 3.0 y 3.5 de .NET Framework. El reenvío de tipos se usa para garantizar la compatibilidad binaria entre .NET Framework 2.0 y .NET Framework componentes de 4 F#.
Forma compilada de tuplas de estructura
Las tuplas de estructura (por ejemplo, ), son fundamentalmente diferentes struct (x, y) de las tuplas de referencia. Se compilan en el ValueTuple tipo , sobrecargados por arity o el número de parámetros de tipo. Son equivalentes a las tuplas de C# 7.0 y Visual Basic tuplas de 2017e interoperan bidireccionalmente.