Entonces, nuestro viaje a F # continúa. El siguiente artículo se centrará en los tipos de F # que pueden tener o no equivalentes .NET estándar. Esta publicación es sobre tuplas.
¿Qué son las tuplas?
Una tupla es un grupo de valores sin nombre pero ordenados, posiblemente de diferentes tipos.
Creando tuplas
Las tuplas son muy fáciles de crear, solo hacemos algo como lo que se muestra a continuación. Observe cómo creé un paquete mixto de tuplas, algunas de las cuales son números y otras son cadenas, y también podemos mezclar y combinar ambos tipos y la cantidad de valores.
let a = (1,2) let b = (1,"cat") let c = (1,"cat") let d = (1,"cat", 'c')
Tuplas universales
Las funciones que aceptan tuplas también pueden aceptar tuplas universales sin ningún problema. Un sistema de inferencia como F # manejará felizmente la inferencia de los tipos correctos para una tupla. Aquí hay un ejemplo.
let someFunction tup = let (x,y) = tup printfn "x is %A and y is %A" xy do someFunction ("cat","dog") do someFunction (11,12)
Y aquí están los resultados de la ejecución anterior, donde puede ver que la función someFunction aceptó y trabajó con varias tuplas escritas sin problemas.
Firmas de tupla
Hasta ahora, no hemos tocado la comprensión de las firmas F # en absoluto, de hecho, este es un tema al que también decidí dedicar una publicación de blog completa, ya que creo que es bastante complicado. Sin embargo, estamos ubicados donde estamos, es decir, aquí y ahora, y estamos estudiando tuplas, así que ahora solo quería demostrar cómo sería la firma de la tupla.
Supongamos que declaro las siguientes tuplas en la ventana FSI:
let a = (1,2) let b = (1,"codfather") let c = (1,"c", 12.5)
Y luego los examiné en la ventana FSI; veremos algo como esto:
val a : int * int = (1, 2) val b : int * string = (1, "codfather") val c : int * string * float = (1, "c", 12.5)
Esto es interesante, podemos ver un par de cosas aquí, a saber:
- Los paréntesis no son parte de una firma de tipo
- El sistema de tipo F # puede inferir correctamente un tipo basado en los valores contenidos en la tupla misma.
- La coma se reemplaza con "*"
Entonces la tupla cristalina se ve así:
let a = (1,2)
Tendrá la siguiente firma:
int * int
Desglose de tuplas
Entonces, vimos cómo podemos crear tuplas, pero qué hay de dividirlas o deconstruirlas en valores separados. ¿Es posible? Si por supuesto. Como antes, comencemos con algunos ejemplos:
let (a,b) = (1,2) printfn "(a,b) = (1,2), so value of 'a' should be 1, and it is =%i,\r\n 'b' should be 2, and it is =%i" ab // , , , // let (_,z) = (1,2) printfn "grabbing last value from (1,2) which is = %i" z let (a,b :string) = (1,"cat") printfn "grabbing (1,\"cat\") which has values = %i %s" ab let (a :int,b :string) = (1,"cat") printfn "grabbing (1,\"cat\") which has values = %i %s" ab let (a ,b, c) = (1,"cat", 'c') printfn "grabbing (1,\"cat\",'c') which has values = %i %s %c" abc let first = fst (1, 2) printfn "grabbing fst from (1,2) which has values = %i" first let second = snd (1, 2) printfn "grabbing 2nd from (1,2) which has values = %i" second
Los resultados se imprimen en una ventana de consola estándar, de la siguiente manera:
Usando Let
Pero, ¿cómo obtuvimos las partes individuales? Bueno, todo lo que necesitas es el código anterior, pero veamos un ejemplo. Supongamos que tenemos una tupla como esta:
(1,2)
Y quería obtener los valores de ambos "valores" de la tupla vinculados a algunos valores individuales nuevos, podríamos hacer esto:
let (a,b) = (1,2)
También podemos seleccionar solo aquellos valores que realmente necesitamos, lo que se hace utilizando un comodín para las partes no deseadas. Lo que garantiza la ausencia de valor vinculante innecesario. Aquí hay un ejemplo:
let (_,z) = (1,2)
Usando las funciones de tupla incorporadas
También hay soporte incorporado para obtener el primer y el segundo valor de una tupla. Qué se puede hacer usando las funciones "
fst " y "
snd ". No hay soporte para nada más que el segundo elemento (estos son probablemente los casos más comunes). "
Fst " y "
snd " se pueden usar de la siguiente manera:
let first = fst (1, 2) let second = snd (1, 2)
Ahora quiero llamar su atención sobre un caso especial en el que podemos tener una discrepancia con el número de valores que estamos tratando de explotar en valores individuales. Entonces esto será algo así como un ejemplo aquí:
let (a ,b) = (1,"cat", 'c')
Puede ver que la tupla en sí contiene 3 valores, pero el enlace Let tiene solo 2 valores, por lo que el compilador nos advierte sobre esto, como puede ver en la captura de pantalla a continuación:
Creando nuevas tuplas
Es posible que desee crear nuevas tuplas a partir de tuplas existentes, es bastante simple, aquí hay un ejemplo:
let oldOne = (1,2) let (x,y) = oldOne let newOne = (x+1,y+1) printfn "original = %A, and we did this (x+1,y+1)\r\n to obtain newOne = %A" oldOne newOne
Comparación de tuplas
Las tuplas se consideran iguales solo si
- Tienen el mismo número de valores.
- TODOS los valores se consideran iguales (obviamente, pueden ser métodos Iguales personalizados o implementaciones IEquatable personalizadas y similares)
Veamos un ejemplo simple.
printfn "(1,2) = (3,4) =% b" ((1,2) = (3,4)) printfn "(1,2) = (1,2) =% b" ((1,2) = (1,2)) printfn "('a', 'b') = ('a', 'b') =% b" (('a', 'b') = ('a', 'b')) printfn "('a', 'b') = ('a', 'c') =% b" (('a', 'b') = ('a', 'c'))
De hecho, si sus tuplas tienen diferentes longitudes (el número de elementos) e intenta compararlas utilizando el operador de igualdad "=", recibirá una advertencia:
Patrones de coincidencia de tuplas
Todavía no hemos tratado con patrones coincidentes, pero luego veremos una publicación completa sobre este tema. Mientras tanto, solo sepa que esta es una manera de hacer coincidir los parámetros de entrada nuevamente. Puede hacer esto para las tuplas, que se hace de la siguiente manera:
let someFunction tup = match tup with | 1,2 -> printfn "you passed (1,2)" | _,_ -> printfn "you passed some other tuple" do someFunction (11,12) do someFunction (4,5) do someFunction (1,2) do someFunction (13,23)
