Olmo - Tuplas

A veces, puede ser necesario almacenar una colección de valores de diversos tipos. Elm nos da una estructura de datos llamada tupla que sirve para este propósito.

Una tupla representa una colección heterogénea de valores. En otras palabras, las tuplas permiten almacenar múltiples campos de diferentes tipos. Una tupla almacena un número fijo de valores. Las tuplas son útiles cuando desea devolver múltiples valores de diferentes tipos de una función. Estas estructuras de datos son inmutables como otros tipos en elm.

Sintaxis

(data1,data2)

A continuación se muestra un ejemplo sencillo:

> ("TuotrialsPoint",5,True,"Hyderabad")
("TuotrialsPoint",5,True,"Hyderabad") : ( String, number, Bool, String )

En las secciones siguientes, aprenderemos sobre las diferentes operaciones de tupla.

primero

Esta operación extrae el primer valor de una tupla.

Sintaxis

Tuple.first tuple_name
> Tuple.first
<function> : ( a1, a2 ) -> a1

Ilustración

> Tuple.first (10,"hello")
10 : number

segundo

los second La operación de tupla extrae el segundo valor de una tupla.

Sintaxis

Tuple.second tuple_name
> Tuple.second
<function> : ( a1, a2 ) -> a2

Ilustración

> Tuple.second (10,"hello")
"hello" : String

Lista de tuplas

Una lista puede almacenar tuplas. Si se utilizan tuplas dentro de una lista, asegúrese de que todas sean del mismo tipo de datos y tengan el mismo número de parámetros.

Ilustración

> [("hello",20),("world",30)]
[("hello",20),("world",30)] : List ( String, number )

Tupla con función

Una función puede devolver tuplas. Además, las tuplas se pueden pasar como parámetros a funciones.

Ilustración 1

El siguiente ejemplo define una función fn_checkEven. Esta función acepta un valor entero como parámetro y devuelve una tupla.

> fn_checkEven no = \
   if no%2 == 0 then \
      (True,"The no is Even")\
   else \
      (False,"No is not even")
<function> : Int -> ( Bool, String )
> fn_checkEven 10
(True,"The no is Even") : ( Bool, String )
> fn_checkEven 11
(False,"No is not even") : ( Bool, String )
>

Ilustración 2

Lo siguiente pasa una tupla como parámetro a una función.

> fn_add (a,b) = \
| a+b
<function> : ( number, number ) -> number
> fn_add (10,20)
30 : number

La función fn_add toma una tupla con 2 valores numéricos y devuelve su suma.

Desestructuración

La desestructuración implica dividir una tupla en valores individuales. Para acceder a valores individuales en una tupla con tres o más elementos, usamos la desestructuración. Aquí, asignamos cada valor en una tupla a diferentes variables. Usando _ uno puede definir marcadores de posición para valores que serán ignorados u omitidos.

Ilustración

> (first,_,_) = (10,20,30)
10 : number
> first
10 : number

Ilustración

En este ejemplo, usaremos let..in block syntax para desestructurar. El bloque let contiene las variables y el bloque in contiene expresiones que se deben evaluar y el valor que se debe devolver.

> t1 = (10,20,30)
(10,20,30) : ( number, number1, number2 )
> let \
(a,b,c) = t1 \
in\
a + b +c
60 : number

Estamos declarando las variables abc en la cláusula let y accediendo a ellas usando la cláusula in.