Elm - Liste

Les structures de données List, Tuples et Record peuvent être utilisées pour stocker une collection de valeurs.

Ce chapitre explique comment utiliser List dans Elm.

Une liste est un ensemble de valeurs homogènes. Les valeurs d'une liste doivent toutes être du même type de données.

Tenez compte des limitations suivantes lors de l'utilisation de variables pour stocker des valeurs -

Les variables sont de nature scalaire. En d'autres termes, au moment de la déclaration, une variable ne peut contenir qu'une seule valeur. Cela signifie que pour stocker n valeurs dans un programme, n déclarations de variables seront nécessaires. Par conséquent, l'utilisation de variables n'est pas faisable lorsque l'on a besoin de stocker une plus grande collection de valeurs.
Les variables d'un programme se voient allouer de la mémoire dans un ordre aléatoire, ce qui rend difficile la récupération / lecture des valeurs dans l'ordre de leur déclaration.

Syntaxe

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

Illustration

L'exemple suivant montre comment utiliser une liste dans Elm. Essayez cet exemple dans elm REPL -

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

Si nous essayons d'ajouter des valeurs de types différents dans une liste, le compilateur lancera une erreur d'incompatibilité de type. Ceci est illustré ci-dessous.

> 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

Liste des opérations

Le tableau suivant montre les opérations courantes sur une liste -

Sr. Non	Méthode	La description
1	isEmpty: List a -> Bool	vérifie si la liste est vide
2	inverse: List a -> Bool	inverse la liste d'entrée
3	length: List a -> Int	renvoie la taille de la liste
4	maximum: Liste comparable -> Peut-être, peut-être comparable	renvoie la valeur maximale
5	minimum: Liste comparable -> Peut-être, peut-être comparable	renvoie la valeur minimale
6	somme: numéro de liste -> numéro	renvoie la somme de tous les éléments de la liste
sept	produit: Numéro de liste -> numéro	vérifie si la liste est vide
8	trier: Liste comparable -> Liste comparable	trie la liste par ordre croissant
9	concat: List (List a) -> List a	fusionne un tas de listes en une seule
dix	ajouter: List a -> List a -> List a	fusionne deux listes ensemble
11	plage: Int -> Int -> List Int	renvoie une liste de nombres du début à la fin
12	filter: (a -> Bool) -> List a -> List a	filtre la liste des valeurs de la liste d'entrée
13	head: Énumérez un -> Peut-être.	renvoie le premier élément de la liste
14	tail:: List a -> Maybe.Peut-être (List a)	renvoie tous les éléments sauf la tête

est vide

Cette fonction renvoie true si une liste est vide.

Syntaxe

List.isEmpty list_name

Pour vérifier la signature de la fonction, tapez ce qui suit dans elm REPL -

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

Illustration

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

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

inverser

Cette fonction inverse la liste.

Syntaxe

List.reverse list_name

Pour vérifier la signature de la fonction, tapez ce qui suit dans elm REPL -

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

Illustration

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

longueur

Cette fonction renvoie la longueur d'une liste.

Syntaxe

List.length list_name

Pour vérifier la signature de la fonction, tapez ce qui suit dans elm REPL -

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

Illustration

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

maximum

Cette fonction renvoie l'élément maximum dans une liste non vide.

Syntaxe

List.maximum list_name

Pour vérifier la signature de la fonction, tapez ce qui suit dans elm REPL -

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

Illustration

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

le minimum

Cette fonction renvoie l'élément minimum dans une liste non vide.

Syntaxe

List.minimum list_name

Pour vérifier la signature de la fonction, tapez ce qui suit dans elm REPL -

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

Illustration

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

somme

Cette fonction renvoie la somme de tous les éléments d'une liste.

Syntaxe

List.sum list_name

Pour vérifier la signature de la fonction, tapez ce qui suit dans elm REPL -

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

Illustration

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

produit

Cette fonction renvoie le produit de tous les éléments d'une liste.

Syntaxe

List.product list_name

Pour vérifier la signature de la fonction, tapez ce qui suit dans elm REPL -

<function>  : List number ->  number

Illustration

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

Trier

Cette fonction trie les valeurs de la plus basse à la plus élevée dans une liste.

Syntaxe

List.sort list_name

Pour vérifier la signature de la fonction, tapez ce qui suit dans elm REPL -

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

Illustration

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

concat

Cette fonction concatène un tas de listes en une seule liste.

Syntaxe

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

Pour vérifier la signature de la fonction, tapez ce qui suit dans elm REPL -

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

Illustration

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

ajouter

Cette fonction rassemble deux listes.

Syntaxe

List.append [list_name1] [list_name2]

Pour vérifier la signature de la fonction, tapez ce qui suit dans elm REPL -

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

Illustration

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

L'opérateur ++ peut également être utilisé pour ajouter une liste à une autre. Ceci est illustré dans l'exemple ci-dessous -

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

intervalle

Cette fonction crée une liste de nombres, chaque élément augmentant de un. Le nombre le plus bas et le plus élevé devant figurer dans la liste est transmis à la fonction.

Syntaxe

List.range start_range end_range

Pour vérifier la signature de la fonction, tapez ce qui suit dans elm REPL -

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

Illustration

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

filtre

Cette fonction filtre un ensemble de valeurs de la liste d'entrée. Conservez uniquement les valeurs qui réussissent le test.

Syntaxe

List.filter test_function input_list

Pour vérifier la signature de la fonction, tapez ce qui suit dans elm REPL -

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

Illustration

L'exemple suivant filtre tous les nombres pairs d'une liste d'entrée

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

tête

Cette fonction renvoie le premier élément de la liste d'entrée.

Syntaxe

List.head input_list

Pour vérifier la signature de la fonction, tapez ce qui suit dans elm REPL -

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

Illustration

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

queue

Cette fonction renvoie tous les éléments après le premier dans la liste.

Syntaxe

List.tail input_list

Pour vérifier la signature de la fonction, tapez ce qui suit dans elm REPL -

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

Illustration

> 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)

Utilisation de l'opérateur Cons

L'opérateur cons (::) ajoute un élément au début d'une liste.

Illustration

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

Le nouvel élément à ajouter et le type de données des valeurs de la liste doivent correspondre. Le compilateur renvoie une erreur si les types de données ne correspondent pas.

> [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.

Les listes sont immuables

Vérifions si les listes sont immuables dans Elm. La première liste myList lorsqu'elle est concaténée avec la valeur 1 crée une nouvelle liste et est renvoyée à myListCopy . Par conséquent, si nous affichons la liste initiale, ses valeurs ne seront pas modifiées.

> 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

↰ Previous page Next page ↱

Elm - Liste

Syntaxe

Illustration

Liste des opérations

est vide

Syntaxe

Illustration

inverser

Syntaxe

Illustration

longueur

Syntaxe

Illustration

maximum

Syntaxe

Illustration

le minimum

Syntaxe

Illustration

somme

Syntaxe

Illustration

produit

Syntaxe

Illustration

Trier

Syntaxe

Illustration

concat

Syntaxe

Illustration

ajouter

Syntaxe

Illustration

intervalle

Syntaxe

Illustration

filtre

Syntaxe

Illustration

tête

Syntaxe

Illustration

queue

Syntaxe

Illustration

Utilisation de l'opérateur Cons

Illustration

Les listes sont immuables

Tutoriel ELM