Elm Language
Collecte de données: tuples, enregistrements et dictionnaires

Tuples

Les tuples sont des listes ordonnées de valeurs de tout type.

(True, "Hello!", 42)

Il est impossible de modifier la structure d'un tuple ou de mettre à jour la valeur.

Les tuples dans Elm sont considérés comme un type de données primitif, ce qui signifie que vous n'avez pas besoin d'importer de modules pour utiliser Tuples.

Accéder aux valeurs

Le module Basics a deux fonctions d'aide pour accéder aux valeurs d'un Tuple d'une longueur de deux ( a, b ) sans utiliser de correspondance de motif:

fst (True, "Hello!") -- True
snd (True, "Hello!") -- "Hello!"

Les valeurs d'accès des tuples de plus grande longueur se font par correspondance de motif.

Correspondance de motif

Les tuples sont extrêmement utiles en combinaison avec la correspondance de motif:

toggleFlag: (Sting, Bool) -> (Sting, Bool)
toggleFlag (name, flag) =
    (name, not flag)

Remarques sur les tuples

Les tuples contiennent moins de 7 valeurs de type de données comparable

Dictionnaires

Les dictionnaires sont implémentés dans une bibliothèque principale de Dict .

Un dictionnaire mappant des clés uniques sur des valeurs. Les clés peuvent être de type comparable. Cela inclut Int, Float, Time, Char, String et des tuples ou des listes de types comparables.

Les opérations d'insertion, de suppression et de requête prennent toutes l'heure O (log n).

Contrairement aux tuples et aux enregistrements, les dictionnaires peuvent modifier leur structure. En d'autres termes, il est possible d'ajouter et de supprimer des clés.

Il est possible de mettre à jour une valeur par une clé.

Il est également possible d'accéder ou de mettre à jour une valeur à l'aide de clés dynamiques.

Accéder aux valeurs

Vous pouvez extraire une valeur d'un dictionnaire en utilisant une fonction Dict.get .

Définition de type de Dict.get :

get : comparable -> Dict comparable v -> Maybe v

Il renverra toujours Maybe v , car il est possible d'essayer d'obtenir une valeur par une clé inexistante.

import Dict

initialUsers =
      Dict.fromList [ (1, "John"), (2, "Brad") ]

getUserName id =
  initialUsers
  |> Dict.get id
  |> Maybe.withDefault "Anonymous"
  
getUserName 2 -- "Brad"
getUserName 0 -- "Anonymous"

Mise à jour des valeurs

L'opération de mise à jour sur un dictionnaire est effectuée à l'aide de Maybe.map , car la clé demandée peut être absente.

import Dict

initialUsers =
  Dict.fromList [ (1, "John"), (2, "Brad") ]

updatedUsers =
  Dict.update 1 (Maybe.map (\name -> name ++ " Johnson")) initialUsers

Maybe.withDefault "No user" (Dict.get 1 updatedUsers) -- "John Johnson"

Des dossiers

Record est un ensemble de paires clé-valeur.

greeter =
    { isMorning: True
    , greeting: "Good morning!"
    }

Il est impossible d'accéder à une valeur par une clé inexistante.

Il est impossible de modifier dynamiquement la structure de Record.

Les enregistrements vous permettent uniquement de mettre à jour les valeurs par des clés constantes.

Accéder aux valeurs

Il est impossible d'accéder aux valeurs à l'aide d'une clé dynamique pour éviter d'éventuelles erreurs d'exécution:

isMorningKeyName =
    "isMorning "


greeter[isMorningKeyName] -- Compiler error
greeter.isMorning -- True

La syntaxe alternative pour accéder à la valeur vous permet d'extraire la valeur, tout en parcourant l'enregistrement:

greeter
    |> .greeting
    |> (++) " Have a nice day!" -- "Good morning! Have a nice day!"

Extension de types

Parfois, vous souhaitez que la signature d'un paramètre contraigne les types d'enregistrement que vous transmettez à des fonctions. L'extension des types d'enregistrement rend l'idée de supertypes inutile. L'exemple suivant montre comment ce concept peut être implémenté:

type alias Person =
    { name : String
    }


type alias Animal =
    { name : String
    }


peter : Person
peter =
    { name = "Peter" }


dog : Animal
dog =
    { name = "Dog" }


getName : { a | name : String } -> String
getName livingThing =
    livingThing.name


bothNames : String
bothNames =
    getName peter ++ " " ++ getName dog

Nous pourrions même aller plus loin dans les enregistrements et faire quelque chose comme:

type alias Named a = { a | name : String }
type alias Totalled a = { a | total : Int }


totallyNamed : Named ( Totalled { age : Int })
totallyNamed =
  { name = "Peter Pan"
  , total = 1337
  , age = 14
  }

Nous avons maintenant des moyens de faire passer ces types partiels dans des fonctions:

changeName : Named a -> String -> Named a
changeName a newName =
  { a | name = newName }
  
cptHook = changeName totallyNamed "Cpt. Hook" |> Debug.log "who?"

Mise à jour des valeurs

Elm a une syntaxe spéciale pour les mises à jour des enregistrements:

model =
    { id: 1
    , score: 0
    , name: "John Doe"
    }


update model =
    { model
       | score = model.score + 100
       | name = "John Johnson"
    }