Olmo - Lista

Las estructuras de datos List, Tuples y Record se pueden utilizar para almacenar una colección de valores.

Este capítulo trata sobre cómo usar List en Elm.

Una lista es una colección de valores homogéneos. Todos los valores de una lista deben ser del mismo tipo de datos.

Tenga en cuenta las siguientes limitaciones al utilizar variables para almacenar valores:

• Las variables son de naturaleza escalar. En otras palabras, en el momento de la declaración, una variable solo puede contener un valor. Esto significa que para almacenar n valores en un programa, se necesitarán n declaraciones de variables. Por tanto, el uso de variables no es factible cuando se necesita almacenar una colección mayor de valores.

• A las variables de un programa se les asigna memoria en orden aleatorio, lo que dificulta la recuperación / lectura de los valores en el orden de su declaración.

Sintaxis

List_name = [value1,value2,value3.....valuen]

Ilustración

El siguiente ejemplo muestra cómo usar una lista en Elm. Pruebe este ejemplo en elm REPL -

> myList1 = [10,20,30]
[10,20,30] : List number
> myList2 = ["hello","world"]
["hello","world"] : List String

Si intentamos agregar valores de diferentes tipos en una lista, el compilador arrojará un error de falta de coincidencia de tipos. Esto se muestra a continuación.

> myList = [1,"hello"]
-- TYPE MISMATCH 
--------------------------------------------- 
repl-temp-000.elm

The 1st and 2nd entries in this list are different types of values.

4| [1,"hello"]
^^^^^^^
The 1st entry has this type:
   number
But the 2nd is:
   String

Operaciones de lista

La siguiente tabla muestra las operaciones comunes en una lista:

No Señor	Método	Descripción
1	isEmpty: Lista a -> Bool	comprueba si la lista está vacía
2	reverso: Lista a -> Bool	invierte la lista de entrada
3	longitud: Lista a -> Int	devuelve el tamaño de la lista
4	máximo: Lista comparable -> Quizás. Quizás comparable	devuelve el valor máximo
5	mínimo: Lista comparable -> Quizás. Quizás comparable	devuelve el valor mínimo
6	suma: Número de lista -> número	devuelve la suma de todos los elementos en la lista
7	producto: Número de lista -> número	comprueba si la lista está vacía
8	sort: Lista comparable -> Lista comparable	ordena la lista en orden ascendente
9	concat: Lista (Lista a) -> Lista a	fusiona un montón de listas en una
10	añadir: Lista a -> Lista a -> Lista a	fusiona dos listas juntas
11	rango: Int -> Int -> List Int	devuelve una lista de números de principio a fin
12	filtro: (a -> Bool) -> Lista a -> Lista a	filtra la lista de valores de la lista de entrada
13	cabeza: Lista a -> Quizás.	devuelve el primer elemento de la lista
14	tail:: Lista a -> Quizás. Quizás (Lista a)	devuelve todos los elementos excepto el encabezado

esta vacio

Esta función devuelve verdadero si una lista está vacía.

Sintaxis

List.isEmpty list_name

Para verificar la firma de la función, escriba lo siguiente en elm REPL:

> List.isEmpty
<function> : List a -> Bool

Ilustración

> List.isEmpty
<function> : List a -> Bool

> List.isEmpty [10,20,30]
False : Bool

contrarrestar

Esta función invierte la lista.

Sintaxis

List.reverse list_name

Para verificar la firma de la función, escriba lo siguiente en elm REPL:

> List.reverse
<function> : List a -> List a

Ilustración

> List.reverse [10,20,30]
[30,20,10] : List number

longitud

Esta función devuelve la longitud de una lista.

Sintaxis

List.length list_name

Para verificar la firma de la función, escriba lo siguiente en elm REPL:

> List.length
<function> : List a -> Int

Ilustración

> List.length [10,20,30]
3 : Int

máximo

Esta función devuelve el elemento máximo en una lista no vacía.

Sintaxis

List.maximum list_name

Para verificar la firma de la función, escriba lo siguiente en elm REPL:

> List.maximum
<function> : List comparable -> Maybe.Maybe comparable

Ilustración

> List.maximum [10,20,30]
Just 30 : Maybe.Maybe number
> List.maximum []
Nothing : Maybe.Maybe comparable

mínimo

Esta función devuelve el elemento mínimo en una lista no vacía.

Sintaxis

List.minimum list_name

Para verificar la firma de la función, escriba lo siguiente en elm REPL:

> List.minimum
<function> : List comparable -> Maybe.Maybe comparable

Ilustración

> List.minimum [10,20,30]
Just 10 : Maybe.Maybe number

suma

Esta función devuelve la suma de todos los elementos de una lista.

Sintaxis

List.sum list_name

Para verificar la firma de la función, escriba lo siguiente en elm REPL:

> List.sum
<function> : List number -> number

Ilustración

> List.sum [10,20,30]
60 : number

producto

Esta función devuelve el producto de todos los elementos de una lista.

Sintaxis

List.product list_name

Para verificar la firma de la función, escriba lo siguiente en elm REPL:

<function>  : List number ->  number

Ilustración

List.product [10,20,30]
6000 : number

ordenar

Esta función ordena los valores de menor a mayor en una lista.

Sintaxis

List.sort list_name

Para verificar la firma de la función, escriba lo siguiente en elm REPL:

> List.sort
<function> : List comparable -> List comparable

Ilustración

> List.sort [10,20,30]
[10,20,30] : List number

concat

Esta función concatena un montón de listas en una sola lista.

Sintaxis

List.concat [ [list_name1],[list_name2],[list_name3],.....[list_nameN] ]

Para verificar la firma de la función, escriba lo siguiente en elm REPL:

> List.concat
<function> : List (List a) -> List a

Ilustración

> List.concat [[10,20], [30,40],[50,60]]
[10,20,30,40,50,60] : List number

adjuntar

Esta función junta dos listas.

Sintaxis

List.append [list_name1] [list_name2]

Para verificar la firma de la función, escriba lo siguiente en elm REPL:

> List.append
<function> : List a -> List a -> List a

Ilustración

> List.append [10,20] [30,40]
[10,20,30,40] : List number

El operador ++ también se puede utilizar para agregar una lista a otra. Esto se muestra en el siguiente ejemplo:

> [10.1,20.2] ++ [30.3,40.4]
[10.1,20.2,30.3,40.4] : List Float

rango

Esta función crea una lista de números, cada elemento se incrementa en uno. El número más bajo y más alto que debería estar en la lista se pasa a la función.

Sintaxis

List.range start_range end_range

Para verificar la firma de la función, escriba lo siguiente en elm REPL:

> List.range
<function> : Int -> Int -> List Int

Ilustración

> List.range 1 10
[1,2,3,4,5,6,7,8,9,10] : List Int

filtrar

Esta función filtra un conjunto de valores de la lista de entrada. Conserve solo los valores que pasen la prueba.

Sintaxis

List.filter test_function input_list

Para verificar la firma de la función, escriba lo siguiente en elm REPL:

> List.filter
<function> : (a -> Bool) -> List a -> List a

Ilustración

El siguiente ejemplo filtra todos los números pares de una lista de entrada

> List.filter (\n -> n%2==0) [10,20,30,55]
[10,20,30] : List Int

cabeza

Esta función devuelve el primer elemento de la lista de entrada.

Sintaxis

List.head input_list

Para verificar la firma de la función, escriba lo siguiente en elm REPL:

> List.head
<function> : List a -> Maybe.Maybe a

Ilustración

> List.head [10,20,30,40]
Just 10 : Maybe.Maybe number
> List.head []
Nothing : Maybe.Maybe a

cola

Esta función devuelve todos los elementos después del primero en la lista.

Sintaxis

List.tail input_list

Para verificar la firma de la función, escriba lo siguiente en elm REPL:

> List.tail
<function> : List a -> Maybe.Maybe (List a)

Ilustración

> List.tail [10,20,30,40,50]
Just [20,30,40,50] : Maybe.Maybe (List number)
> List.tail [10]
Just [] : Maybe.Maybe (List number)
> List.tail []
Nothing : Maybe.Maybe (List a)

Uso del operador Contras

El operador cons (::) agrega un elemento al principio de una lista.

Ilustración

> 10::[20,30,40,50]
[10,20,30,40,50] : List number

El nuevo elemento que se agregará y el tipo de datos de los valores en la lista deben coincidir. El compilador arroja un error si los tipos de datos no coinciden.

> [1,2,3,4]::[5,6,7,8]
-- TYPE MISMATCH ---------------------------------
------------ repl-temp-000.elm

The right side of (::) is causing a type mismatch.

3| [1,2,3,4]::[5,6,7,8]
			  ^^^^^^^^^
(::) is expecting the right side to be a:

   List (List number)

But the right side is:

   List number
Hint: With operators like (::) I always check the left side first. If it seems fine, 
I assume it is correct and check the right side. So the 
problem may be in how the left and right arguments interact.

Las listas son inmutables

Comprobemos si las listas son inmutables en Elm. La primera lista myList cuando se concatena con el valor 1 crea una nueva lista y se devuelve a myListCopy . Por lo tanto, si mostramos la lista inicial, sus valores no cambiarán.

> myList = [10,20,30]
[10,20,30] : List number
> myListCopy = 1::myList
[1,10,20,30] : List number
> myList
[10,20,30] : List number
>myList == myListCopy
False : Bool